Merge branch 'fix/order-utils/remaining-v2-changes' into feature/combinatorial-testing

* fix/order-utils/remaining-v2-changes:
  Revert to returning orderState on invalid order
  - Refactor remainingFillableCalculator so it can be used for the maker and taker side - Moved the tests over from order-watcher - Did some token -> asset renaming
  Update naming in orderStateUtils to use asset over token, also removed cancelledAmount since in V2 it's binary.

5 files changed, 201 insertions, 183 deletions

diff --git a/packages/order-utils/src/abstract/abstract_order_filled_cancelled_fetcher.ts b/packages/order-utils/src/abstract/abstract_order_filled_cancelled_fetcher.ts
index f54bed6f1..ec398a11e 100644
--- a/packages/order-utils/src/abstract/abstract_order_filled_cancelled_fetcher.ts
+++ b/packages/order-utils/src/abstract/abstract_order_filled_cancelled_fetcher.ts
@@ -2,7 +2,6 @@ import { BigNumber } from '@0xproject/utils';
 
 export abstract class AbstractOrderFilledCancelledFetcher {
     public abstract async getFilledTakerAmountAsync(orderHash: string): Promise<BigNumber>;
-    public abstract async getCancelledTakerAmountAsync(orderHash: string): Promise<BigNumber>;
-    public abstract async getUnavailableTakerAmountAsync(orderHash: string): Promise<BigNumber>;
+    public abstract async isOrderCancelledAsync(orderHash: string): Promise<boolean>;
     public abstract getZRXTokenAddress(): string;
 }
