Merge pull request #109 from 0xProject/fees-balance-allowance-validation

Fees balance allowance validation

12 files changed, 291 insertions, 165 deletions

diff --git a/src/0x.ts b/src/0x.ts
index eaaa67d59..b581d242d 100644
--- a/src/0x.ts
+++ b/src/0x.ts
@@ -3,7 +3,6 @@ import * as BigNumber from 'bignumber.js';
 import {bigNumberConfigs} from './bignumber_config';
 import * as ethUtil from 'ethereumjs-util';
 import contract = require('truffle-contract');
-import * as Web3 from 'web3';
 import findVersions = require('find-versions');
 import compareVersions = require('compare-versions');
 import {Web3Wrapper} from './web3_wrapper';
diff --git a/src/contract_wrappers/exchange_wrapper.ts b/src/contract_wrappers/exchange_wrapper.ts
index 9cc29e286..2ddd63422 100644
--- a/src/contract_wrappers/exchange_wrapper.ts
+++ b/src/contract_wrappers/exchange_wrapper.ts
@@ -1,7 +1,6 @@
 import * as _ from 'lodash';
 import * as BigNumber from 'bignumber.js';
 import promisify = require('es6-promisify');
-import * as Web3 from 'web3';
 import {Web3Wrapper} from '../web3_wrapper';
 import {
     ECSignature,
@@ -27,16 +26,12 @@ import {
     LogErrorContractEventArgs,
     LogFillContractEventArgs,
     LogCancelContractEventArgs,
-    EventCallback,
-    ContractEventArg,
-    ExchangeContractByAddress,
-    ContractArtifact,
 } from '../types';
 import {assert} from '../utils/assert';
 import {utils} from '../utils/utils';
 import {eventUtils} from '../utils/event_utils';
+import {OrderValidationUtils} from '../utils/order_validation_utils';
 import {ContractWrapper} from './contract_wrapper';
-import {ProxyWrapper} from './proxy_wrapper';
 import {ecSignatureSchema} from '../schemas/ec_signature_schema';
 import {signedOrdersSchema} from '../schemas/signed_orders_schema';
 import {subscriptionOptsSchema} from '../schemas/subscription_opts_schema';
@@ -66,6 +61,7 @@ export class ExchangeWrapper extends ContractWrapper {
     };
     private _exchangeContractIfExists?: ExchangeContract;
     private _exchangeLogEventEmitters: ContractEventEmitter[];
+    private _orderValidationUtils: OrderValidationUtils;
     private _tokenWrapper: TokenWrapper;
     private static _getOrderAddressesAndValues(order: Order): [OrderAddresses, OrderValues] {
         const orderAddresses: OrderAddresses = [
@@ -88,6 +84,7 @@ export class ExchangeWrapper extends ContractWrapper {
     constructor(web3Wrapper: Web3Wrapper, tokenWrapper: TokenWrapper) {
         super(web3Wrapper);
         this._tokenWrapper = tokenWrapper;
+        this._orderValidationUtils = new OrderValidationUtils(tokenWrapper);
         this._exchangeLogEventEmitters = [];
     }
     /**
@@ -667,8 +664,9 @@ export class ExchangeWrapper extends ContractWrapper {
             throw new Error(ExchangeContractErrs.OrderFillExpired);
         }
         const zrxTokenAddress = await this._getZRXTokenAddressAsync(signedOrder.exchangeContractAddress);
-        await this._validateFillOrderBalancesAndAllowancesAndThrowIfInvalidAsync(signedOrder, fillTakerAmount,
-                                                               senderAddress, zrxTokenAddress);
+        await this._orderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+            signedOrder, fillTakerAmount, senderAddress, zrxTokenAddress,
+        );
 
         const wouldRoundingErrorOccur = await this._isRoundingErrorAsync(
             signedOrder.takerTokenAmount, fillTakerAmount, signedOrder.makerTokenAmount,
@@ -702,67 +700,6 @@ export class ExchangeWrapper extends ContractWrapper {
             throw new Error(ExchangeContractErrs.InsufficientRemainingFillAmount);
         }
     }
-    /**
-     * This method does not currently validate the edge-case where the makerToken or takerToken is also the token used
-     * to pay fees  (ZRX). It is possible for them to have enough for fees and the transfer but not both.
-     * Handling the edge-cases that arise when this happens would require making sure that the user has sufficient
-     * funds to pay both the fees and the transfer amount. We decided to punt on this for now as the contracts
-     * will throw for these edge-cases.
-     * TODO: Throw errors before calling the smart contract for these edge-cases in order to minimize
-     * the callers gas costs.
-     */
-    private async _validateFillOrderBalancesAndAllowancesAndThrowIfInvalidAsync(signedOrder: SignedOrder,
-                                                                                fillTakerAmount: BigNumber.BigNumber,
-                                                                                senderAddress: string,
-                                                                                zrxTokenAddress: string,
-    ): Promise<void> {
-
-        const makerBalance = await this._tokenWrapper.getBalanceAsync(signedOrder.makerTokenAddress,
-                                                                     signedOrder.maker);
-        const takerBalance = await this._tokenWrapper.getBalanceAsync(signedOrder.takerTokenAddress, senderAddress);
-        const makerAllowance = await this._tokenWrapper.getProxyAllowanceAsync(signedOrder.makerTokenAddress,
-                                                                              signedOrder.maker);
-        const takerAllowance = await this._tokenWrapper.getProxyAllowanceAsync(signedOrder.takerTokenAddress,
-                                                                              senderAddress);
-
-        // exchangeRate is the price of one maker token denominated in taker tokens
-        const exchangeRate = signedOrder.takerTokenAmount.div(signedOrder.makerTokenAmount);
-        const fillMakerAmountInBaseUnits = fillTakerAmount.div(exchangeRate);
-
-        if (fillTakerAmount.greaterThan(takerBalance)) {
-            throw new Error(ExchangeContractErrs.InsufficientTakerBalance);
-        }
-        if (fillTakerAmount.greaterThan(takerAllowance)) {
-            throw new Error(ExchangeContractErrs.InsufficientTakerAllowance);
-        }
-        if (fillMakerAmountInBaseUnits.greaterThan(makerBalance)) {
-            throw new Error(ExchangeContractErrs.InsufficientMakerBalance);
-        }
-        if (fillMakerAmountInBaseUnits.greaterThan(makerAllowance)) {
-            throw new Error(ExchangeContractErrs.InsufficientMakerAllowance);
-        }
-
-        const makerFeeBalance = await this._tokenWrapper.getBalanceAsync(zrxTokenAddress,
-                                                                        signedOrder.maker);
-        const takerFeeBalance = await this._tokenWrapper.getBalanceAsync(zrxTokenAddress, senderAddress);
-        const makerFeeAllowance = await this._tokenWrapper.getProxyAllowanceAsync(zrxTokenAddress,
-                                                                                 signedOrder.maker);
-        const takerFeeAllowance = await this._tokenWrapper.getProxyAllowanceAsync(zrxTokenAddress,
-                                                                                 senderAddress);
-
-        if (signedOrder.takerFee.greaterThan(takerFeeBalance)) {
-            throw new Error(ExchangeContractErrs.InsufficientTakerFeeBalance);
-        }
-        if (signedOrder.takerFee.greaterThan(takerFeeAllowance)) {
-            throw new Error(ExchangeContractErrs.InsufficientTakerFeeAllowance);
-        }
-        if (signedOrder.makerFee.greaterThan(makerFeeBalance)) {
-            throw new Error(ExchangeContractErrs.InsufficientMakerFeeBalance);
-        }
-        if (signedOrder.makerFee.greaterThan(makerFeeAllowance)) {
-            throw new Error(ExchangeContractErrs.InsufficientMakerFeeAllowance);
-        }
-    }
     private _throwErrorLogsAsErrors(logs: ContractEvent[]): void {
         const errEvent = _.find(logs, {event: 'LogError'});
         if (!_.isUndefined(errEvent)) {
diff --git a/src/contract_wrappers/proxy_wrapper.ts b/src/contract_wrappers/proxy_wrapper.ts
index c247754f8..9deed5231 100644
--- a/src/contract_wrappers/proxy_wrapper.ts
+++ b/src/contract_wrappers/proxy_wrapper.ts
@@ -1,5 +1,4 @@
 import * as _ from 'lodash';
-import {Web3Wrapper} from '../web3_wrapper';
 import {ContractWrapper} from './contract_wrapper';
 import * as ProxyArtifacts from '../artifacts/Proxy.json';
 import {ProxyContract} from '../types';
diff --git a/src/contract_wrappers/token_registry_wrapper.ts b/src/contract_wrappers/token_registry_wrapper.ts
index c9f21e46f..d15e5c4f7 100644
--- a/src/contract_wrappers/token_registry_wrapper.ts
+++ b/src/contract_wrappers/token_registry_wrapper.ts
@@ -1,7 +1,6 @@
 import * as _ from 'lodash';
 import {Web3Wrapper} from '../web3_wrapper';
 import {Token, TokenRegistryContract, TokenMetadata} from '../types';
-import {assert} from '../utils/assert';
 import {ContractWrapper} from './contract_wrapper';
 import * as TokenRegistryArtifacts from '../artifacts/TokenRegistry.json';
 
diff --git a/src/types.ts b/src/types.ts
index 974057fed..ee45acf11 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -1,4 +1,3 @@
-import * as _ from 'lodash';
 import * as Web3 from 'web3';
 
 export enum ZeroExError {
diff --git a/src/utils/assert.ts b/src/utils/assert.ts
index dab796c4e..969209208 100644
--- a/src/utils/assert.ts
+++ b/src/utils/assert.ts
@@ -3,7 +3,6 @@ import * as BigNumber from 'bignumber.js';
 import * as Web3 from 'web3';
 import {Web3Wrapper} from '../web3_wrapper';
 import {SchemaValidator} from './schema_validator';
-import {utils} from './utils';
 
 const HEX_REGEX = /^0x[0-9A-F]*$/i;
 
diff --git a/src/utils/order_validation_utils.ts b/src/utils/order_validation_utils.ts
new file mode 100644
index 000000000..8a737040c
--- /dev/null
+++ b/src/utils/order_validation_utils.ts
@@ -0,0 +1,81 @@
+import {ExchangeContractErrs, SignedOrder} from '../types';
+import {TokenWrapper} from '../contract_wrappers/token_wrapper';
+
+export class OrderValidationUtils {
+    private tokenWrapper: TokenWrapper;
+    constructor(tokenWrapper: TokenWrapper) {
+        this.tokenWrapper = tokenWrapper;
+    }
+    public async validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+        signedOrder: SignedOrder, fillTakerAmount: BigNumber.BigNumber, senderAddress: string, zrxTokenAddress: string,
+    ): Promise<void> {
+        await this.validateFillOrderMakerBalancesAllowancesThrowIfInvalidAsync(
+            signedOrder, fillTakerAmount, zrxTokenAddress,
+        );
+        await this.validateFillOrderTakerBalancesAllowancesThrowIfInvalidAsync(
+            signedOrder, fillTakerAmount, senderAddress, zrxTokenAddress,
+        );
+    }
+    private async validateFillOrderMakerBalancesAllowancesThrowIfInvalidAsync(
+        signedOrder: SignedOrder, fillTakerAmount: BigNumber.BigNumber, zrxTokenAddress: string,
+    ): Promise<void> {
+        const makerBalance = await this.tokenWrapper.getBalanceAsync(signedOrder.makerTokenAddress, signedOrder.maker);
+        const makerAllowance = await this.tokenWrapper.getProxyAllowanceAsync(
+            signedOrder.makerTokenAddress, signedOrder.maker);
+
+        const isMakerTokenZRX = signedOrder.makerTokenAddress === zrxTokenAddress;
+        // exchangeRate is the price of one maker token denominated in taker tokens
+        const exchangeRate = signedOrder.takerTokenAmount.div(signedOrder.makerTokenAmount);
+        const fillMakerAmount = fillTakerAmount.div(exchangeRate);
+
+        const requiredMakerAmount = isMakerTokenZRX ? fillMakerAmount.plus(signedOrder.makerFee) : fillMakerAmount;
+        if (requiredMakerAmount.greaterThan(makerBalance)) {
+            throw new Error(ExchangeContractErrs.InsufficientMakerBalance);
+        }
+        if (requiredMakerAmount.greaterThan(makerAllowance)) {
+            throw new Error(ExchangeContractErrs.InsufficientMakerAllowance);
+        }
+
+        if (!isMakerTokenZRX) {
+            const makerZRXBalance = await this.tokenWrapper.getBalanceAsync(zrxTokenAddress, signedOrder.maker);
+            const makerZRXAllowance = await this.tokenWrapper.getProxyAllowanceAsync(
+                zrxTokenAddress, signedOrder.maker);
+
+            if (signedOrder.makerFee.greaterThan(makerZRXBalance)) {
+                throw new Error(ExchangeContractErrs.InsufficientMakerFeeBalance);
+            }
+            if (signedOrder.makerFee.greaterThan(makerZRXAllowance)) {
+                throw new Error(ExchangeContractErrs.InsufficientMakerFeeAllowance);
+            }
+        }
+    }
+    private async validateFillOrderTakerBalancesAllowancesThrowIfInvalidAsync(
+        signedOrder: SignedOrder, fillTakerAmount: BigNumber.BigNumber, senderAddress: string, zrxTokenAddress: string,
+    ): Promise<void> {
+        const takerBalance = await this.tokenWrapper.getBalanceAsync(signedOrder.takerTokenAddress, senderAddress);
+        const takerAllowance = await this.tokenWrapper.getProxyAllowanceAsync(
+            signedOrder.takerTokenAddress, senderAddress);
+
+        const isTakerTokenZRX = signedOrder.takerTokenAddress === zrxTokenAddress;
+
+        const requiredTakerAmount = isTakerTokenZRX ? fillTakerAmount.plus(signedOrder.takerFee) : fillTakerAmount;
+        if (requiredTakerAmount.greaterThan(takerBalance)) {
+            throw new Error(ExchangeContractErrs.InsufficientTakerBalance);
+        }
+        if (requiredTakerAmount.greaterThan(takerAllowance)) {
+            throw new Error(ExchangeContractErrs.InsufficientTakerAllowance);
+        }
+
+        if (!isTakerTokenZRX) {
+            const takerZRXBalance = await this.tokenWrapper.getBalanceAsync(zrxTokenAddress, senderAddress);
+            const takerZRXAllowance = await this.tokenWrapper.getProxyAllowanceAsync(zrxTokenAddress, senderAddress);
+
+            if (signedOrder.takerFee.greaterThan(takerZRXBalance)) {
+                throw new Error(ExchangeContractErrs.InsufficientTakerFeeBalance);
+            }
+            if (signedOrder.takerFee.greaterThan(takerZRXAllowance)) {
+                throw new Error(ExchangeContractErrs.InsufficientTakerFeeAllowance);
+            }
+        }
+    }
+}
diff --git a/test/0x.js_test.ts b/test/0x.js_test.ts
index 3d9aa105b..03bf21e96 100644
--- a/test/0x.js_test.ts
+++ b/test/0x.js_test.ts
@@ -6,7 +6,6 @@ import * as BigNumber from 'bignumber.js';
 import * as Sinon from 'sinon';
 import {ZeroEx, Order} from '../src';
 import {constants} from './utils/constants';
-import {assert} from '../src/utils/assert';
 import {web3Factory} from './utils/web3_factory';
 
 chaiSetup.configure();
diff --git a/test/artifacts_test.ts b/test/artifacts_test.ts
index 04b9ecb2d..65d75f16e 100644
--- a/test/artifacts_test.ts
+++ b/test/artifacts_test.ts
@@ -3,7 +3,6 @@ import * as chai from 'chai';
 import {chaiSetup} from './utils/chai_setup';
 import HDWalletProvider = require('truffle-hdwallet-provider');
 import {ZeroEx} from '../src';
-import {web3Factory} from './utils/web3_factory';
 import {constants} from './utils/constants';
 
 chaiSetup.configure();
diff --git a/test/ether_token_wrapper_test.ts b/test/ether_token_wrapper_test.ts
index 5ed800fc7..a8186499c 100644
--- a/test/ether_token_wrapper_test.ts
+++ b/test/ether_token_wrapper_test.ts
@@ -5,7 +5,7 @@ import * as Web3 from 'web3';
 import * as BigNumber from 'bignumber.js';
 import promisify = require('es6-promisify');
 import {web3Factory} from './utils/web3_factory';
-import {ZeroEx, ZeroExError, Token} from '../src';
+import {ZeroEx, ZeroExError} from '../src';
 import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
 
 chaiSetup.configure();
diff --git a/test/exchange_wrapper_test.ts b/test/exchange_wrapper_test.ts
index 0dc67bb01..9c3da81b2 100644
--- a/test/exchange_wrapper_test.ts
+++ b/test/exchange_wrapper_test.ts
@@ -1,5 +1,4 @@
 import 'mocha';
-import * as _ from 'lodash';
 import * as chai from 'chai';
 import * as Web3 from 'web3';
 import * as BigNumber from 'bignumber.js';
@@ -204,48 +203,6 @@ describe('ExchangeWrapper', () => {
                         signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
                     )).to.be.rejectedWith(ExchangeContractErrs.OrderFillExpired);
                 });
-                describe('should throw when not enough balance or allowance to fulfill the order', () => {
-                    const balanceToSubtractFromMaker = new BigNumber(3);
-                    const lackingAllowance = new BigNumber(3);
-                    let signedOrder: SignedOrder;
-                    beforeEach('create fillable signed order', async () => {
-                        signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                            makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
-                        );
-                    });
-                    it('should throw when taker balance is less than fill amount', async () => {
-                        await zeroEx.token.transferAsync(
-                            takerTokenAddress, takerAddress, coinbase, balanceToSubtractFromMaker,
-                        );
-                        return expect(zeroEx.exchange.fillOrderAsync(
-                            signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
-                        )).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerBalance);
-                    });
-                    it('should throw when taker allowance is less than fill amount', async () => {
-                        const newAllowanceWhichIsLessThanFillAmount = fillTakerAmount.minus(lackingAllowance);
-                        await zeroEx.token.setProxyAllowanceAsync(takerTokenAddress, takerAddress,
-                            newAllowanceWhichIsLessThanFillAmount);
-                        return expect(zeroEx.exchange.fillOrderAsync(
-                            signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
-                        )).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerAllowance);
-                    });
-                    it('should throw when maker balance is less than maker fill amount', async () => {
-                        await zeroEx.token.transferAsync(
-                            makerTokenAddress, makerAddress, coinbase, balanceToSubtractFromMaker,
-                        );
-                        return expect(zeroEx.exchange.fillOrderAsync(
-                            signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
-                        )).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerBalance);
-                    });
-                    it('should throw when maker allowance is less than maker fill amount', async () => {
-                        const newAllowanceWhichIsLessThanFillAmount = fillTakerAmount.minus(lackingAllowance);
-                        await zeroEx.token.setProxyAllowanceAsync(makerTokenAddress, makerAddress,
-                            newAllowanceWhichIsLessThanFillAmount);
-                        return expect(zeroEx.exchange.fillOrderAsync(
-                            signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
-                        )).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerAllowance);
-                    });
-                });
                 it('should throw when there a rounding error would have occurred', async () => {
                     const makerAmount = new BigNumber(3);
                     const takerAmount = new BigNumber(5);
@@ -258,51 +215,6 @@ describe('ExchangeWrapper', () => {
                         signedOrder, fillTakerAmountThatCausesRoundingError, shouldCheckTransfer, takerAddress,
                     )).to.be.rejectedWith(ExchangeContractErrs.OrderFillRoundingError);
                 });