diff --git a/packages/order-utils/src/order_state_utils.ts b/packages/order-utils/src/order_state_utils.ts
index da33ea010..ef868e60f 100644
--- a/packages/order-utils/src/order_state_utils.ts
+++ b/packages/order-utils/src/order_state_utils.ts
@@ -20,11 +20,8 @@ export class OrderStateUtils {
     private _balanceAndProxyAllowanceFetcher: AbstractBalanceAndProxyAllowanceFetcher;
     private _orderFilledCancelledFetcher: AbstractOrderFilledCancelledFetcher;
     private static _validateIfOrderIsValid(signedOrder: SignedOrder, orderRelevantState: OrderRelevantState): void {
-        const unavailableTakerTokenAmount = orderRelevantState.cancelledTakerTokenAmount.add(
-            orderRelevantState.filledTakerTokenAmount,
-        );
-        const availableTakerTokenAmount = signedOrder.takerAssetAmount.minus(unavailableTakerTokenAmount);
-        if (availableTakerTokenAmount.eq(0)) {
+        const availableTakerAssetAmount = signedOrder.takerAssetAmount.minus(orderRelevantState.filledTakerAssetAmount);
+        if (availableTakerAssetAmount.eq(0)) {
             throw new Error(ExchangeContractErrs.OrderRemainingFillAmountZero);
         }
 
@@ -42,12 +39,12 @@ export class OrderStateUtils {
                 throw new Error(ExchangeContractErrs.InsufficientMakerFeeAllowance);
             }
         }
-        const minFillableTakerTokenAmountWithinNoRoundingErrorRange = signedOrder.takerAssetAmount
+        const minFillableTakerAssetAmountWithinNoRoundingErrorRange = signedOrder.takerAssetAmount
             .dividedBy(ACCEPTABLE_RELATIVE_ROUNDING_ERROR)
             .dividedBy(signedOrder.makerAssetAmount);
         if (
-            orderRelevantState.remainingFillableTakerTokenAmount.lessThan(
-                minFillableTakerTokenAmountWithinNoRoundingErrorRange,
+            orderRelevantState.remainingFillableTakerAssetAmount.lessThan(
+                minFillableTakerAssetAmountWithinNoRoundingErrorRange,
             )
         ) {
             throw new Error(ExchangeContractErrs.OrderFillRoundingError);
@@ -82,13 +79,15 @@ export class OrderStateUtils {
     }
     public async getOrderRelevantStateAsync(signedOrder: SignedOrder): Promise<OrderRelevantState> {
         const zrxTokenAddress = this._orderFilledCancelledFetcher.getZRXTokenAddress();
+        const makerProxyData = assetProxyUtils.decodeERC20ProxyData(signedOrder.makerAssetData);
+        const makerAssetAddress = makerProxyData.tokenAddress;
         const orderHash = orderHashUtils.getOrderHashHex(signedOrder);
         const makerBalance = await this._balanceAndProxyAllowanceFetcher.getBalanceAsync(
-            signedOrder.makerAssetData,
+            makerAssetAddress,
             signedOrder.makerAddress,
         );
         const makerProxyAllowance = await this._balanceAndProxyAllowanceFetcher.getProxyAllowanceAsync(
-            signedOrder.makerAssetData,
+            makerAssetAddress,
             signedOrder.makerAddress,
         );
         const makerFeeBalance = await this._balanceAndProxyAllowanceFetcher.getBalanceAsync(
@@ -99,42 +98,42 @@ export class OrderStateUtils {
             zrxTokenAddress,
             signedOrder.makerAddress,
         );
-        const filledTakerTokenAmount = await this._orderFilledCancelledFetcher.getFilledTakerAmountAsync(orderHash);
-        const cancelledTakerTokenAmount = await this._orderFilledCancelledFetcher.getCancelledTakerAmountAsync(
-            orderHash,
-        );
-        const unavailableTakerTokenAmount = await this._orderFilledCancelledFetcher.getUnavailableTakerAmountAsync(
-            orderHash,
-        );
-        const totalMakerTokenAmount = signedOrder.makerAssetAmount;
-        const totalTakerTokenAmount = signedOrder.takerAssetAmount;
-        const remainingTakerTokenAmount = totalTakerTokenAmount.minus(unavailableTakerTokenAmount);
-        const remainingMakerTokenAmount = remainingTakerTokenAmount
-            .times(totalMakerTokenAmount)
-            .dividedToIntegerBy(totalTakerTokenAmount);
-        const transferrableMakerTokenAmount = BigNumber.min([makerProxyAllowance, makerBalance]);
-        const transferrableFeeTokenAmount = BigNumber.min([makerFeeProxyAllowance, makerFeeBalance]);
+        const filledTakerAssetAmount = await this._orderFilledCancelledFetcher.getFilledTakerAmountAsync(orderHash);
+        const isOrderCancelled = await this._orderFilledCancelledFetcher.isOrderCancelledAsync(orderHash);
+        const totalMakerAssetAmount = signedOrder.makerAssetAmount;
+        const totalTakerAssetAmount = signedOrder.takerAssetAmount;
+        const remainingTakerAssetAmount = isOrderCancelled
+            ? new BigNumber(0)
+            : totalTakerAssetAmount.minus(filledTakerAssetAmount);
+        const remainingMakerAssetAmount = remainingTakerAssetAmount
+            .times(totalMakerAssetAmount)
+            .dividedToIntegerBy(totalTakerAssetAmount);
+        const transferrableMakerAssetAmount = BigNumber.min([makerProxyAllowance, makerBalance]);
+        const transferrableFeeAssetAmount = BigNumber.min([makerFeeProxyAllowance, makerFeeBalance]);
 
         const zrxAssetData = assetProxyUtils.encodeERC20ProxyData(zrxTokenAddress);
-        const isMakerTokenZRX = signedOrder.makerAssetData === zrxAssetData;
+        const isMakerAssetZRX = signedOrder.makerAssetData === zrxAssetData;
+        const isTraderMaker = true;
         const remainingFillableCalculator = new RemainingFillableCalculator(
+            isTraderMaker,
             signedOrder,
-            isMakerTokenZRX,
-            transferrableMakerTokenAmount,
-            transferrableFeeTokenAmount,
-            remainingMakerTokenAmount,
+            isMakerAssetZRX,
+            transferrableMakerAssetAmount,
+            transferrableFeeAssetAmount,
+            remainingMakerAssetAmount,
         );
-        const remainingFillableMakerTokenAmount = remainingFillableCalculator.computeRemainingMakerFillable();
-        const remainingFillableTakerTokenAmount = remainingFillableCalculator.computeRemainingTakerFillable();
+        const remainingFillableMakerAssetAmount = remainingFillableCalculator.computeRemainingFillable();
+        const remainingFillableTakerAssetAmount = remainingFillableMakerAssetAmount
+            .times(signedOrder.takerAssetAmount)
+            .dividedToIntegerBy(signedOrder.makerAssetAmount);
         const orderRelevantState = {
             makerBalance,
             makerProxyAllowance,
             makerFeeBalance,
             makerFeeProxyAllowance,
-            filledTakerTokenAmount,
-            cancelledTakerTokenAmount,
-            remainingFillableMakerTokenAmount,
-            remainingFillableTakerTokenAmount,
+            filledTakerAssetAmount,
+            remainingFillableMakerAssetAmount,
+            remainingFillableTakerAssetAmount,
         };
         return orderRelevantState;
     }
diff --git a/packages/order-utils/src/remaining_fillable_calculator.ts b/packages/order-utils/src/remaining_fillable_calculator.ts
index b291d8ea9..acab2f41b 100644
--- a/packages/order-utils/src/remaining_fillable_calculator.ts
+++ b/packages/order-utils/src/remaining_fillable_calculator.ts
@@ -3,93 +3,92 @@ import { BigNumber } from '@0xproject/utils';
 
 export class RemainingFillableCalculator {
     private _signedOrder: SignedOrder;
-    private _isMakerTokenZRX: boolean;
+    private _isTraderAssetZRX: boolean;
     // Transferrable Amount is the minimum of Approval and Balance
-    private _transferrableMakerTokenAmount: BigNumber;
-    private _transferrableMakerFeeTokenAmount: BigNumber;
-    private _remainingMakerTokenAmount: BigNumber;
-    private _remainingMakerFeeAmount: BigNumber;
+    private _transferrableAssetAmount: BigNumber;
+    private _transferrableFeeAmount: BigNumber;
+    private _remainingOrderAssetAmount: BigNumber;
+    private _remainingOrderFeeAmount: BigNumber;
+    private _orderFee: BigNumber;
+    private _orderAssetAmount: BigNumber;
     constructor(
+        isTraderMaker: boolean,
         signedOrder: SignedOrder,
-        isMakerTokenZRX: boolean,
-        transferrableMakerTokenAmount: BigNumber,
-        transferrableMakerFeeTokenAmount: BigNumber,
-        remainingMakerTokenAmount: BigNumber,
+        isTraderAssetZRX: boolean,
+        transferrableAssetAmount: BigNumber,
+        transferrableFeeAmount: BigNumber,
+        remainingOrderAssetAmount: BigNumber,
     ) {
+        if (isTraderMaker) {
+            this._orderFee = signedOrder.makerFee;
+            this._orderAssetAmount = signedOrder.makerAssetAmount;
+        } else {
+            this._orderFee = signedOrder.takerFee;
+            this._orderAssetAmount = signedOrder.takerAssetAmount;
+        }
         this._signedOrder = signedOrder;
-        this._isMakerTokenZRX = isMakerTokenZRX;
-        this._transferrableMakerTokenAmount = transferrableMakerTokenAmount;
-        this._transferrableMakerFeeTokenAmount = transferrableMakerFeeTokenAmount;
-        this._remainingMakerTokenAmount = remainingMakerTokenAmount;
-        this._remainingMakerFeeAmount = remainingMakerTokenAmount
-            .times(signedOrder.makerFee)
-            .dividedToIntegerBy(signedOrder.makerAssetAmount);
+        this._isTraderAssetZRX = isTraderAssetZRX;
+        this._transferrableAssetAmount = transferrableAssetAmount;
+        this._transferrableFeeAmount = transferrableFeeAmount;
+        this._remainingOrderAssetAmount = remainingOrderAssetAmount;
+        this._remainingOrderFeeAmount = remainingOrderAssetAmount
+            .times(this._orderFee)
+            .dividedToIntegerBy(this._orderAssetAmount);
     }
-    public computeRemainingMakerFillable(): BigNumber {
+    public computeRemainingFillable(): BigNumber {
         if (this._hasSufficientFundsForFeeAndTransferAmount()) {
-            return this._remainingMakerTokenAmount;
+            return this._remainingOrderAssetAmount;
         }
-        if (this._signedOrder.makerFee.isZero()) {
-            return BigNumber.min(this._remainingMakerTokenAmount, this._transferrableMakerTokenAmount);
+        if (this._orderFee.isZero()) {
+            return BigNumber.min(this._remainingOrderAssetAmount, this._transferrableAssetAmount);
         }
-        return this._calculatePartiallyFillableMakerTokenAmount();
-    }
-    public computeRemainingTakerFillable(): BigNumber {
-        return this.computeRemainingMakerFillable()
-            .times(this._signedOrder.takerAssetAmount)
-            .dividedToIntegerBy(this._signedOrder.makerAssetAmount);
+        return this._calculatePartiallyFillableAssetAmount();
     }
     private _hasSufficientFundsForFeeAndTransferAmount(): boolean {
-        if (this._isMakerTokenZRX) {
-            const totalZRXTransferAmountRequired = this._remainingMakerTokenAmount.plus(this._remainingMakerFeeAmount);
-            const hasSufficientFunds = this._transferrableMakerTokenAmount.greaterThanOrEqualTo(
+        if (this._isTraderAssetZRX) {
+            const totalZRXTransferAmountRequired = this._remainingOrderAssetAmount.plus(this._remainingOrderFeeAmount);
+            const hasSufficientFunds = this._transferrableAssetAmount.greaterThanOrEqualTo(
                 totalZRXTransferAmountRequired,
             );
             return hasSufficientFunds;
         } else {
-            const hasSufficientFundsForTransferAmount = this._transferrableMakerTokenAmount.greaterThanOrEqualTo(
-                this._remainingMakerTokenAmount,
+            const hasSufficientFundsForTransferAmount = this._transferrableAssetAmount.greaterThanOrEqualTo(
+                this._remainingOrderAssetAmount,
             );
-            const hasSufficientFundsForFeeAmount = this._transferrableMakerFeeTokenAmount.greaterThanOrEqualTo(
-                this._remainingMakerFeeAmount,
+            const hasSufficientFundsForFeeAmount = this._transferrableFeeAmount.greaterThanOrEqualTo(
+                this._remainingOrderFeeAmount,
             );
             const hasSufficientFunds = hasSufficientFundsForTransferAmount && hasSufficientFundsForFeeAmount;
             return hasSufficientFunds;
         }
     }
-    private _calculatePartiallyFillableMakerTokenAmount(): BigNumber {
+    private _calculatePartiallyFillableAssetAmount(): BigNumber {
         // Given an order for 200 wei for 2 ZRXwei fee, find 100 wei for 1 ZRXwei. Order ratio is then 100:1
-        const orderToFeeRatio = this._signedOrder.makerAssetAmount.dividedBy(this._signedOrder.makerFee);
-        // The number of times the maker can fill the order, if each fill only required the transfer of a single
+        const orderToFeeRatio = this._orderAssetAmount.dividedBy(this._orderFee);
+        // The number of times the trader (maker or taker) can fill the order, if each fill only required the transfer of a single
         // baseUnit of fee tokens.
-        // Given 2 ZRXwei, the maximum amount of times Maker can fill this order, in terms of fees, is 2
-        const fillableTimesInFeeTokenBaseUnits = BigNumber.min(
-            this._transferrableMakerFeeTokenAmount,
-            this._remainingMakerFeeAmount,
-        );
-        // The number of times the Maker can fill the order, given the Maker Token Balance
-        // Assuming a balance of 150 wei, and an orderToFeeRatio of 100:1, maker can fill this order 1 time.
-        let fillableTimesInMakerTokenUnits = this._transferrableMakerTokenAmount.dividedBy(orderToFeeRatio);
-        if (this._isMakerTokenZRX) {
-            // If ZRX is the maker token, the Fee and the Maker amount need to be removed from the same pool;
+        // Given 2 ZRXwei, the maximum amount of times trader can fill this order, in terms of fees, is 2
+        const fillableTimesInFeeBaseUnits = BigNumber.min(this._transferrableFeeAmount, this._remainingOrderFeeAmount);
+        // The number of times the trader can fill the order, given the traders asset Balance
+        // Assuming a balance of 150 wei, and an orderToFeeRatio of 100:1, trader can fill this order 1 time.
+        let fillableTimesInAssetUnits = this._transferrableAssetAmount.dividedBy(orderToFeeRatio);
+        if (this._isTraderAssetZRX) {
+            // If ZRX is the trader asset, the Fee and the trader fill amount need to be removed from the same pool;
             // 200 ZRXwei for 2ZRXwei fee can only be filled once (need 202 ZRXwei)
-            const totalZRXTokenPooled = this._transferrableMakerTokenAmount;
+            const totalZRXTokenPooled = this._transferrableAssetAmount;
             // The purchasing power here is less as the tokens are taken from the same Pool
             // For every one number of fills, we have to take an extra ZRX out of the pool
-            fillableTimesInMakerTokenUnits = totalZRXTokenPooled.dividedBy(orderToFeeRatio.plus(new BigNumber(1)));
+            fillableTimesInAssetUnits = totalZRXTokenPooled.dividedBy(orderToFeeRatio.plus(new BigNumber(1)));
         }
         // When Ratio is not fully divisible there can be remainders which cannot be represented, so they are floored.
         // This can result in a RoundingError being thrown by the Exchange Contract.
-        const partiallyFillableMakerTokenAmount = fillableTimesInMakerTokenUnits
-            .times(this._signedOrder.makerAssetAmount)
-            .dividedToIntegerBy(this._signedOrder.makerFee);
-        const partiallyFillableFeeTokenAmount = fillableTimesInFeeTokenBaseUnits
-            .times(this._signedOrder.makerAssetAmount)
-            .dividedToIntegerBy(this._signedOrder.makerFee);
-        const partiallyFillableAmount = BigNumber.min(
-            partiallyFillableMakerTokenAmount,
-            partiallyFillableFeeTokenAmount,
-        );
+        const partiallyFillableAssetAmount = fillableTimesInAssetUnits
+            .times(this._orderAssetAmount)
+            .dividedToIntegerBy(this._orderFee);
+        const partiallyFillableFeeAmount = fillableTimesInFeeBaseUnits
+            .times(this._orderAssetAmount)
+            .dividedToIntegerBy(this._orderFee);
+        const partiallyFillableAmount = BigNumber.min(partiallyFillableAssetAmount, partiallyFillableFeeAmount);
         return partiallyFillableAmount;
     }
 }
diff --git a/packages/order-watcher/test/remaining_fillable_calculator_test.ts b/packages/order-utils/test/remaining_fillable_calculator_test.ts
index ea116175b..81f8132b2 100644
--- a/packages/order-watcher/test/remaining_fillable_calculator_test.ts
+++ b/packages/order-utils/test/remaining_fillable_calculator_test.ts
@@ -5,7 +5,7 @@ import * as chai from 'chai';
 import 'make-promises-safe';
 import 'mocha';
 
-import { RemainingFillableCalculator } from '@0xproject/order-utils';
+import { RemainingFillableCalculator } from '../src/remaining_fillable_calculator';
 
 import { chaiSetup } from './utils/chai_setup';
 
@@ -15,101 +15,111 @@ const expect = chai.expect;
 describe('RemainingFillableCalculator', () => {
     let calculator: RemainingFillableCalculator;
     let signedOrder: SignedOrder;
-    let transferrableMakerTokenAmount: BigNumber;
+    let transferrableMakeAssetAmount: BigNumber;
     let transferrableMakerFeeTokenAmount: BigNumber;
-    let remainingMakerTokenAmount: BigNumber;
+    let remainingMakeAssetAmount: BigNumber;
     let makerAmount: BigNumber;
     let takerAmount: BigNumber;
     let makerFeeAmount: BigNumber;
-    let isMakerTokenZRX: boolean;
-    const makerToken: string = '0x1';
-    const takerToken: string = '0x2';
+    let isMakeAssetZRX: boolean;
+    const makerAssetData: string = '0x1';
+    const takerAssetData: string = '0x2';
     const decimals: number = 4;
     const zero: BigNumber = new BigNumber(0);
     const zeroAddress = '0x0';
-    const signature: ECSignature = { v: 27, r: '', s: '' };
+    const signature: string =
+        '0x1B61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc3340349190569279751135161d22529dc25add4f6069af05be04cacbda2ace225403';
     beforeEach(async () => {
         [makerAmount, takerAmount, makerFeeAmount] = [
             Web3Wrapper.toBaseUnitAmount(new BigNumber(50), decimals),
             Web3Wrapper.toBaseUnitAmount(new BigNumber(5), decimals),
             Web3Wrapper.toBaseUnitAmount(new BigNumber(1), decimals),
         ];
-        [transferrableMakerTokenAmount, transferrableMakerFeeTokenAmount] = [
+        [transferrableMakeAssetAmount, transferrableMakerFeeTokenAmount] = [
             Web3Wrapper.toBaseUnitAmount(new BigNumber(50), decimals),
             Web3Wrapper.toBaseUnitAmount(new BigNumber(5), decimals),
         ];
     });
     function buildSignedOrder(): SignedOrder {
         return {
-            ecSignature: signature,
-            exchangeContractAddress: zeroAddress,
-            feeRecipient: zeroAddress,
-            maker: zeroAddress,
-            taker: zeroAddress,
+            signature,
+            exchangeAddress: zeroAddress,
+            feeRecipientAddress: zeroAddress,
+            senderAddress: zeroAddress,
+            makerAddress: zeroAddress,
+            takerAddress: zeroAddress,
             makerFee: makerFeeAmount,
             takerFee: zero,
-            makerTokenAmount: makerAmount,
-            takerTokenAmount: takerAmount,
-            makerTokenAddress: makerToken,
-            takerTokenAddress: takerToken,
+            makerAssetAmount: makerAmount,
+            takerAssetAmount: takerAmount,
+            makerAssetData,
+            takerAssetData,
             salt: zero,
-            expirationUnixTimestampSec: zero,
+            expirationTimeSeconds: zero,
         };
     }
     describe('Maker token is NOT ZRX', () => {
         before(async () => {
-            isMakerTokenZRX = false;
+            isMakeAssetZRX = false;
         });
         it('calculates the correct amount when unfilled and funds available', () => {
             signedOrder = buildSignedOrder();
-            remainingMakerTokenAmount = signedOrder.makerTokenAmount;
+            remainingMakeAssetAmount = signedOrder.makerAssetAmount;
+            const isTraderMaker = true;
             calculator = new RemainingFillableCalculator(
+                isTraderMaker,
                 signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
+                isMakeAssetZRX,
+                transferrableMakeAssetAmount,
                 transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
+                remainingMakeAssetAmount,
             );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
+            expect(calculator.computeRemainingFillable()).to.be.bignumber.equal(remainingMakeAssetAmount);
         });
         it('calculates the correct amount when partially filled and funds available', () => {
             signedOrder = buildSignedOrder();
-            remainingMakerTokenAmount = Web3Wrapper.toBaseUnitAmount(new BigNumber(1), decimals);
+            remainingMakeAssetAmount = Web3Wrapper.toBaseUnitAmount(new BigNumber(1), decimals);
+            const isTraderMaker = true;
             calculator = new RemainingFillableCalculator(
+                isTraderMaker,
                 signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
+                isMakeAssetZRX,
+                transferrableMakeAssetAmount,
                 transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
+                remainingMakeAssetAmount,
             );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
+            expect(calculator.computeRemainingFillable()).to.be.bignumber.equal(remainingMakeAssetAmount);
         });
         it('calculates the amount to be 0 when all fee funds are transferred', () => {
             signedOrder = buildSignedOrder();
             transferrableMakerFeeTokenAmount = zero;
-            remainingMakerTokenAmount = signedOrder.makerTokenAmount;
+            remainingMakeAssetAmount = signedOrder.makerAssetAmount;
+            const isTraderMaker = true;
             calculator = new RemainingFillableCalculator(
+                isTraderMaker,
                 signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
+                isMakeAssetZRX,
+                transferrableMakeAssetAmount,
                 transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
+                remainingMakeAssetAmount,
             );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(zero);
+            expect(calculator.computeRemainingFillable()).to.be.bignumber.equal(zero);
         });
         it('calculates the correct amount when balance is less than remaining fillable', () => {
             signedOrder = buildSignedOrder();
             const partiallyFilledAmount = Web3Wrapper.toBaseUnitAmount(new BigNumber(2), decimals);
-            remainingMakerTokenAmount = signedOrder.makerTokenAmount.minus(partiallyFilledAmount);
-            transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(partiallyFilledAmount);
+            remainingMakeAssetAmount = signedOrder.makerAssetAmount.minus(partiallyFilledAmount);
+            transferrableMakeAssetAmount = remainingMakeAssetAmount.minus(partiallyFilledAmount);
+            const isTraderMaker = true;
             calculator = new RemainingFillableCalculator(
+                isTraderMaker,
                 signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
+                isMakeAssetZRX,
+                transferrableMakeAssetAmount,
                 transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
+                remainingMakeAssetAmount,
             );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(transferrableMakerTokenAmount);
+            expect(calculator.computeRemainingFillable()).to.be.bignumber.equal(transferrableMakeAssetAmount);
         });
         describe('Order to Fee Ratio is < 1', () => {
             beforeEach(async () => {
@@ -121,17 +131,19 @@ describe('RemainingFillableCalculator', () => {
             });
             it('calculates the correct amount when funds unavailable', () => {
                 signedOrder = buildSignedOrder();
-                remainingMakerTokenAmount = signedOrder.makerTokenAmount;
+                remainingMakeAssetAmount = signedOrder.makerAssetAmount;
                 const transferredAmount = Web3Wrapper.toBaseUnitAmount(new BigNumber(2), decimals);
-                transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(transferredAmount);
+                transferrableMakeAssetAmount = remainingMakeAssetAmount.minus(transferredAmount);
+                const isTraderMaker = true;
                 calculator = new RemainingFillableCalculator(
+                    isTraderMaker,
                     signedOrder,
-                    isMakerTokenZRX,
-                    transferrableMakerTokenAmount,
+                    isMakeAssetZRX,
+                    transferrableMakeAssetAmount,
                     transferrableMakerFeeTokenAmount,
-                    remainingMakerTokenAmount,
+                    remainingMakeAssetAmount,
                 );
-                expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(transferrableMakerTokenAmount);
+                expect(calculator.computeRemainingFillable()).to.be.bignumber.equal(transferrableMakeAssetAmount);
             });
         });
         describe('Ratio is not evenly divisble', () => {
@@ -144,20 +156,22 @@ describe('RemainingFillableCalculator', () => {
             });
             it('calculates the correct amount when funds unavailable', () => {
                 signedOrder = buildSignedOrder();
-                remainingMakerTokenAmount = signedOrder.makerTokenAmount;
+                remainingMakeAssetAmount = signedOrder.makerAssetAmount;
                 const transferredAmount = Web3Wrapper.toBaseUnitAmount(new BigNumber(2), decimals);
-                transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(transferredAmount);
+                transferrableMakeAssetAmount = remainingMakeAssetAmount.minus(transferredAmount);
+                const isTraderMaker = true;
                 calculator = new RemainingFillableCalculator(
+                    isTraderMaker,
                     signedOrder,
-                    isMakerTokenZRX,
-                    transferrableMakerTokenAmount,
+                    isMakeAssetZRX,
+                    transferrableMakeAssetAmount,
                     transferrableMakerFeeTokenAmount,
-                    remainingMakerTokenAmount,
+                    remainingMakeAssetAmount,
                 );
-                const calculatedFillableAmount = calculator.computeRemainingMakerFillable();
-                expect(calculatedFillableAmount.lessThanOrEqualTo(transferrableMakerTokenAmount)).to.be.true();
+                const calculatedFillableAmount = calculator.computeRemainingFillable();
+                expect(calculatedFillableAmount.lessThanOrEqualTo(transferrableMakeAssetAmount)).to.be.true();
                 expect(calculatedFillableAmount).to.be.bignumber.greaterThan(new BigNumber(0));
-                const orderToFeeRatio = signedOrder.makerTokenAmount.dividedBy(signedOrder.makerFee);
+                const orderToFeeRatio = signedOrder.makerAssetAmount.dividedBy(signedOrder.makerFee);
                 const calculatedFeeAmount = calculatedFillableAmount.dividedBy(orderToFeeRatio);
                 expect(calculatedFeeAmount).to.be.bignumber.lessThan(transferrableMakerFeeTokenAmount);
             });
@@ -165,69 +179,77 @@ describe('RemainingFillableCalculator', () => {
     });
     describe('Maker Token is ZRX', () => {
         before(async () => {
-            isMakerTokenZRX = true;
+            isMakeAssetZRX = true;
         });
         it('calculates the correct amount when unfilled and funds available', () => {
             signedOrder = buildSignedOrder();
-            transferrableMakerTokenAmount = makerAmount.plus(makerFeeAmount);
-            transferrableMakerFeeTokenAmount = transferrableMakerTokenAmount;
-            remainingMakerTokenAmount = signedOrder.makerTokenAmount;
+            transferrableMakeAssetAmount = makerAmount.plus(makerFeeAmount);
+            transferrableMakerFeeTokenAmount = transferrableMakeAssetAmount;
+            remainingMakeAssetAmount = signedOrder.makerAssetAmount;
+            const isTraderMaker = true;
             calculator = new RemainingFillableCalculator(
+                isTraderMaker,
                 signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
+                isMakeAssetZRX,
+                transferrableMakeAssetAmount,
                 transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
+                remainingMakeAssetAmount,
             );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
+            expect(calculator.computeRemainingFillable()).to.be.bignumber.equal(remainingMakeAssetAmount);
         });
         it('calculates the correct amount when partially filled and funds available', () => {
             signedOrder = buildSignedOrder();
-            remainingMakerTokenAmount = Web3Wrapper.toBaseUnitAmount(new BigNumber(1), decimals);
+            remainingMakeAssetAmount = Web3Wrapper.toBaseUnitAmount(new BigNumber(1), decimals);
+            const isTraderMaker = true;
             calculator = new RemainingFillableCalculator(
+                isTraderMaker,
                 signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
+                isMakeAssetZRX,
+                transferrableMakeAssetAmount,
                 transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
+                remainingMakeAssetAmount,
             );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
+            expect(calculator.computeRemainingFillable()).to.be.bignumber.equal(remainingMakeAssetAmount);
         });
         it('calculates the amount to be 0 when all fee funds are transferred', () => {
             signedOrder = buildSignedOrder();
-            transferrableMakerTokenAmount = zero;
+            transferrableMakeAssetAmount = zero;
             transferrableMakerFeeTokenAmount = zero;
-            remainingMakerTokenAmount = signedOrder.makerTokenAmount;
+            remainingMakeAssetAmount = signedOrder.makerAssetAmount;
+            const isTraderMaker = true;
             calculator = new RemainingFillableCalculator(
+                isTraderMaker,
                 signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
+                isMakeAssetZRX,
+                transferrableMakeAssetAmount,
                 transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
+                remainingMakeAssetAmount,
             );
-            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(zero);
+            expect(calculator.computeRemainingFillable()).to.be.bignumber.equal(zero);
         });
         it('calculates the correct amount when balance is less than remaining fillable', () => {
             signedOrder = buildSignedOrder();
             const partiallyFilledAmount = Web3Wrapper.toBaseUnitAmount(new BigNumber(2), decimals);
-            remainingMakerTokenAmount = signedOrder.makerTokenAmount.minus(partiallyFilledAmount);
-            transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(partiallyFilledAmount);
-            transferrableMakerFeeTokenAmount = transferrableMakerTokenAmount;
+            remainingMakeAssetAmount = signedOrder.makerAssetAmount.minus(partiallyFilledAmount);
+            transferrableMakeAssetAmount = remainingMakeAssetAmount.minus(partiallyFilledAmount);
+            transferrableMakerFeeTokenAmount = transferrableMakeAssetAmount;
 
-            const orderToFeeRatio = signedOrder.makerTokenAmount.dividedToIntegerBy(signedOrder.makerFee);
+            const orderToFeeRatio = signedOrder.makerAssetAmount.dividedToIntegerBy(signedOrder.makerFee);
             const expectedFillableAmount = new BigNumber(450980);
+            const isTraderMaker = true;
             calculator = new RemainingFillableCalculator(
+                isTraderMaker,
                 signedOrder,
-                isMakerTokenZRX,
-                transferrableMakerTokenAmount,
+                isMakeAssetZRX,
+                transferrableMakeAssetAmount,
                 transferrableMakerFeeTokenAmount,
-                remainingMakerTokenAmount,
+                remainingMakeAssetAmount,
             );
-            const calculatedFillableAmount = calculator.computeRemainingMakerFillable();
+            const calculatedFillableAmount = calculator.computeRemainingFillable();
             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(calculatedFillableAmountPlusFees).to.be.bignumber.lessThan(transferrableMakeAssetAmount);
+            expect(calculatedFillableAmountPlusFees).to.be.bignumber.lessThan(remainingMakeAssetAmount);
             expect(calculatedFillableAmount).to.be.bignumber.equal(expectedFillableAmount);
             expect(numberOfFillsInRatio.decimalPlaces()).to.be.equal(0);
         });
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index 7cecae419..5ba66158e 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -103,10 +103,9 @@ export interface OrderRelevantState {
     makerProxyAllowance: BigNumber;
     makerFeeBalance: BigNumber;
     makerFeeProxyAllowance: BigNumber;
-    filledTakerTokenAmount: BigNumber;
-    cancelledTakerTokenAmount: BigNumber;
-    remainingFillableMakerTokenAmount: BigNumber;
-    remainingFillableTakerTokenAmount: BigNumber;
+    filledTakerAssetAmount: BigNumber;
+    remainingFillableMakerAssetAmount: BigNumber;
+    remainingFillableTakerAssetAmount: BigNumber;
 }
 
 export interface OrderStateValid {