-                describe('should throw when not enough balance or allowance to pay fees', () => {
-                    const makerFee = new BigNumber(2);
-                    const takerFee = new BigNumber(2);
-                    let signedOrder: SignedOrder;
-                    beforeEach('setup', async () => {
-                        signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-                            makerTokenAddress, takerTokenAddress, makerFee, takerFee,
-                            makerAddress, takerAddress, fillableAmount, feeRecipient,
-                        );
-                    });
-                    it('should throw when maker doesn\'t have enough balance to pay fees', async () => {
-                        const balanceToSubtractFromMaker = new BigNumber(1);
-                        await zeroEx.token.transferAsync(
-                            zrxTokenAddress, makerAddress, coinbase, balanceToSubtractFromMaker,
-                        );
-                        return expect(zeroEx.exchange.fillOrderAsync(
-                            signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
-                        )).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerFeeBalance);
-                    });
-                    it('should throw when maker doesn\'t have enough allowance to pay fees', async () => {
-                        const newAllowanceWhichIsLessThanFees = makerFee.minus(1);
-                        await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, makerAddress,
-                            newAllowanceWhichIsLessThanFees);
-                        return expect(zeroEx.exchange.fillOrderAsync(
-                            signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
-                        )).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerFeeAllowance);
-                    });
-                    it('should throw when taker doesn\'t have enough balance to pay fees', async () => {
-                        const balanceToSubtractFromTaker = new BigNumber(1);
-                        await zeroEx.token.transferAsync(
-                            zrxTokenAddress, takerAddress, coinbase, balanceToSubtractFromTaker,
-                        );
-                        return expect(zeroEx.exchange.fillOrderAsync(
-                            signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
-                        )).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerFeeBalance);
-                    });
-                    it('should throw when taker doesn\'t have enough allowance to pay fees', async () => {
-                        const newAllowanceWhichIsLessThanFees = makerFee.minus(1);
-                        await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, takerAddress,
-                            newAllowanceWhichIsLessThanFees);
-                        return expect(zeroEx.exchange.fillOrderAsync(
-                            signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
-                        )).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerFeeAllowance);
-                    });
-                });
             });
             describe('successful fills', () => {
                 it('should fill a valid order', async () => {
diff --git a/test/order_validation_test.ts b/test/order_validation_test.ts
new file mode 100644
index 000000000..773a23aa7
--- /dev/null
+++ b/test/order_validation_test.ts
@@ -0,0 +1,203 @@
+import * as chai from 'chai';
+import * as Web3 from 'web3';
+import * as BigNumber from 'bignumber.js';
+import promisify = require('es6-promisify');
+import {chaiSetup} from './utils/chai_setup';
+import {web3Factory} from './utils/web3_factory';
+import {ZeroEx, SignedOrder, Token, ExchangeContractErrs} from '../src';
+import {TokenUtils} from './utils/token_utils';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
+import {FillScenarios} from './utils/fill_scenarios';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle();
+
+describe('OrderValidationUtils', () => {
+    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 shouldCheckTransfer = true;
+    before(async () => {
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider);
+        exchangeContractAddress = await zeroEx.exchange.getContractAddressAsync();
+        userAddresses = await promisify(web3.eth.getAccounts)();
+        [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.getNonProtocolTokens();
+        makerTokenAddress = makerToken.address;
+        takerTokenAddress = takerToken.address;
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('#validateFillOrderBalancesAndAllowancesAndThrowIfInvalidAsync', () => {
+        describe('should throw when not enough balance or allowance to fulfill the order', () => {
+            const balanceToSubtractFromMaker = new BigNumber(3);
+            const lackingAllowance = new BigNumber(3);
+            let signedOrder: SignedOrder;
+            beforeEach('create fillable signed order', async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
+                );
+            });
+            it('should throw when taker balance is less than fill amount', async () => {
+                await zeroEx.token.transferAsync(
+                    takerTokenAddress, takerAddress, coinbase, balanceToSubtractFromMaker,
+                );
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
+                )).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerBalance);
+            });
+            it('should throw when taker allowance is less than fill amount', async () => {
+                const newAllowanceWhichIsLessThanFillAmount = fillTakerAmount.minus(lackingAllowance);
+                await zeroEx.token.setProxyAllowanceAsync(takerTokenAddress, takerAddress,
+                    newAllowanceWhichIsLessThanFillAmount);
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
+                )).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerAllowance);
+            });
+            it('should throw when maker balance is less than maker fill amount', async () => {
+                await zeroEx.token.transferAsync(
+                    makerTokenAddress, makerAddress, coinbase, balanceToSubtractFromMaker,
+                );
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
+                )).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerBalance);
+            });
+            it('should throw when maker allowance is less than maker fill amount', async () => {
+                const newAllowanceWhichIsLessThanFillAmount = fillTakerAmount.minus(lackingAllowance);
+                await zeroEx.token.setProxyAllowanceAsync(makerTokenAddress, makerAddress,
+                    newAllowanceWhichIsLessThanFillAmount);
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
+                )).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerAllowance);
+            });
+        });
+        describe('should throw when not enough balance or allowance to pay fees', () => {
+            const makerFee = new BigNumber(2);
+            const takerFee = new BigNumber(2);
+            let signedOrder: SignedOrder;
+            beforeEach('setup', async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                    makerTokenAddress, takerTokenAddress, makerFee, takerFee,
+                    makerAddress, takerAddress, fillableAmount, feeRecipient,
+                );
+            });
+            it('should throw when maker doesn\'t have enough balance to pay fees', async () => {
+                const balanceToSubtractFromMaker = new BigNumber(1);
+                await zeroEx.token.transferAsync(
+                    zrxTokenAddress, makerAddress, coinbase, balanceToSubtractFromMaker,
+                );
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
+                )).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerFeeBalance);
+            });
+            it('should throw when maker doesn\'t have enough allowance to pay fees', async () => {
+                const newAllowanceWhichIsLessThanFees = makerFee.minus(1);
+                await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, makerAddress,
+                    newAllowanceWhichIsLessThanFees);
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
+                )).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerFeeAllowance);
+            });
+            it('should throw when taker doesn\'t have enough balance to pay fees', async () => {
+                const balanceToSubtractFromTaker = new BigNumber(1);
+                await zeroEx.token.transferAsync(
+                    zrxTokenAddress, takerAddress, coinbase, balanceToSubtractFromTaker,
+                );
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
+                )).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerFeeBalance);
+            });
+            it('should throw when taker doesn\'t have enough allowance to pay fees', async () => {
+                const newAllowanceWhichIsLessThanFees = makerFee.minus(1);
+                await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, takerAddress,
+                    newAllowanceWhichIsLessThanFees);
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
+                )).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerFeeAllowance);
+            });
+        });
+        describe('should throw on insufficient balance or allowance when makerToken is ZRX',
+            () => {
+            const makerFee = new BigNumber(2);
+            const takerFee = new BigNumber(2);
+            let signedOrder: SignedOrder;
+            beforeEach(async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                    zrxTokenAddress, takerTokenAddress, makerFee, takerFee,
+                    makerAddress, takerAddress, fillableAmount, feeRecipient,
+                );
+            });
+            it('should throw on insufficient balance when makerToken is ZRX', async () => {
+                const balanceToSubtractFromMaker = new BigNumber(1);
+                await zeroEx.token.transferAsync(
+                    zrxTokenAddress, makerAddress, coinbase, balanceToSubtractFromMaker,
+                );
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
+                )).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerBalance);
+            });
+            it('should throw on insufficient allowance when makerToken is ZRX', async () => {
+                const oldAllowance = await zeroEx.token.getProxyAllowanceAsync(zrxTokenAddress, makerAddress);
+                const newAllowanceWhichIsInsufficient = oldAllowance.minus(1);
+                await zeroEx.token.setProxyAllowanceAsync(
+                    zrxTokenAddress, makerAddress, newAllowanceWhichIsInsufficient);
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
+                )).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerAllowance);
+            });
+        });
+        describe('should throw on insufficient balance or allowance when takerToken is ZRX',
+            () => {
+            const makerFee = new BigNumber(2);
+            const takerFee = new BigNumber(2);
+            let signedOrder: SignedOrder;
+            beforeEach(async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                    makerTokenAddress, zrxTokenAddress, makerFee, takerFee,
+                    makerAddress, takerAddress, fillableAmount, feeRecipient,
+                );
+            });
+            it('should throw on insufficient balance when takerToken is ZRX', async () => {
+                const balanceToSubtractFromTaker = new BigNumber(1);
+                await zeroEx.token.transferAsync(
+                    zrxTokenAddress, takerAddress, coinbase, balanceToSubtractFromTaker,
+                );
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
+                )).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerBalance);
+            });
+            it('should throw on insufficient allowance when takerToken is ZRX', async () => {
+                const oldAllowance = await zeroEx.token.getProxyAllowanceAsync(zrxTokenAddress, takerAddress);
+                const newAllowanceWhichIsInsufficient = oldAllowance.minus(1);
+                await zeroEx.token.setProxyAllowanceAsync(
+                    zrxTokenAddress, takerAddress, newAllowanceWhichIsInsufficient);
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmount, shouldCheckTransfer, takerAddress,
+                )).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerAllowance);
+            });
+        });
+    });
+});