Add marketBuyOrders, rename variables, and fx old tests

11 files changed, 681 insertions, 645 deletions

diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol b/packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol
index e966f9ffc..4394e26c8 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol
@@ -28,10 +28,10 @@ contract LibOrder {
         "address makerTokenAddress",
         "address takerTokenAddress",
         "address feeRecipientAddress",
-        "uint256 makerTokenAmount",
-        "uint256 takerTokenAmount",
-        "uint256 makerFeeAmount",
-        "uint256 takerFeeAmount",
+        "uint256 makerSellAmount",
+        "uint256 makerBuyAmount",
+        "uint256 makerFee",
+        "uint256 takerFee",
         "uint256 expirationTimeSeconds",
         "uint256 salt"
     );
@@ -42,10 +42,10 @@ contract LibOrder {
         address makerTokenAddress;
         address takerTokenAddress;
         address feeRecipientAddress;
-        uint256 makerTokenAmount;
-        uint256 takerTokenAmount;
-        uint256 makerFeeAmount;
-        uint256 takerFeeAmount;
+        uint256 makerSellAmount;
+        uint256 makerBuyAmount;
+        uint256 makerFee;
+        uint256 takerFee;
         uint256 expirationTimeSeconds;
         uint256 salt;
     }
@@ -68,10 +68,10 @@ contract LibOrder {
                 order.makerTokenAddress,
                 order.takerTokenAddress,
                 order.feeRecipientAddress,
-                order.makerTokenAmount,
-                order.takerTokenAmount,
-                order.makerFeeAmount,
-                order.takerFeeAmount,
+                order.makerSellAmount,
+                order.makerBuyAmount,
+                order.makerFee,
+                order.takerFee,
                 order.expirationTimeSeconds,
                 order.salt
             )
diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol b/packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol
index 82c1cc33a..375848ed1 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol
@@ -39,8 +39,10 @@ contract MixinExchangeCore is
     LibErrors,
     LibPartialAmount
 {
-    // Mappings of orderHash => amounts of takerTokenAmount filled or cancelled.
+    // Mapping of orderHash => amount of takerToken already bought by maker
     mapping (bytes32 => uint256) public filled;
+
+    // Mapping of orderHash => cancelled
     mapping (bytes32 => bool) public cancelled;
 
     // Mapping of makerAddress => lowest salt an order can have in order to be fillable
@@ -53,10 +55,10 @@ contract MixinExchangeCore is
         address indexed feeRecipientAddress,
         address makerTokenAddress,
         address takerTokenAddress,
-        uint256 makerTokenFilledAmount,
-        uint256 takerTokenFilledAmount,
-        uint256 makerFeeAmountPaid,
-        uint256 takerFeeAmountPaid,
+        uint256 makerAmountSold,
+        uint256 makerAmountBought,
+        uint256 makerFeePaid,
+        uint256 takerFeePaid,
         bytes32 indexed orderHash
     );
 
@@ -69,7 +71,7 @@ contract MixinExchangeCore is
     );
 
     event LogCancelUpTo(
-        address indexed maker,
+        address indexed makerAddress,
         uint256 makerEpoch
     );
 
@@ -79,15 +81,15 @@ contract MixinExchangeCore is
 
     /// @dev Fills the input order.
     /// @param order Order struct containing order specifications.
-    /// @param takerTokenFillAmount Desired amount of takerToken to fill.
+    /// @param takerSellAmount Desired amount of takerToken to sell.
     /// @param signature Proof of signing order by maker.
     /// @return Total amount of takerToken filled in trade.
     function fillOrder(
-        Order order,
-        uint256 takerTokenFillAmount,
-        bytes signature)
+        Order memory order,
+        uint256 takerSellAmount,
+        bytes memory signature)
         public
-        returns (uint256 takerTokenFilledAmount)
+        returns (uint256 takerAmountSold)
     {
         // Compute the order hash
         bytes32 orderHash = getOrderHash(order);
@@ -101,8 +103,6 @@ contract MixinExchangeCore is
         // Validate order and maker only if first time seen
         // TODO: Read filled and cancelled only once
         if (filled[orderHash] == 0) {
-            require(order.makerTokenAmount > 0);
-            require(order.takerTokenAmount > 0);
             require(isValidSignature(orderHash, order.makerAddress, signature));
         }
 
@@ -110,7 +110,6 @@ contract MixinExchangeCore is
         if (order.takerAddress != address(0)) {
             require(order.takerAddress == msg.sender);
         }
-        require(takerTokenFillAmount > 0);
 
         // Validate order expiration
         if (block.timestamp >= order.expirationTimeSeconds) {
@@ -119,15 +118,15 @@ contract MixinExchangeCore is
         }
 
         // Validate order availability
-        uint256 remainingTakerTokenAmount = safeSub(order.takerTokenAmount, filled[orderHash]);
-        if (remainingTakerTokenAmount == 0) {
+        uint256 remainingMakerBuyAmount = safeSub(order.makerBuyAmount, filled[orderHash]);
+        if (remainingMakerBuyAmount == 0) {
             LogError(uint8(Errors.ORDER_FULLY_FILLED), orderHash);
             return 0;
         }
 
         // Validate fill order rounding
-        takerTokenFilledAmount = min256(takerTokenFillAmount, remainingTakerTokenAmount);
-        if (isRoundingError(takerTokenFilledAmount, order.takerTokenAmount, order.makerTokenAmount)) {
+        takerAmountSold = min256(takerSellAmount, remainingMakerBuyAmount);
+        if (isRoundingError(takerAmountSold, order.makerBuyAmount, order.makerSellAmount)) {
             LogError(uint8(Errors.ROUNDING_ERROR_TOO_LARGE), orderHash);
             return 0;
         }
@@ -139,11 +138,11 @@ contract MixinExchangeCore is
         }
 
         // Update state
-        filled[orderHash] = safeAdd(filled[orderHash], takerTokenFilledAmount);
+        filled[orderHash] = safeAdd(filled[orderHash], takerAmountSold);
 
         // Settle order
-        var (makerTokenFilledAmount, makerFeeAmountPaid, takerFeeAmountPaid) =
-            settleOrder(order, msg.sender, takerTokenFilledAmount);
+        var (makerAmountSold, makerFeePaid, takerFeePaid) =
+            settleOrder(order, msg.sender, takerAmountSold);
 
         // Log order
         LogFill(
@@ -152,19 +151,19 @@ contract MixinExchangeCore is
             order.feeRecipientAddress,
             order.makerTokenAddress,
             order.takerTokenAddress,
-            makerTokenFilledAmount,
-            takerTokenFilledAmount,
-            makerFeeAmountPaid,
-            takerFeeAmountPaid,
+            makerAmountSold,
+            takerAmountSold,
+            makerFeePaid,
+            takerFeePaid,
             orderHash
         );
-        return takerTokenFilledAmount;
+        return takerAmountSold;
     }
 
     /// @dev After calling, the order can not be filled anymore.
     /// @param order Order struct containing order specifications.
     /// @return True if the order state changed to cancelled. False if the transaction was already cancelled or expired.
-    function cancelOrder(Order order)
+    function cancelOrder(Order memory order)
         public
         returns (bool)
     {
@@ -172,8 +171,6 @@ contract MixinExchangeCore is
         bytes32 orderHash = getOrderHash(order);
 
         // Validate the order
-        require(order.makerTokenAmount > 0);
-        require(order.takerTokenAmount > 0);
         require(order.makerAddress == msg.sender);
 
         if (block.timestamp >= order.expirationTimeSeconds) {
diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol b/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol
index f4139fe65..772ea3d9f 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol
@@ -48,32 +48,32 @@ contract MixinSettlementProxy is
     }
 
     function MixinSettlementProxy(
-        ITokenTransferProxy proxyContract,
-        IToken zrxToken)
+        ITokenTransferProxy _proxyContract,
+        IToken _zrxToken)
         public
     {
-        ZRX_TOKEN = zrxToken;
-        TRANSFER_PROXY = proxyContract;
+        ZRX_TOKEN = _zrxToken;
+        TRANSFER_PROXY = _proxyContract;
     }
 
     function settleOrder(
-        Order order,
+        Order memory order,
         address takerAddress,
-        uint256 takerTokenFilledAmount)
+        uint256 takerAmountSold)
         internal
         returns (
-            uint256 makerTokenFilledAmount,
-            uint256 makerFeeAmountPaid,
-            uint256 takerFeeAmountPaid
+            uint256 makerAmountSold,
+            uint256 makerFeePaid,
+            uint256 takerFeePaid
         )
     {
-        makerTokenFilledAmount = getPartialAmount(takerTokenFilledAmount, order.takerTokenAmount, order.makerTokenAmount);
+        makerAmountSold = getPartialAmount(takerAmountSold, order.makerBuyAmount, order.makerSellAmount);
         require(
             TRANSFER_PROXY.transferFrom(
                 order.makerTokenAddress,
                 order.makerAddress,
                 takerAddress,
-                makerTokenFilledAmount
+                makerAmountSold
             )
         );
         require(
@@ -81,33 +81,33 @@ contract MixinSettlementProxy is
                 order.takerTokenAddress,
                 takerAddress,
                 order.makerAddress,
-                takerTokenFilledAmount
+                takerAmountSold
             )
         );
         if (order.feeRecipientAddress != address(0)) {
-            if (order.makerFeeAmount > 0) {
-                makerFeeAmountPaid = getPartialAmount(takerTokenFilledAmount, order.takerTokenAmount, order.makerFeeAmount);
+            if (order.makerFee > 0) {
+                makerFeePaid = getPartialAmount(takerAmountSold, order.makerBuyAmount, order.makerFee);
                 require(
                     TRANSFER_PROXY.transferFrom(
                         ZRX_TOKEN,
                         order.makerAddress,
                         order.feeRecipientAddress,
-                        makerFeeAmountPaid
+                        makerFeePaid
                     )
                 );
             }
-            if (order.takerFeeAmount > 0) {
-                takerFeeAmountPaid = getPartialAmount(takerTokenFilledAmount, order.takerTokenAmount, order.takerFeeAmount);
+            if (order.takerFee > 0) {
+                takerFeePaid = getPartialAmount(takerAmountSold, order.makerBuyAmount, order.takerFee);
                 require(
                     TRANSFER_PROXY.transferFrom(
                         ZRX_TOKEN,
                         takerAddress,
                         order.feeRecipientAddress,
-                        takerFeeAmountPaid
+                        takerFeePaid
                     )
                 );
             }
         }
-        return (makerTokenFilledAmount, makerFeeAmountPaid, takerFeeAmountPaid);
+        return (makerAmountSold, makerFeePaid, takerFeePaid);
     }
 }
diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/MixinWrapperFunctions.sol b/packages/contracts/src/contracts/current/protocol/Exchange/MixinWrapperFunctions.sol
index 39f4784cb..cfd52f71d 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/MixinWrapperFunctions.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/MixinWrapperFunctions.sol
@@ -20,42 +20,46 @@ pragma solidity ^0.4.21;
 pragma experimental ABIEncoderV2;
 
 import "./mixins/MExchangeCore.sol";
+import "./LibPartialAmount.sol";
 import "../../utils/SafeMath/SafeMath.sol";
 
 /// @dev Consumes MExchangeCore
 contract MixinWrapperFunctions is
     MExchangeCore,
-    SafeMath
+    SafeMath,
+    LibPartialAmount
 {
+    /// @dev Fills the input order. Reverts if exact takerSellAmount not filled.
     /// @param order Order struct containing order specifications.
-    /// @param takerTokenFillAmount Desired amount of takerToken to fill.
+    /// @param takerSellAmount Desired amount of takerToken to fill.
     /// @param signature Maker's signature of the order.
     function fillOrKillOrder(
-        Order order,
-        uint256 takerTokenFillAmount,
-        bytes signature)
+        Order memory order,
+        uint256 takerSellAmount,
+        bytes memory signature)
         public
     {
         require(
             fillOrder(
                 order,
-                takerTokenFillAmount,
+                takerSellAmount,
                 signature
-            ) == takerTokenFillAmount
+            ) == takerSellAmount
         );
     }
 
-    /// @dev Fills an order with specified parameters and ECDSA signature. Returns false if the transaction would otherwise revert.
+    /// @dev Fills an order with specified parameters and ECDSA signature.
+    ///      Returns false if the transaction would otherwise revert.
     /// @param order Order struct containing order specifications.
-    /// @param takerTokenFillAmount Desired amount of takerToken to fill.
+    /// @param takerSellAmount Desired amount of takerToken to fill.
     /// @param signature Maker's signature of the order.
     /// @return Total amount of takerToken filled in trade.
     function fillOrderNoThrow(
-        Order order,
-        uint256 takerTokenFillAmount,
-        bytes signature)
+        Order memory order,
+        uint256 takerSellAmount,
+        bytes memory signature)
         public
-        returns (uint256 takerTokenFilledAmount)
+        returns (uint256 takerAmountSold)
     {
         // We need to call MExchangeCore.fillOrder using a delegatecall in
         // assembly so that we can intercept a call that throws. For this, we
@@ -101,8 +105,8 @@ contract MixinWrapperFunctions is
             mstore(add(start, 292), mload(add(order, 288))) // expirationTimeSeconds
             mstore(add(start, 324), mload(add(order, 320))) // salt
 
-            // Write takerTokenFillAmount
-            mstore(add(start, 356), takerTokenFillAmount)
+            // Write takerSellAmount
+            mstore(add(start, 356), takerSellAmount)
 
             // Write signature offset
             mstore(add(start, 388), 416)
@@ -133,30 +137,30 @@ contract MixinWrapperFunctions is
             )
             switch success
             case 0 {
-                takerTokenFilledAmount := 0
+                takerAmountSold := 0
             }
             case 1 {
-                takerTokenFilledAmount := mload(start)
+                takerAmountSold := mload(start)
             }
 
         }
-        return takerTokenFilledAmount;
+        return takerAmountSold;
     }
 
     /// @dev Synchronously executes multiple calls of fillOrder in a single transaction.
     /// @param orders Array of orders.
-    /// @param takerTokenFillAmounts Array of desired amounts of takerToken to fill in orders.
+    /// @param takerSellAmounts Array of desired amounts of takerToken to fill in orders.
     /// @param signatures Maker's signatures of the orders.
     function batchFillOrders(
-        Order[] orders,
-        uint256[] takerTokenFillAmounts,
-        bytes[] signatures)
+        Order[] memory orders,
+        uint256[] memory takerSellAmounts,
+        bytes[] memory signatures)
         public
     {
         for (uint256 i = 0; i < orders.length; i++) {
             fillOrder(
                 orders[i],
-                takerTokenFillAmounts[i],
+                takerSellAmounts[i],
                 signatures[i]
             );
         }
@@ -164,18 +168,18 @@ contract MixinWrapperFunctions is
 
     /// @dev Synchronously executes multiple calls of fillOrKill in a single transaction.
     /// @param orders Array of orders.
-    /// @param takerTokenFillAmounts Array of desired amounts of takerToken to fill in orders.
+    /// @param takerSellAmounts Array of desired amounts of takerToken to fill in orders.
     /// @param signatures Maker's signatures of the orders.
     function batchFillOrKillOrders(
-        Order[] orders,
-        uint256[] takerTokenFillAmounts,
-        bytes[] signatures)
+        Order[] memory orders,
+        uint256[] memory takerSellAmounts,
+        bytes[] memory signatures)
         public
     {
         for (uint256 i = 0; i < orders.length; i++) {
             fillOrKillOrder(
                 orders[i],
-                takerTokenFillAmounts[i],
+                takerSellAmounts[i],
                 signatures[i]
             );
         }
@@ -183,86 +187,168 @@ contract MixinWrapperFunctions is
 
     /// @dev Fills an order with specified parameters and ECDSA signature. Returns false if the transaction would otherwise revert.
     /// @param orders Array of orders.
-    /// @param takerTokenFillAmounts Array of desired amounts of takerToken to fill in orders.
+    /// @param takerSellAmounts Array of desired amounts of takerToken to fill in orders.
     /// @param signatures Maker's signatures of the orders.
     function batchFillOrdersNoThrow(
-        Order[] orders,
-        uint256[] takerTokenFillAmounts,
-        bytes[] signatures)
+        Order[] memory orders,
+        uint256[] memory takerSellAmounts,
+        bytes[] memory signatures)
         public
     {
         for (uint256 i = 0; i < orders.length; i++) {
             fillOrderNoThrow(
                 orders[i],
-                takerTokenFillAmounts[i],
+                takerSellAmounts[i],
                 signatures[i]
             );
         }
     }
 
-    /// @dev Synchronously executes multiple fill orders in a single transaction until total takerTokenFillAmount filled.
+    /// @dev Synchronously executes multiple fill orders in a single transaction until total amount is sold by taker.
     /// @param orders Array of orders.
-    /// @param takerTokenFillAmount Desired amount of takerToken to fill.
+    /// @param takerSellAmount Desired amount of takerToken to sell.
     /// @param signatures Maker's signatures of the orders.
-    /// @return Total amount of takerTokenFillAmount filled in orders.
-    function marketFillOrders(
-        Order[] orders,
-        uint256 takerTokenFillAmount,
-        bytes[] signatures)
+    /// @return Total amount of tokens sold by taker in orders.
+    function marketSellOrders(
+        Order[] memory orders,
+        uint256 takerSellAmount,
+        bytes[] memory signatures)
         public
-        returns (uint256 totalTakerTokenFilledAmount)
+        returns (uint256 takerAmountSold)
     {
         for (uint256 i = 0; i < orders.length; i++) {
             require(orders[i].takerTokenAddress == orders[0].takerTokenAddress);
-            uint256 remainingTakerTokenFillAmount = safeSub(takerTokenFillAmount, totalTakerTokenFilledAmount);
-            totalTakerTokenFilledAmount = safeAdd(
-                totalTakerTokenFilledAmount,
+            uint256 remainingTakerSellAmount = safeSub(takerSellAmount, takerAmountSold);
+            takerAmountSold = safeAdd(
+                takerAmountSold,
                 fillOrder(
                     orders[i],
-                    remainingTakerTokenFillAmount,
+                    remainingTakerSellAmount,
                     signatures[i]
                 )
             );
-            if (totalTakerTokenFilledAmount == takerTokenFillAmount) {
+            if (takerAmountSold == takerSellAmount) {
                 break;
             }
         }
-        return totalTakerTokenFilledAmount;
+        return takerAmountSold;
     }
 
-    /// @dev Synchronously executes multiple calls of fillOrderNoThrow in a single transaction until total takerTokenFillAmount filled.
+    /// @dev Synchronously executes multiple calls of fillOrderNoThrow in a single transaction until total amount is sold by taker.
+    ///      Returns false if the transaction would otherwise revert.
     /// @param orders Array of orders.
-    /// @param takerTokenFillAmount Desired total amount of takerToken to fill in orders.
+    /// @param takerSellAmount Desired amount of takerToken to sell.
     /// @param signatures Maker's signatures of the orders.
-    /// @return Total amount of takerTokenFillAmount filled in orders.
-    function marketFillOrdersNoThrow(
-        Order[] orders,
-        uint256 takerTokenFillAmount,
-        bytes[] signatures)
+    /// @return Total amount of tokens sold by taker in orders.
+    function marketSellOrdersNoThrow(
+        Order[] memory orders,
+        uint256 takerSellAmount,
+        bytes[] memory signatures)
         public
-        returns (uint256 totalTakerTokenFilledAmount)
+        returns (uint256 takerAmountSold)
     {
         for (uint256 i = 0; i < orders.length; i++) {
             require(orders[i].takerTokenAddress == orders[0].takerTokenAddress);
-            uint256 remainingTakerTokenFillAmount = safeSub(takerTokenFillAmount, totalTakerTokenFilledAmount);
-            totalTakerTokenFilledAmount = safeAdd(
-                totalTakerTokenFilledAmount,
+            uint256 remainingTakerSellAmount = safeSub(takerSellAmount, takerAmountSold);
+            takerAmountSold = safeAdd(
+                takerAmountSold,
                 fillOrderNoThrow(
                     orders[i],
-                    remainingTakerTokenFillAmount,
+                    remainingTakerSellAmount,
+                    signatures[i]
+                )
+            );
+            if (takerAmountSold == takerSellAmount) {
+                break;
+            }
+        }
+        return takerAmountSold;
+    }
+
+    /// @dev Synchronously executes multiple fill orders in a single transaction until total amount is bought by taker.
+    /// @param orders Array of orders.
+    /// @param takerBuyAmount Desired amount of makerToken to buy.
+    /// @param signatures Maker's signatures of the orders.
+    /// @return Total amount of takerTokenFillAmount filled in orders.
+    function marketBuyOrders(
+        Order[] memory orders,
+        uint256 takerBuyAmount,
+        bytes[] memory signatures)
+        public
+        returns (uint256 takerAmountBought)
+    {
+        for (uint256 i = 0; i < orders.length; i++) {
+            require(orders[i].takerTokenAddress == orders[0].takerTokenAddress);
+            uint256 remainingTakerBuyAmount = safeSub(takerBuyAmount, takerAmountBought);
+            uint256 takerSellAmount = getPartialAmount(
+                orders[i].makerBuyAmount,
+                orders[i].makerSellAmount,
+                remainingTakerBuyAmount
+            );
+            uint256 takerAmountSold = fillOrder(
+                    orders[i],
+                    takerSellAmount,
                     signatures[i]
+            );
+            takerAmountBought = safeAdd(
+                takerAmountBought,
+                getPartialAmount(
+                    orders[i].makerSellAmount,
+                    orders[i].makerBuyAmount,
+                    takerAmountSold
+                )
+            );
+            if (takerAmountBought == takerBuyAmount) {
+                break;
+            }
+        }
+        return takerAmountBought;
+    }
+
+    /// @dev Synchronously executes multiple fill orders in a single transaction until total amount is bought by taker.
+    ///      Returns false if the transaction would otherwise revert.
+    /// @param orders Array of orders.
+    /// @param takerBuyAmount Desired amount of makerToken to fill.
+    /// @param signatures Maker's signatures of the orders.
+    /// @return Total amount of takerTokenFillAmount filled in orders.
+    function marketBuyOrdersNoThrow(
+        Order[] memory orders,
+        uint256 takerBuyAmount,
+        bytes[] memory signatures)
+        public
+        returns (uint256 takerAmountBought)
+    {
+        for (uint256 i = 0; i < orders.length; i++) {
+            require(orders[i].takerTokenAddress == orders[0].takerTokenAddress);
+            uint256 remainingTakerBuyAmount = safeSub(takerBuyAmount, takerAmountBought);
+            uint256 takerSellAmount = getPartialAmount(
+                orders[i].makerBuyAmount,
+                orders[i].makerSellAmount,
+                remainingTakerBuyAmount
+            );
+            uint256 takerAmountSold = fillOrderNoThrow(
+                    orders[i],
+                    takerSellAmount,
+                    signatures[i]
+            );
+            takerAmountBought = safeAdd(
+                takerAmountBought,
+                getPartialAmount(
+                    orders[i].makerSellAmount,
+                    orders[i].makerBuyAmount,
+                    takerAmountSold
                 )
             );
-            if (totalTakerTokenFilledAmount == takerTokenFillAmount) {
+            if (takerAmountBought == takerBuyAmount) {
                 break;
             }
         }
-        return totalTakerTokenFilledAmount;
+        return takerAmountBought;
     }
 
     /// @dev Synchronously cancels multiple orders in a single transaction.
     /// @param orders Array of orders.
-    function batchCancelOrders(Order[] orders)
+    function batchCancelOrders(Order[] memory orders)
         public
     {
         for (uint256 i = 0; i < orders.length; i++) {
diff --git a/packages/contracts/src/utils/exchange_wrapper.ts b/packages/contracts/src/utils/exchange_wrapper.ts
index 179fe44a5..743a9c496 100644
--- a/packages/contracts/src/utils/exchange_wrapper.ts
+++ b/packages/contracts/src/utils/exchange_wrapper.ts
@@ -22,12 +22,12 @@ export class ExchangeWrapper {
     public async fillOrderAsync(
         signedOrder: SignedOrder,
         from: string,
-        opts: { takerTokenFillAmount?: BigNumber } = {},
+        opts: { takerSellAmount?: BigNumber } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = orderUtils.createFill(signedOrder, opts.takerTokenFillAmount);
+        const params = orderUtils.createFill(signedOrder, opts.takerSellAmount);
         const txHash = await this._exchange.fillOrder.sendTransactionAsync(
             params.order,
-            params.takerTokenFillAmount,
+            params.takerSellAmount,
             params.signature,
             { from },
         );
@@ -43,12 +43,12 @@ export class ExchangeWrapper {
     public async fillOrKillOrderAsync(
         signedOrder: SignedOrder,
         from: string,
-        opts: { takerTokenFillAmount?: BigNumber } = {},
+        opts: { takerSellAmount?: BigNumber } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = orderUtils.createFill(signedOrder, opts.takerTokenFillAmount);
+        const params = orderUtils.createFill(signedOrder, opts.takerSellAmount);
         const txHash = await this._exchange.fillOrKillOrder.sendTransactionAsync(
             params.order,
-            params.takerTokenFillAmount,
+            params.takerSellAmount,
             params.signature,
             { from },
         );
@@ -58,12 +58,12 @@ export class ExchangeWrapper {
     public async fillOrderNoThrowAsync(
         signedOrder: SignedOrder,
         from: string,
-        opts: { takerTokenFillAmount?: BigNumber } = {},
+        opts: { takerSellAmount?: BigNumber } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = orderUtils.createFill(signedOrder, opts.takerTokenFillAmount);
+        const params = orderUtils.createFill(signedOrder, opts.takerSellAmount);
         const txHash = await this._exchange.fillOrderNoThrow.sendTransactionAsync(
             params.order,
-            params.takerTokenFillAmount,
+            params.takerSellAmount,
             params.signature,
             { from },
         );
@@ -73,12 +73,12 @@ export class ExchangeWrapper {
     public async batchFillOrdersAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { takerTokenFillAmounts?: BigNumber[] } = {},
+        opts: { takerSellAmounts?: BigNumber[] } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createBatchFill(orders, opts.takerTokenFillAmounts);
+        const params = formatters.createBatchFill(orders, opts.takerSellAmounts);
         const txHash = await this._exchange.batchFillOrders.sendTransactionAsync(
             params.orders,
-            params.takerTokenFillAmounts,
+            params.takerSellAmounts,
             params.signatures,
             { from },
         );
@@ -88,12 +88,12 @@ export class ExchangeWrapper {
     public async batchFillOrKillOrdersAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { takerTokenFillAmounts?: BigNumber[] } = {},
+        opts: { takerSellAmounts?: BigNumber[] } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createBatchFill(orders, opts.takerTokenFillAmounts);
+        const params = formatters.createBatchFill(orders, opts.takerSellAmounts);
         const txHash = await this._exchange.batchFillOrKillOrders.sendTransactionAsync(
             params.orders,
-            params.takerTokenFillAmounts,
+            params.takerSellAmounts,
             params.signatures,
             { from },
         );
@@ -103,42 +103,72 @@ export class ExchangeWrapper {
     public async batchFillOrdersNoThrowAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { takerTokenFillAmounts?: BigNumber[] } = {},
+        opts: { takerSellAmounts?: BigNumber[] } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createBatchFill(orders, opts.takerTokenFillAmounts);
+        const params = formatters.createBatchFill(orders, opts.takerSellAmounts);
         const txHash = await this._exchange.batchFillOrdersNoThrow.sendTransactionAsync(
             params.orders,
-            params.takerTokenFillAmounts,
+            params.takerSellAmounts,
             params.signatures,
             { from },
         );
         const tx = await this._getTxWithDecodedExchangeLogsAsync(txHash);
         return tx;
     }
-    public async marketFillOrdersAsync(
+    public async marketSellOrdersAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { takerTokenFillAmount: BigNumber },
+        opts: { takerSellAmount: BigNumber },
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createMarketFillOrders(orders, opts.takerTokenFillAmount);
-        const txHash = await this._exchange.marketFillOrders.sendTransactionAsync(
+        const params = formatters.createMarketSellOrders(orders, opts.takerSellAmount);
+        const txHash = await this._exchange.marketSellOrders.sendTransactionAsync(
             params.orders,
-            params.takerTokenFillAmount,
+            params.takerSellAmount,
             params.signatures,
             { from },
         );
         const tx = await this._getTxWithDecodedExchangeLogsAsync(txHash);
         return tx;
     }
-    public async marketFillOrdersNoThrowAsync(
+    public async marketSellOrdersNoThrowAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { takerTokenFillAmount: BigNumber },
+        opts: { takerSellAmount: BigNumber },
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createMarketFillOrders(orders, opts.takerTokenFillAmount);
-        const txHash = await this._exchange.marketFillOrdersNoThrow.sendTransactionAsync(
+        const params = formatters.createMarketSellOrders(orders, opts.takerSellAmount);
+        const txHash = await this._exchange.marketSellOrdersNoThrow.sendTransactionAsync(
             params.orders,
-            params.takerTokenFillAmount,
+            params.takerSellAmount,
+            params.signatures,
+            { from },
+        );
+        const tx = await this._getTxWithDecodedExchangeLogsAsync(txHash);
+        return tx;
+    }
+    public async marketBuyOrdersAsync(
+        orders: SignedOrder[],
+        from: string,
+        opts: { takerBuyAmount: BigNumber },
+    ): Promise<TransactionReceiptWithDecodedLogs> {
+        const params = formatters.createMarketBuyOrders(orders, opts.takerBuyAmount);
+        const txHash = await this._exchange.marketBuyOrders.sendTransactionAsync(
+            params.orders,
+            params.takerBuyAmount,
+            params.signatures,
+            { from },
+        );
+        const tx = await this._getTxWithDecodedExchangeLogsAsync(txHash);
+        return tx;
+    }
+    public async marketBuyOrdersNoThrowAsync(
+        orders: SignedOrder[],
+        from: string,
+        opts: { takerBuyAmount: BigNumber },
+    ): Promise<TransactionReceiptWithDecodedLogs> {
+        const params = formatters.createMarketBuyOrders(orders, opts.takerBuyAmount);
+        const txHash = await this._exchange.marketBuyOrdersNoThrow.sendTransactionAsync(
+            params.orders,
+            params.takerBuyAmount,
             params.signatures,
             { from },
         );
@@ -191,7 +221,7 @@ export class ExchangeWrapper {
         );
         return partialAmount;
     }
-    public async getFilledTakerTokenAmountAsync(orderHashHex: string): Promise<BigNumber> {
+    public async getMakerAmountBoughtAsync(orderHashHex: string): Promise<BigNumber> {
         const filledAmount = new BigNumber(await this._exchange.filled.callAsync(orderHashHex));
         return filledAmount;
     }
diff --git a/packages/contracts/src/utils/formatters.ts b/packages/contracts/src/utils/formatters.ts
index 2b261f967..d70c03cb8 100644
--- a/packages/contracts/src/utils/formatters.ts
+++ b/packages/contracts/src/utils/formatters.ts
@@ -1,78 +1,59 @@
 import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 
-import { BatchCancelOrders, BatchFillOrders, MarketFillOrders, SignedOrder } from './types';
+import { orderUtils } from './order_utils';
+import { BatchCancelOrders, BatchFillOrders, MarketBuyOrders, MarketSellOrders, SignedOrder } from './types';
 
 export const formatters = {
-    createBatchFill(signedOrders: SignedOrder[], takerTokenFillAmounts: BigNumber[] = []) {
+    createBatchFill(signedOrders: SignedOrder[], takerSellAmounts: BigNumber[] = []) {
         const batchFill: BatchFillOrders = {
             orders: [],
             signatures: [],
-            takerTokenFillAmounts,
+            takerSellAmounts,
         };
         _.forEach(signedOrders, signedOrder => {
-            batchFill.orders.push({
-                makerAddress: signedOrder.makerAddress,
-                takerAddress: signedOrder.takerAddress,
-                makerTokenAddress: signedOrder.makerTokenAddress,
-                takerTokenAddress: signedOrder.takerTokenAddress,
-                feeRecipientAddress: signedOrder.feeRecipientAddress,
-                makerTokenAmount: signedOrder.makerTokenAmount,
-                takerTokenAmount: signedOrder.takerTokenAmount,
-                makerFeeAmount: signedOrder.makerFeeAmount,
-                takerFeeAmount: signedOrder.takerFeeAmount,
-                expirationTimeSeconds: signedOrder.expirationTimeSeconds,
-                salt: signedOrder.salt,
-            });
+            const orderStruct = orderUtils.getOrderStruct(signedOrder);
+            batchFill.orders.push(orderStruct);
             batchFill.signatures.push(signedOrder.signature);
-            if (takerTokenFillAmounts.length < signedOrders.length) {
-                batchFill.takerTokenFillAmounts.push(signedOrder.takerTokenAmount);
+            if (takerSellAmounts.length < signedOrders.length) {
+                batchFill.takerSellAmounts.push(signedOrder.makerBuyAmount);
             }
         });
         return batchFill;
     },
-    createMarketFillOrders(signedOrders: SignedOrder[], takerTokenFillAmount: BigNumber) {
-        const marketFillOrders: MarketFillOrders = {
+    createMarketSellOrders(signedOrders: SignedOrder[], takerSellAmount: BigNumber) {
+        const marketSellOrders: MarketSellOrders = {
             orders: [],
             signatures: [],
-            takerTokenFillAmount,
+            takerSellAmount,
         };
         _.forEach(signedOrders, signedOrder => {
-            marketFillOrders.orders.push({
-                makerAddress: signedOrder.makerAddress,
-                takerAddress: signedOrder.takerAddress,
-                makerTokenAddress: signedOrder.makerTokenAddress,
-                takerTokenAddress: signedOrder.takerTokenAddress,
-                feeRecipientAddress: signedOrder.feeRecipientAddress,
-                makerTokenAmount: signedOrder.makerTokenAmount,
-                takerTokenAmount: signedOrder.takerTokenAmount,
-                makerFeeAmount: signedOrder.makerFeeAmount,
-                takerFeeAmount: signedOrder.takerFeeAmount,
-                expirationTimeSeconds: signedOrder.expirationTimeSeconds,
-                salt: signedOrder.salt,
-            });
-            marketFillOrders.signatures.push(signedOrder.signature);
+            const orderStruct = orderUtils.getOrderStruct(signedOrder);
+            marketSellOrders.orders.push(orderStruct);
+            marketSellOrders.signatures.push(signedOrder.signature);
         });
-        return marketFillOrders;
+        return marketSellOrders;
+    },
+    createMarketBuyOrders(signedOrders: SignedOrder[], takerBuyAmount: BigNumber) {
+        const marketBuyOrders: MarketBuyOrders = {
+            orders: [],
+            signatures: [],
+            takerBuyAmount,
+        };
+        _.forEach(signedOrders, signedOrder => {
+            const orderStruct = orderUtils.getOrderStruct(signedOrder);
+            marketBuyOrders.orders.push(orderStruct);
+            marketBuyOrders.signatures.push(signedOrder.signature);
+        });
+        return marketBuyOrders;
     },
     createBatchCancel(signedOrders: SignedOrder[]) {
         const batchCancel: BatchCancelOrders = {
             orders: [],
         };
         _.forEach(signedOrders, signedOrder => {
-            batchCancel.orders.push({
-                makerAddress: signedOrder.makerAddress,
-                takerAddress: signedOrder.takerAddress,
-                makerTokenAddress: signedOrder.makerTokenAddress,
-                takerTokenAddress: signedOrder.takerTokenAddress,
-                feeRecipientAddress: signedOrder.feeRecipientAddress,
-                makerTokenAmount: signedOrder.makerTokenAmount,
-                takerTokenAmount: signedOrder.takerTokenAmount,
-                makerFeeAmount: signedOrder.makerFeeAmount,
-                takerFeeAmount: signedOrder.takerFeeAmount,
-                expirationTimeSeconds: signedOrder.expirationTimeSeconds,
-                salt: signedOrder.salt,
-            });
+            const orderStruct = orderUtils.getOrderStruct(signedOrder);
+            batchCancel.orders.push(orderStruct);
         });
         return batchCancel;
     },
diff --git a/packages/contracts/src/utils/order_utils.ts b/packages/contracts/src/utils/order_utils.ts
index c14dc4e80..1f808024a 100644
--- a/packages/contracts/src/utils/order_utils.ts
+++ b/packages/contracts/src/utils/order_utils.ts
@@ -7,10 +7,10 @@ import { crypto } from './crypto';
 import { OrderStruct, SignatureType, SignedOrder, UnsignedOrder } from './types';
 
 export const orderUtils = {
-    createFill: (signedOrder: SignedOrder, takerTokenFillAmount?: BigNumber) => {
+    createFill: (signedOrder: SignedOrder, takerSellAmount?: BigNumber) => {
         const fill = {
             order: orderUtils.getOrderStruct(signedOrder),
-            takerTokenFillAmount: takerTokenFillAmount || signedOrder.takerTokenAmount,
+            takerSellAmount: takerSellAmount || signedOrder.makerBuyAmount,
             signature: signedOrder.signature,
         };
         return fill;
@@ -18,7 +18,7 @@ export const orderUtils = {
     createCancel(signedOrder: SignedOrder, takerTokenCancelAmount?: BigNumber) {
         const cancel = {
             order: orderUtils.getOrderStruct(signedOrder),
-            takerTokenCancelAmount: takerTokenCancelAmount || signedOrder.takerTokenAmount,
+            takerTokenCancelAmount: takerTokenCancelAmount || signedOrder.makerBuyAmount,
         };
         return cancel;
     },
@@ -29,10 +29,10 @@ export const orderUtils = {
             makerTokenAddress: signedOrder.makerTokenAddress,
             takerTokenAddress: signedOrder.takerTokenAddress,
             feeRecipientAddress: signedOrder.feeRecipientAddress,
-            makerTokenAmount: signedOrder.makerTokenAmount,
-            takerTokenAmount: signedOrder.takerTokenAmount,
-            makerFeeAmount: signedOrder.makerFeeAmount,
-            takerFeeAmount: signedOrder.takerFeeAmount,
+            makerSellAmount: signedOrder.makerSellAmount,
+            makerBuyAmount: signedOrder.makerBuyAmount,
+            makerFee: signedOrder.makerFee,
+            takerFee: signedOrder.takerFee,
             expirationTimeSeconds: signedOrder.expirationTimeSeconds,
             salt: signedOrder.salt,
         };
@@ -46,10 +46,10 @@ export const orderUtils = {
             'address makerTokenAddress',
             'address takerTokenAddress',
             'address feeRecipientAddress',
-            'uint256 makerTokenAmount',
-            'uint256 takerTokenAmount',
-            'uint256 makerFeeAmount',
-            'uint256 takerFeeAmount',
+            'uint256 makerSellAmount',
+            'uint256 makerBuyAmount',
+            'uint256 makerFee',
+            'uint256 takerFee',
             'uint256 expirationTimeSeconds',
             'uint256 salt',
         ]);
@@ -60,10 +60,10 @@ export const orderUtils = {
             order.makerTokenAddress,
             order.takerTokenAddress,
             order.feeRecipientAddress,
-            order.makerTokenAmount,
-            order.takerTokenAmount,
-            order.makerFeeAmount,
-            order.takerFeeAmount,
+            order.makerSellAmount,
+            order.makerBuyAmount,
+            order.makerFee,
+            order.takerFee,
             order.expirationTimeSeconds,
             order.salt,
         ]);
diff --git a/packages/contracts/src/utils/types.ts b/packages/contracts/src/utils/types.ts
index ce87e9851..570f664e0 100644
--- a/packages/contracts/src/utils/types.ts
+++ b/packages/contracts/src/utils/types.ts
@@ -14,13 +14,19 @@ export interface SubmissionContractEventArgs {
 export interface BatchFillOrders {
     orders: OrderStruct[];
     signatures: string[];
-    takerTokenFillAmounts: BigNumber[];
+    takerSellAmounts: BigNumber[];
 }
 
-export interface MarketFillOrders {
+export interface MarketSellOrders {
     orders: OrderStruct[];
     signatures: string[];
-    takerTokenFillAmount: BigNumber;
+    takerSellAmount: BigNumber;
+}
+
+export interface MarketBuyOrders {
+    orders: OrderStruct[];
+    signatures: string[];
+    takerBuyAmount: BigNumber;
 }
 
 export interface BatchCancelOrders {
@@ -37,10 +43,10 @@ export interface DefaultOrderParams {
     feeRecipientAddress: string;
     makerTokenAddress: string;
     takerTokenAddress: string;
-    makerTokenAmount: BigNumber;
-    takerTokenAmount: BigNumber;
-    makerFeeAmount: BigNumber;
-    takerFeeAmount: BigNumber;
+    makerSellAmount: BigNumber;
+    makerBuyAmount: BigNumber;
+    makerFee: BigNumber;
+    takerFee: BigNumber;
 }
 
 export interface TransactionDataParams {
@@ -122,10 +128,10 @@ export interface OrderStruct {
     makerTokenAddress: string;
     takerTokenAddress: string;
     feeRecipientAddress: string;
-    makerTokenAmount: BigNumber;
-    takerTokenAmount: BigNumber;
-    makerFeeAmount: BigNumber;
-    takerFeeAmount: BigNumber;
+    makerSellAmount: BigNumber;
+    makerBuyAmount: BigNumber;
+    makerFee: BigNumber;
+    takerFee: BigNumber;
     expirationTimeSeconds: BigNumber;
     salt: BigNumber;
 }
diff --git a/packages/contracts/test/exchange/core.ts b/packages/contracts/test/exchange/core.ts
index f3ab94139..b9ad309fc 100644
--- a/packages/contracts/test/exchange/core.ts
+++ b/packages/contracts/test/exchange/core.ts
@@ -19,7 +19,6 @@ import { Balances } from '../../src/utils/balances';
 import { constants } from '../../src/utils/constants';
 import { crypto } from '../../src/utils/crypto';
 import { ExchangeWrapper } from '../../src/utils/exchange_wrapper';
-import { LogDecoder } from '../../src/utils/log_decoder';
 import { OrderFactory } from '../../src/utils/order_factory';
 import { orderUtils } from '../../src/utils/order_utils';
 import { BalancesByOwner, ContractName, ExchangeContractErrs, SignatureType, SignedOrder } from '../../src/utils/types';
@@ -30,7 +29,6 @@ import { provider, web3Wrapper } from '../utils/web3_wrapper';
 chaiSetup.configure();
 const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
-const logDecoder = new LogDecoder(constants.TESTRPC_NETWORK_ID);
 
 describe('Exchange', () => {
     let makerAddress: string;
@@ -90,10 +88,10 @@ describe('Exchange', () => {
             feeRecipientAddress,
             makerTokenAddress: rep.address,
             takerTokenAddress: dgd.address,
-            makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-            takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
-            makerFeeAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
-            takerFeeAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
+            makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+            makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+            makerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
+            takerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
         };
         const privateKey = constants.TESTRPC_PRIVATE_KEYS[0];
         orderFactory = new OrderFactory(privateKey, defaultOrderParams);
@@ -145,80 +143,80 @@ describe('Exchange', () => {
 
         it('should create an unfillable order', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(1001),
-                takerTokenAmount: new BigNumber(3),
+                makerSellAmount: new BigNumber(1001),
+                makerBuyAmount: new BigNumber(3),
             });
 
-            const filledTakerTokenAmountBefore = await exWrapper.getFilledTakerTokenAmountAsync(
+            const makerAmountBoughtBefore = await exWrapper.getMakerAmountBoughtAsync(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(filledTakerTokenAmountBefore).to.be.bignumber.equal(0);
+            expect(makerAmountBoughtBefore).to.be.bignumber.equal(0);
 
             const fillTakerTokenAmount1 = new BigNumber(2);
             await exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount: fillTakerTokenAmount1,
+                takerSellAmount: fillTakerTokenAmount1,
             });
 
-            const filledTakerTokenAmountAfter1 = await exWrapper.getFilledTakerTokenAmountAsync(
+            const filledTakerTokenAmountAfter1 = await exWrapper.getMakerAmountBoughtAsync(
                 orderUtils.getOrderHashHex(signedOrder),
             );
             expect(filledTakerTokenAmountAfter1).to.be.bignumber.equal(fillTakerTokenAmount1);
 
             const fillTakerTokenAmount2 = new BigNumber(1);
             await exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount: fillTakerTokenAmount2,
+                takerSellAmount: fillTakerTokenAmount2,
             });
 
-            const filledTakerTokenAmountAfter2 = await exWrapper.getFilledTakerTokenAmountAsync(
+            const filledTakerTokenAmountAfter2 = await exWrapper.getMakerAmountBoughtAsync(
                 orderUtils.getOrderHashHex(signedOrder),
             );
             expect(filledTakerTokenAmountAfter2).to.be.bignumber.equal(filledTakerTokenAmountAfter1);
         });
 
-        it('should transfer the correct amounts when makerTokenAmount === takerTokenAmount', async () => {
+        it('should transfer the correct amounts when makerSellAmount === makerBuyAmount', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
             });
 
-            const filledTakerTokenAmountBefore = await exWrapper.getFilledTakerTokenAmountAsync(
+            const makerAmountBoughtBefore = await exWrapper.getMakerAmountBoughtAsync(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(filledTakerTokenAmountBefore).to.be.bignumber.equal(0);
+            expect(makerAmountBoughtBefore).to.be.bignumber.equal(0);
 
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+            const takerSellAmount = signedOrder.makerBuyAmount.div(2);
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerSellAmount });
 
-            const filledTakerTokenAmountAfter = await exWrapper.getFilledTakerTokenAmountAsync(
+            const makerAmountBoughtAfter = await exWrapper.getMakerAmountBoughtAsync(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(filledTakerTokenAmountAfter).to.be.bignumber.equal(takerTokenFillAmount);
+            expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerSellAmount);
 
             const newBalances = await dmyBalances.getAsync();
 
-            const makerTokenFillAmount = takerTokenFillAmount
-                .times(signedOrder.makerTokenAmount)
-                .dividedToIntegerBy(signedOrder.takerTokenAmount);
-            const makerFeePaid = signedOrder.makerFeeAmount
-                .times(makerTokenFillAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
-            const takerFeePaid = signedOrder.takerFeeAmount
-                .times(makerTokenFillAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+            const makerAmountSold = takerSellAmount
+                .times(signedOrder.makerSellAmount)
+                .dividedToIntegerBy(signedOrder.makerBuyAmount);
+            const makerFeePaid = signedOrder.makerFee
+                .times(makerAmountSold)
+                .dividedToIntegerBy(signedOrder.makerSellAmount);
+            const takerFeePaid = signedOrder.takerFee
+                .times(makerAmountSold)
+                .dividedToIntegerBy(signedOrder.makerSellAmount);
             expect(newBalances[makerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.makerTokenAddress].minus(makerTokenFillAmount),
+                balances[makerAddress][signedOrder.makerTokenAddress].minus(makerAmountSold),
             );
             expect(newBalances[makerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.takerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][signedOrder.takerTokenAddress].add(takerSellAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(makerFeePaid),
             );
             expect(newBalances[takerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerSellAmount),
             );
             expect(newBalances[takerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.makerTokenAddress].add(makerTokenFillAmount),
+                balances[takerAddress][signedOrder.makerTokenAddress].add(makerAmountSold),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[takerAddress][zrx.address].minus(takerFeePaid),
@@ -228,50 +226,50 @@ describe('Exchange', () => {
             );
         });
 
-        it('should transfer the correct amounts when makerTokenAmount > takerTokenAmount', async () => {
+        it('should transfer the correct amounts when makerSellAmount > makerBuyAmount', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+                makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
             });
 
-            const filledTakerTokenAmountBefore = await exWrapper.getFilledTakerTokenAmountAsync(
+            const makerAmountBoughtBefore = await exWrapper.getMakerAmountBoughtAsync(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(filledTakerTokenAmountBefore).to.be.bignumber.equal(0);
+            expect(makerAmountBoughtBefore).to.be.bignumber.equal(0);
 
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+            const takerSellAmount = signedOrder.makerBuyAmount.div(2);
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerSellAmount });
 
-            const filledTakerTokenAmountAfter = await exWrapper.getFilledTakerTokenAmountAsync(
+            const makerAmountBoughtAfter = await exWrapper.getMakerAmountBoughtAsync(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(filledTakerTokenAmountAfter).to.be.bignumber.equal(takerTokenFillAmount);
+            expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerSellAmount);
 
             const newBalances = await dmyBalances.getAsync();
 
-            const makerTokenFillAmount = takerTokenFillAmount
-                .times(signedOrder.makerTokenAmount)
-                .dividedToIntegerBy(signedOrder.takerTokenAmount);
-            const makerFeePaid = signedOrder.makerFeeAmount
-                .times(makerTokenFillAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
-            const takerFeePaid = signedOrder.takerFeeAmount
-                .times(makerTokenFillAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+            const makerAmountSold = takerSellAmount
+                .times(signedOrder.makerSellAmount)
+                .dividedToIntegerBy(signedOrder.makerBuyAmount);
+            const makerFeePaid = signedOrder.makerFee
+                .times(makerAmountSold)
+                .dividedToIntegerBy(signedOrder.makerSellAmount);
+            const takerFeePaid = signedOrder.takerFee
+                .times(makerAmountSold)
+                .dividedToIntegerBy(signedOrder.makerSellAmount);
             expect(newBalances[makerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.makerTokenAddress].minus(makerTokenFillAmount),
+                balances[makerAddress][signedOrder.makerTokenAddress].minus(makerAmountSold),
             );
             expect(newBalances[makerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.takerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][signedOrder.takerTokenAddress].add(takerSellAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(makerFeePaid),
             );
             expect(newBalances[takerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerSellAmount),
             );
             expect(newBalances[takerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.makerTokenAddress].add(makerTokenFillAmount),
+                balances[takerAddress][signedOrder.makerTokenAddress].add(makerAmountSold),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[takerAddress][zrx.address].minus(takerFeePaid),
@@ -281,50 +279,50 @@ describe('Exchange', () => {
             );
         });
 
-        it('should transfer the correct amounts when makerTokenAmount < takerTokenAmount', async () => {
+        it('should transfer the correct amounts when makerSellAmount < makerBuyAmount', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+                makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             });
 
-            const filledTakerTokenAmountBefore = await exWrapper.getFilledTakerTokenAmountAsync(
+            const makerAmountBoughtBefore = await exWrapper.getMakerAmountBoughtAsync(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(filledTakerTokenAmountBefore).to.be.bignumber.equal(0);
+            expect(makerAmountBoughtBefore).to.be.bignumber.equal(0);
 
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+            const takerSellAmount = signedOrder.makerBuyAmount.div(2);
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerSellAmount });
 
-            const filledTakerTokenAmountAfter = await exWrapper.getFilledTakerTokenAmountAsync(
+            const makerAmountBoughtAfter = await exWrapper.getMakerAmountBoughtAsync(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(filledTakerTokenAmountAfter).to.be.bignumber.equal(takerTokenFillAmount);
+            expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerSellAmount);
 
             const newBalances = await dmyBalances.getAsync();
 
-            const makerTokenFillAmount = takerTokenFillAmount
-                .times(signedOrder.makerTokenAmount)
-                .dividedToIntegerBy(signedOrder.takerTokenAmount);
-            const makerFeePaid = signedOrder.makerFeeAmount
-                .times(makerTokenFillAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
-            const takerFeePaid = signedOrder.takerFeeAmount
-                .times(makerTokenFillAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+            const makerAmountSold = takerSellAmount
+                .times(signedOrder.makerSellAmount)
+                .dividedToIntegerBy(signedOrder.makerBuyAmount);
+            const makerFeePaid = signedOrder.makerFee
+                .times(makerAmountSold)
+                .dividedToIntegerBy(signedOrder.makerSellAmount);
+            const takerFeePaid = signedOrder.takerFee
+                .times(makerAmountSold)
+                .dividedToIntegerBy(signedOrder.makerSellAmount);
             expect(newBalances[makerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.makerTokenAddress].minus(makerTokenFillAmount),
+                balances[makerAddress][signedOrder.makerTokenAddress].minus(makerAmountSold),
             );
             expect(newBalances[makerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.takerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][signedOrder.takerTokenAddress].add(takerSellAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(makerFeePaid),
             );
             expect(newBalances[takerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerSellAmount),
             );
             expect(newBalances[takerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.makerTokenAddress].add(makerTokenFillAmount),
+                balances[takerAddress][signedOrder.makerTokenAddress].add(makerAmountSold),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[takerAddress][zrx.address].minus(takerFeePaid),
@@ -337,49 +335,49 @@ describe('Exchange', () => {
         it('should transfer the correct amounts when taker is specified and order is claimed by taker', async () => {
             signedOrder = orderFactory.newSignedOrder({
                 takerAddress,
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+                makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             });
 
-            const filledTakerTokenAmountBefore = await exWrapper.getFilledTakerTokenAmountAsync(
+            const makerAmountBoughtBefore = await exWrapper.getMakerAmountBoughtAsync(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(filledTakerTokenAmountBefore).to.be.bignumber.equal(0);
+            expect(makerAmountBoughtBefore).to.be.bignumber.equal(0);
 
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+            const takerSellAmount = signedOrder.makerBuyAmount.div(2);
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerSellAmount });
 
-            const filledTakerTokenAmountAfter = await exWrapper.getFilledTakerTokenAmountAsync(
+            const makerAmountBoughtAfter = await exWrapper.getMakerAmountBoughtAsync(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            const expectedFillAmountTAfter = takerTokenFillAmount.add(filledTakerTokenAmountBefore);
-            expect(filledTakerTokenAmountAfter).to.be.bignumber.equal(expectedFillAmountTAfter);
+            const expectedMakerAmountBoughtAfter = takerSellAmount.add(makerAmountBoughtBefore);
+            expect(makerAmountBoughtAfter).to.be.bignumber.equal(expectedMakerAmountBoughtAfter);
 
             const newBalances = await dmyBalances.getAsync();
 
-            const makerTokenFillAmount = takerTokenFillAmount
-                .times(signedOrder.makerTokenAmount)
-                .dividedToIntegerBy(signedOrder.takerTokenAmount);
-            const makerFeePaid = signedOrder.makerFeeAmount
-                .times(makerTokenFillAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
-            const takerFeePaid = signedOrder.takerFeeAmount
-                .times(makerTokenFillAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+            const makerAmountSold = takerSellAmount
+                .times(signedOrder.makerSellAmount)
+                .dividedToIntegerBy(signedOrder.makerBuyAmount);
+            const makerFeePaid = signedOrder.makerFee
+                .times(makerAmountSold)
+                .dividedToIntegerBy(signedOrder.makerSellAmount);
+            const takerFeePaid = signedOrder.takerFee
+                .times(makerAmountSold)
+                .dividedToIntegerBy(signedOrder.makerSellAmount);
             expect(newBalances[makerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.makerTokenAddress].minus(makerTokenFillAmount),
+                balances[makerAddress][signedOrder.makerTokenAddress].minus(makerAmountSold),
             );
             expect(newBalances[makerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.takerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][signedOrder.takerTokenAddress].add(takerSellAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(makerFeePaid),
             );
             expect(newBalances[takerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerSellAmount),
             );
             expect(newBalances[takerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.makerTokenAddress].add(makerTokenFillAmount),
+                balances[takerAddress][signedOrder.makerTokenAddress].add(makerAmountSold),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[takerAddress][zrx.address].minus(takerFeePaid),
@@ -389,69 +387,63 @@ describe('Exchange', () => {
             );
         });
 
-        it('should fill remaining value if takerTokenFillAmount > remaining takerTokenAmount', async () => {
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+        it('should fill remaining value if takerSellAmount > remaining makerBuyAmount', async () => {
+            const takerSellAmount = signedOrder.makerBuyAmount.div(2);
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerSellAmount });
 
             const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount: signedOrder.takerTokenAmount,
+                takerSellAmount: signedOrder.makerBuyAmount,
             });
-            const log = logDecoder.decodeLogOrThrow(res.logs[0]) as LogWithDecodedArgs<LogFillContractEventArgs>;
-            expect(log.args.takerTokenFilledAmount).to.be.bignumber.equal(
-                signedOrder.takerTokenAmount.minus(takerTokenFillAmount),
-            );
+            const log = res.logs[0] as LogWithDecodedArgs<LogFillContractEventArgs>;
+            expect(log.args.makerAmountBought).to.be.bignumber.equal(signedOrder.makerBuyAmount.minus(takerSellAmount));
             const newBalances = await dmyBalances.getAsync();
 
             expect(newBalances[makerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.makerTokenAddress].minus(signedOrder.makerTokenAmount),
+                balances[makerAddress][signedOrder.makerTokenAddress].minus(signedOrder.makerSellAmount),
             );
             expect(newBalances[makerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.takerTokenAddress].add(signedOrder.takerTokenAmount),
+                balances[makerAddress][signedOrder.takerTokenAddress].add(signedOrder.makerBuyAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
-                balances[makerAddress][zrx.address].minus(signedOrder.makerFeeAmount),
+                balances[makerAddress][zrx.address].minus(signedOrder.makerFee),
             );
             expect(newBalances[takerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.takerTokenAddress].minus(signedOrder.takerTokenAmount),
+                balances[takerAddress][signedOrder.takerTokenAddress].minus(signedOrder.makerBuyAmount),
             );
             expect(newBalances[takerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.makerTokenAddress].add(signedOrder.makerTokenAmount),
+                balances[takerAddress][signedOrder.makerTokenAddress].add(signedOrder.makerSellAmount),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
-                balances[takerAddress][zrx.address].minus(signedOrder.takerFeeAmount),
+                balances[takerAddress][zrx.address].minus(signedOrder.takerFee),
             );
             expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal(
-                balances[feeRecipientAddress][zrx.address].add(
-                    signedOrder.makerFeeAmount.add(signedOrder.takerFeeAmount),
-                ),
+                balances[feeRecipientAddress][zrx.address].add(signedOrder.makerFee.add(signedOrder.takerFee)),
             );
         });
 
         it('should log 1 event with the correct arguments when order has a feeRecipient', async () => {
             const divisor = 2;
             const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount: signedOrder.takerTokenAmount.div(divisor),
+                takerSellAmount: signedOrder.makerBuyAmount.div(divisor),
             });
             expect(res.logs).to.have.length(1);
 
-            const log = logDecoder.decodeLogOrThrow(res.logs[0]) as LogWithDecodedArgs<LogFillContractEventArgs>;
+            const log = res.logs[0] as LogWithDecodedArgs<LogFillContractEventArgs>;
             const logArgs = log.args;
-            const expectedFilledMakerTokenAmount = signedOrder.makerTokenAmount.div(divisor);
-            const expectedFilledTakerTokenAmount = signedOrder.takerTokenAmount.div(divisor);
-            const expectedFeeMPaid = signedOrder.makerFeeAmount.div(divisor);
-            const expectedFeeTPaid = signedOrder.takerFeeAmount.div(divisor);
-            const tokensHashBuff = crypto.solSHA3([signedOrder.makerTokenAddress, signedOrder.takerTokenAddress]);
-            const expectedTokens = ethUtil.bufferToHex(tokensHashBuff);
+            const expectedFilledMakerTokenAmount = signedOrder.makerSellAmount.div(divisor);
+            const expectedFilledTakerTokenAmount = signedOrder.makerBuyAmount.div(divisor);
+            const expectedFeeMPaid = signedOrder.makerFee.div(divisor);
+            const expectedFeeTPaid = signedOrder.takerFee.div(divisor);
 
             expect(signedOrder.makerAddress).to.be.equal(logArgs.makerAddress);
             expect(takerAddress).to.be.equal(logArgs.takerAddress);
             expect(signedOrder.feeRecipientAddress).to.be.equal(logArgs.feeRecipientAddress);
             expect(signedOrder.makerTokenAddress).to.be.equal(logArgs.makerTokenAddress);
             expect(signedOrder.takerTokenAddress).to.be.equal(logArgs.takerTokenAddress);
-            expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerTokenFilledAmount);
-            expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerTokenFilledAmount);
-            expect(expectedFeeMPaid).to.be.bignumber.equal(logArgs.makerFeeAmountPaid);
-            expect(expectedFeeTPaid).to.be.bignumber.equal(logArgs.takerFeeAmountPaid);
+            expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerAmountSold);
+            expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.makerAmountBought);
+            expect(expectedFeeMPaid).to.be.bignumber.equal(logArgs.makerFeePaid);
+            expect(expectedFeeTPaid).to.be.bignumber.equal(logArgs.takerFeePaid);
             expect(orderUtils.getOrderHashHex(signedOrder)).to.be.equal(logArgs.orderHash);
         });
 
@@ -461,43 +453,41 @@ describe('Exchange', () => {
             });
             const divisor = 2;
             const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount: signedOrder.takerTokenAmount.div(divisor),
+                takerSellAmount: signedOrder.makerBuyAmount.div(divisor),
             });
             expect(res.logs).to.have.length(1);
 
-            const log = logDecoder.decodeLogOrThrow(res.logs[0]) as LogWithDecodedArgs<LogFillContractEventArgs>;
+            const log = res.logs[0] as LogWithDecodedArgs<LogFillContractEventArgs>;
             const logArgs = log.args;
-            const expectedFilledMakerTokenAmount = signedOrder.makerTokenAmount.div(divisor);
-            const expectedFilledTakerTokenAmount = signedOrder.takerTokenAmount.div(divisor);
+            const expectedFilledMakerTokenAmount = signedOrder.makerSellAmount.div(divisor);
+            const expectedFilledTakerTokenAmount = signedOrder.makerBuyAmount.div(divisor);
             const expectedFeeMPaid = new BigNumber(0);
             const expectedFeeTPaid = new BigNumber(0);
-            const tokensHashBuff = crypto.solSHA3([signedOrder.makerTokenAddress, signedOrder.takerTokenAddress]);
-            const expectedTokens = ethUtil.bufferToHex(tokensHashBuff);
 
             expect(signedOrder.makerAddress).to.be.equal(logArgs.makerAddress);
             expect(takerAddress).to.be.equal(logArgs.takerAddress);
             expect(signedOrder.feeRecipientAddress).to.be.equal(logArgs.feeRecipientAddress);
             expect(signedOrder.makerTokenAddress).to.be.equal(logArgs.makerTokenAddress);
             expect(signedOrder.takerTokenAddress).to.be.equal(logArgs.takerTokenAddress);
-            expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerTokenFilledAmount);
-            expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerTokenFilledAmount);
-            expect(expectedFeeMPaid).to.be.bignumber.equal(logArgs.makerFeeAmountPaid);
-            expect(expectedFeeTPaid).to.be.bignumber.equal(logArgs.takerFeeAmountPaid);
+            expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerAmountSold);
+            expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.makerAmountBought);
+            expect(expectedFeeMPaid).to.be.bignumber.equal(logArgs.makerFeePaid);
+            expect(expectedFeeTPaid).to.be.bignumber.equal(logArgs.takerFeePaid);
             expect(orderUtils.getOrderHashHex(signedOrder)).to.be.equal(logArgs.orderHash);
         });
 
         it('should throw when taker is specified and order is claimed by other', async () => {
             signedOrder = orderFactory.newSignedOrder({
                 takerAddress: feeRecipientAddress,
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+                makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             });
             return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
         });
 
         it('should throw if signature is invalid', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(10), 18),
+                makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(10), 18),
             });
 
             const invalidR = ethUtil.sha3('invalidR');
@@ -509,35 +499,9 @@ describe('Exchange', () => {
             return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
         });
 
-        it('should throw if makerTokenAmount is 0', async () => {
-            signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(0),
-            });
-
-            return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
-        });
-
-        it('should throw if takerTokenAmount is 0', async () => {
-            signedOrder = orderFactory.newSignedOrder({
-                takerTokenAmount: new BigNumber(0),
-            });
-
-            return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
-        });
-
-        it('should throw if takerTokenFillAmount is 0', async () => {
-            signedOrder = orderFactory.newSignedOrder();
-
-            return expect(
-                exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                    takerTokenFillAmount: new BigNumber(0),
-                }),
-            ).to.be.rejectedWith(constants.REVERT);
-        });
-
         it('should throw if maker balances are too low to fill order', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18),
+                makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18),
             });
 
             return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
@@ -545,7 +509,7 @@ describe('Exchange', () => {
 
         it('should throw if taker balances are too low to fill order', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18),
+                makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18),
             });
 
             return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
@@ -588,7 +552,7 @@ describe('Exchange', () => {
 
             const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress);
             expect(res.logs).to.have.length(1);
-            const log = logDecoder.decodeLogOrThrow(res.logs[0]) as LogWithDecodedArgs<LogErrorContractEventArgs>;
+            const log = res.logs[0] as LogWithDecodedArgs<LogErrorContractEventArgs>;
             const errCode = log.args.errorId;
             expect(errCode).to.be.equal(ExchangeContractErrs.ERROR_ORDER_EXPIRED);
         });
@@ -599,7 +563,7 @@ describe('Exchange', () => {
 
             const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress);
             expect(res.logs).to.have.length(1);
-            const log = logDecoder.decodeLogOrThrow(res.logs[0]) as LogWithDecodedArgs<LogErrorContractEventArgs>;
+            const log = res.logs[0] as LogWithDecodedArgs<LogErrorContractEventArgs>;
             const errCode = log.args.errorId;
             expect(errCode).to.be.equal(ExchangeContractErrs.ERROR_ORDER_FULLY_FILLED);
         });
@@ -615,26 +579,10 @@ describe('Exchange', () => {
             return expect(exWrapper.cancelOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
         });
 
-        it('should throw if makerTokenAmount is 0', async () => {
-            signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(0),
-            });
-
-            return expect(exWrapper.cancelOrderAsync(signedOrder, makerAddress)).to.be.rejectedWith(constants.REVERT);
-        });
-
-        it('should throw if takerTokenAmount is 0', async () => {
-            signedOrder = orderFactory.newSignedOrder({
-                takerTokenAmount: new BigNumber(0),
-            });
-
-            return expect(exWrapper.cancelOrderAsync(signedOrder, makerAddress)).to.be.rejectedWith(constants.REVERT);
-        });
-
         it('should be able to cancel a full order', async () => {
             await exWrapper.cancelOrderAsync(signedOrder, makerAddress);
             await exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount: signedOrder.takerTokenAmount.div(2),
+                takerSellAmount: signedOrder.makerBuyAmount.div(2),
             });
 
             const newBalances = await dmyBalances.getAsync();
@@ -646,7 +594,7 @@ describe('Exchange', () => {
             const res = await exWrapper.cancelOrderAsync(signedOrder, makerAddress);
             expect(res.logs).to.have.length(1);
 
-            const log = logDecoder.decodeLogOrThrow(res.logs[0]) as LogWithDecodedArgs<LogCancelContractEventArgs>;
+            const log = res.logs[0] as LogWithDecodedArgs<LogCancelContractEventArgs>;
             const logArgs = log.args;
 
             expect(signedOrder.makerAddress).to.be.equal(logArgs.makerAddress);
@@ -661,7 +609,7 @@ describe('Exchange', () => {
 
             const res = await exWrapper.cancelOrderAsync(signedOrder, makerAddress);
             expect(res.logs).to.have.length(1);
-            const log = logDecoder.decodeLogOrThrow(res.logs[0]) as LogWithDecodedArgs<LogErrorContractEventArgs>;
+            const log = res.logs[0] as LogWithDecodedArgs<LogErrorContractEventArgs>;
             const errCode = log.args.errorId;
             expect(errCode).to.be.equal(ExchangeContractErrs.ERROR_ORDER_CANCELLED);
         });
@@ -673,7 +621,7 @@ describe('Exchange', () => {
 
             const res = await exWrapper.cancelOrderAsync(signedOrder, makerAddress);
             expect(res.logs).to.have.length(1);
-            const log = logDecoder.decodeLogOrThrow(res.logs[0]) as LogWithDecodedArgs<LogErrorContractEventArgs>;
+            const log = res.logs[0] as LogWithDecodedArgs<LogErrorContractEventArgs>;
             const errCode = log.args.errorId;
             expect(errCode).to.be.equal(ExchangeContractErrs.ERROR_ORDER_EXPIRED);
         });
@@ -707,33 +655,33 @@ describe('Exchange', () => {
             balances = await dmyBalances.getAsync();
             const signedOrders = await Promise.all([
                 orderFactory.newSignedOrder({
-                    makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(9), 18),
-                    takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(9), 18),
+                    makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(9), 18),
+                    makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(9), 18),
                     salt: new BigNumber(0),
                 }),
                 orderFactory.newSignedOrder({
-                    makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(79), 18),
-                    takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(79), 18),
+                    makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(79), 18),
+                    makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(79), 18),
                     salt: new BigNumber(1),
                 }),
                 orderFactory.newSignedOrder({
-                    makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(979), 18),
-                    takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(979), 18),
+                    makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(979), 18),
+                    makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(979), 18),
                     salt: new BigNumber(2),
                 }),
                 orderFactory.newSignedOrder({
-                    makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(7979), 18),
-                    takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(7979), 18),
+                    makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(7979), 18),
+                    makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(7979), 18),
                     salt: new BigNumber(3),
                 }),
             ]);
             await exWrapper.batchFillOrdersNoThrowAsync(signedOrders, takerAddress);
 
             const newBalances = await dmyBalances.getAsync();
-            const fillMakerTokenAmount = signedOrders[2].makerTokenAmount.add(signedOrders[3].makerTokenAmount);
-            const fillTakerTokenAmount = signedOrders[2].takerTokenAmount.add(signedOrders[3].takerTokenAmount);
-            const makerFeeAmount = signedOrders[2].makerFeeAmount.add(signedOrders[3].makerFeeAmount);
-            const takerFeeAmount = signedOrders[2].takerFeeAmount.add(signedOrders[3].takerFeeAmount);
+            const fillMakerTokenAmount = signedOrders[2].makerSellAmount.add(signedOrders[3].makerSellAmount);
+            const fillTakerTokenAmount = signedOrders[2].makerBuyAmount.add(signedOrders[3].makerBuyAmount);
+            const makerFee = signedOrders[2].makerFee.add(signedOrders[3].makerFee);
+            const takerFee = signedOrders[2].takerFee.add(signedOrders[3].takerFee);
             expect(newBalances[makerAddress][signedOrders[3].makerTokenAddress]).to.be.bignumber.equal(
                 balances[makerAddress][signedOrders[3].makerTokenAddress].minus(fillMakerTokenAmount),
             );
@@ -741,7 +689,7 @@ describe('Exchange', () => {
                 balances[makerAddress][signedOrders[3].takerTokenAddress].add(fillTakerTokenAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
-                balances[makerAddress][zrx.address].minus(makerFeeAmount),
+                balances[makerAddress][zrx.address].minus(makerFee),
             );
             expect(newBalances[takerAddress][signedOrders[3].takerTokenAddress]).to.be.bignumber.equal(
                 balances[takerAddress][signedOrders[3].takerTokenAddress].minus(fillTakerTokenAmount),
@@ -750,10 +698,10 @@ describe('Exchange', () => {
                 balances[takerAddress][signedOrders[3].makerTokenAddress].add(fillMakerTokenAmount),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
-                balances[takerAddress][zrx.address].minus(takerFeeAmount),
+                balances[takerAddress][zrx.address].minus(takerFee),
             );
             expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal(
-                balances[feeRecipientAddress][zrx.address].add(makerFeeAmount.add(takerFeeAmount)),
+                balances[feeRecipientAddress][zrx.address].add(makerFee.add(takerFee)),
             );
         });
     });
diff --git a/packages/contracts/test/exchange/helpers.ts b/packages/contracts/test/exchange/helpers.ts
index 2880bab22..76a64d567 100644
--- a/packages/contracts/test/exchange/helpers.ts
+++ b/packages/contracts/test/exchange/helpers.ts
@@ -52,10 +52,10 @@ describe('Exchange', () => {
             feeRecipientAddress,
             makerTokenAddress: rep.address,
             takerTokenAddress: dgd.address,
-            makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-            takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
-            makerFeeAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
-            takerFeeAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
+            makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+            makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+            makerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
+            takerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
         };
         const privateKey = constants.TESTRPC_PRIVATE_KEYS[0];
         orderFactory = new OrderFactory(privateKey, defaultOrderParams);
diff --git a/packages/contracts/test/exchange/wrapper.ts b/packages/contracts/test/exchange/wrapper.ts
index b87f45387..00e703b2f 100644
--- a/packages/contracts/test/exchange/wrapper.ts
+++ b/packages/contracts/test/exchange/wrapper.ts
@@ -85,10 +85,10 @@ describe('Exchange', () => {
             feeRecipientAddress,
             makerTokenAddress: rep.address,
             takerTokenAddress: dgd.address,
-            makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-            takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
-            makerFeeAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
-            takerFeeAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
+            makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+            makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+            makerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
+            takerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
         };
 
         const privateKey = constants.TESTRPC_PRIVATE_KEYS[0];
@@ -119,45 +119,45 @@ describe('Exchange', () => {
     describe('fillOrKillOrder', () => {
         it('should transfer the correct amounts', async () => {
             const signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+                makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             });
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
+            const takerSellAmount = signedOrder.makerBuyAmount.div(2);
             await exWrapper.fillOrKillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount,
+                takerSellAmount,
             });
 
             const newBalances = await dmyBalances.getAsync();
 
-            const makerTokenFillAmount = takerTokenFillAmount
-                .times(signedOrder.makerTokenAmount)
-                .dividedToIntegerBy(signedOrder.takerTokenAmount);
-            const makerFeeAmount = signedOrder.makerFeeAmount
-                .times(makerTokenFillAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
-            const takerFeeAmount = signedOrder.takerFeeAmount
-                .times(makerTokenFillAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+            const makerAmountSold = takerSellAmount
+                .times(signedOrder.makerSellAmount)
+                .dividedToIntegerBy(signedOrder.makerBuyAmount);
+            const makerFee = signedOrder.makerFee
+                .times(makerAmountSold)
+                .dividedToIntegerBy(signedOrder.makerSellAmount);
+            const takerFee = signedOrder.takerFee
+                .times(makerAmountSold)
+                .dividedToIntegerBy(signedOrder.makerSellAmount);
             expect(newBalances[makerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.makerTokenAddress].minus(makerTokenFillAmount),
+                balances[makerAddress][signedOrder.makerTokenAddress].minus(makerAmountSold),
             );
             expect(newBalances[makerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.takerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][signedOrder.takerTokenAddress].add(takerSellAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
-                balances[makerAddress][zrx.address].minus(makerFeeAmount),
+                balances[makerAddress][zrx.address].minus(makerFee),
             );
             expect(newBalances[takerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerSellAmount),
             );
             expect(newBalances[takerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.makerTokenAddress].add(makerTokenFillAmount),
+                balances[takerAddress][signedOrder.makerTokenAddress].add(makerAmountSold),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
-                balances[takerAddress][zrx.address].minus(takerFeeAmount),
+                balances[takerAddress][zrx.address].minus(takerFee),
             );
             expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal(
-                balances[feeRecipientAddress][zrx.address].add(makerFeeAmount.add(takerFeeAmount)),
+                balances[feeRecipientAddress][zrx.address].add(makerFee.add(takerFee)),
             );
         });
 
@@ -171,11 +171,11 @@ describe('Exchange', () => {
             );
         });
 
-        it('should throw if entire takerTokenFillAmount not filled', async () => {
+        it('should throw if entire takerSellAmount not filled', async () => {
             const signedOrder = orderFactory.newSignedOrder();
 
             await exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount: signedOrder.takerTokenAmount.div(2),
+                takerSellAmount: signedOrder.makerBuyAmount.div(2),
             });
 
             return expect(exWrapper.fillOrKillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(
@@ -187,51 +187,51 @@ describe('Exchange', () => {
     describe('fillOrderNoThrow', () => {
         it('should transfer the correct amounts', async () => {
             const signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+                makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             });
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
+            const takerSellAmount = signedOrder.makerBuyAmount.div(2);
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount,
+                takerSellAmount,
             });
 
             const newBalances = await dmyBalances.getAsync();
 
-            const makerTokenFillAmount = takerTokenFillAmount
-                .times(signedOrder.makerTokenAmount)
-                .dividedToIntegerBy(signedOrder.takerTokenAmount);
-            const makerFeeAmount = signedOrder.makerFeeAmount
-                .times(makerTokenFillAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
-            const takerFeeAmount = signedOrder.takerFeeAmount
-                .times(makerTokenFillAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+            const makerAmountSold = takerSellAmount
+                .times(signedOrder.makerSellAmount)
+                .dividedToIntegerBy(signedOrder.makerBuyAmount);
+            const makerFee = signedOrder.makerFee
+                .times(makerAmountSold)
+                .dividedToIntegerBy(signedOrder.makerSellAmount);
+            const takerFee = signedOrder.takerFee
+                .times(makerAmountSold)
+                .dividedToIntegerBy(signedOrder.makerSellAmount);
             expect(newBalances[makerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.makerTokenAddress].minus(makerTokenFillAmount),
+                balances[makerAddress][signedOrder.makerTokenAddress].minus(makerAmountSold),
             );
             expect(newBalances[makerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][signedOrder.takerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][signedOrder.takerTokenAddress].add(takerSellAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
-                balances[makerAddress][zrx.address].minus(makerFeeAmount),
+                balances[makerAddress][zrx.address].minus(makerFee),
             );
             expect(newBalances[takerAddress][signedOrder.takerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][signedOrder.takerTokenAddress].minus(takerSellAmount),
             );
             expect(newBalances[takerAddress][signedOrder.makerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][signedOrder.makerTokenAddress].add(makerTokenFillAmount),
+                balances[takerAddress][signedOrder.makerTokenAddress].add(makerAmountSold),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
-                balances[takerAddress][zrx.address].minus(takerFeeAmount),
+                balances[takerAddress][zrx.address].minus(takerFee),
             );
             expect(newBalances[feeRecipientAddress][zrx.address]).to.be.bignumber.equal(
-                balances[feeRecipientAddress][zrx.address].add(makerFeeAmount.add(takerFeeAmount)),
+                balances[feeRecipientAddress][zrx.address].add(makerFee.add(takerFee)),
             );
         });
 
         it('should not change balances if maker balances are too low to fill order', async () => {
             const signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18),
+                makerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18),
             });
 
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
@@ -241,7 +241,7 @@ describe('Exchange', () => {
 
         it('should not change balances if taker balances are too low to fill order', async () => {
             const signedOrder = orderFactory.newSignedOrder({
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18),
+                makerBuyAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18),
             });
 
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
@@ -277,48 +277,48 @@ describe('Exchange', () => {
             expect(newBalances).to.be.deep.equal(balances);
         });
 
-        it('should not change balances if makerTokenAddress is ZRX, makerTokenAmount + makerFee > maker balance', async () => {
+        it('should not change balances if makerTokenAddress is ZRX, makerSellAmount + makerFee > maker balance', async () => {
             const makerZRXBalance = new BigNumber(balances[makerAddress][zrx.address]);
             const signedOrder = orderFactory.newSignedOrder({
                 makerTokenAddress: zrx.address,
-                makerTokenAmount: makerZRXBalance,
-                makerFeeAmount: new BigNumber(1),
+                makerSellAmount: makerZRXBalance,
+                makerFee: new BigNumber(1),
             });
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
             const newBalances = await dmyBalances.getAsync();
             expect(newBalances).to.be.deep.equal(balances);
         });
 
-        it('should not change balances if makerTokenAddress is ZRX, makerTokenAmount + makerFee > maker allowance', async () => {
+        it('should not change balances if makerTokenAddress is ZRX, makerSellAmount + makerFee > maker allowance', async () => {
             const makerZRXAllowance = await zrx.allowance.callAsync(makerAddress, tokenTransferProxy.address);
             const signedOrder = orderFactory.newSignedOrder({
                 makerTokenAddress: zrx.address,
-                makerTokenAmount: new BigNumber(makerZRXAllowance),
-                makerFeeAmount: new BigNumber(1),
+                makerSellAmount: new BigNumber(makerZRXAllowance),
+                makerFee: new BigNumber(1),
             });
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
             const newBalances = await dmyBalances.getAsync();
             expect(newBalances).to.be.deep.equal(balances);
         });
 
-        it('should not change balances if takerTokenAddress is ZRX, takerTokenAmount + takerFee > taker balance', async () => {
+        it('should not change balances if takerTokenAddress is ZRX, makerBuyAmount + takerFee > taker balance', async () => {
             const takerZRXBalance = new BigNumber(balances[takerAddress][zrx.address]);
             const signedOrder = orderFactory.newSignedOrder({
                 takerTokenAddress: zrx.address,
-                takerTokenAmount: takerZRXBalance,
-                takerFeeAmount: new BigNumber(1),
+                makerBuyAmount: takerZRXBalance,
+                takerFee: new BigNumber(1),
             });
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
             const newBalances = await dmyBalances.getAsync();
             expect(newBalances).to.be.deep.equal(balances);
         });
 
-        it('should not change balances if takerTokenAddress is ZRX, takerTokenAmount + takerFee > taker allowance', async () => {
+        it('should not change balances if takerTokenAddress is ZRX, makerBuyAmount + takerFee > taker allowance', async () => {
             const takerZRXAllowance = await zrx.allowance.callAsync(takerAddress, tokenTransferProxy.address);
             const signedOrder = orderFactory.newSignedOrder({
                 takerTokenAddress: zrx.address,
-                takerTokenAmount: new BigNumber(takerZRXAllowance),
-                takerFeeAmount: new BigNumber(1),
+                makerBuyAmount: new BigNumber(takerZRXAllowance),
+                takerFee: new BigNumber(1),
             });
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
             const newBalances = await dmyBalances.getAsync();
@@ -338,42 +338,42 @@ describe('Exchange', () => {
 
         describe('batchFillOrders', () => {
             it('should transfer the correct amounts', async () => {
-                const takerTokenFillAmounts: BigNumber[] = [];
+                const takerSellAmounts: BigNumber[] = [];
                 const makerTokenAddress = rep.address;
                 const takerTokenAddress = dgd.address;
                 _.forEach(signedOrders, signedOrder => {
-                    const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-                    const makerTokenFillAmount = takerTokenFillAmount
-                        .times(signedOrder.makerTokenAmount)
-                        .dividedToIntegerBy(signedOrder.takerTokenAmount);
-                    const makerFeeAmount = signedOrder.makerFeeAmount
-                        .times(makerTokenFillAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
-                    const takerFeeAmount = signedOrder.takerFeeAmount
-                        .times(makerTokenFillAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
-                    takerTokenFillAmounts.push(takerTokenFillAmount);
+                    const takerSellAmount = signedOrder.makerBuyAmount.div(2);
+                    const makerAmountSold = takerSellAmount
+                        .times(signedOrder.makerSellAmount)
+                        .dividedToIntegerBy(signedOrder.makerBuyAmount);
+                    const makerFee = signedOrder.makerFee
+                        .times(makerAmountSold)
+                        .dividedToIntegerBy(signedOrder.makerSellAmount);
+                    const takerFee = signedOrder.takerFee
+                        .times(makerAmountSold)
+                        .dividedToIntegerBy(signedOrder.makerSellAmount);
+                    takerSellAmounts.push(takerSellAmount);
                     balances[makerAddress][makerTokenAddress] = balances[makerAddress][makerTokenAddress].minus(
-                        makerTokenFillAmount,
+                        makerAmountSold,
                     );
                     balances[makerAddress][takerTokenAddress] = balances[makerAddress][takerTokenAddress].add(
-                        takerTokenFillAmount,
+                        takerSellAmount,
                     );
-                    balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFeeAmount);
+                    balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFee);
                     balances[takerAddress][makerTokenAddress] = balances[takerAddress][makerTokenAddress].add(
-                        makerTokenFillAmount,
+                        makerAmountSold,
                     );
                     balances[takerAddress][takerTokenAddress] = balances[takerAddress][takerTokenAddress].minus(
-                        takerTokenFillAmount,
+                        takerSellAmount,
                     );
-                    balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFeeAmount);
+                    balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFee);
                     balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add(
-                        makerFeeAmount.add(takerFeeAmount),
+                        makerFee.add(takerFee),
                     );
                 });
 
                 await exWrapper.batchFillOrdersAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmounts,
+                    takerSellAmounts,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
@@ -383,33 +383,33 @@ describe('Exchange', () => {
 
         describe('batchFillOrKillOrders', () => {
             it('should transfer the correct amounts', async () => {
-                const takerTokenFillAmounts: BigNumber[] = [];
+                const takerSellAmounts: BigNumber[] = [];
                 const makerTokenAddress = rep.address;
                 const takerTokenAddress = dgd.address;
                 _.forEach(signedOrders, signedOrder => {
-                    const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-                    const makerTokenFillAmount = takerTokenFillAmount
-                        .times(signedOrder.makerTokenAmount)
-                        .dividedToIntegerBy(signedOrder.takerTokenAmount);
-                    const makerFee = signedOrder.makerFeeAmount
-                        .times(makerTokenFillAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
-                    const takerFee = signedOrder.takerFeeAmount
-                        .times(makerTokenFillAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
-                    takerTokenFillAmounts.push(takerTokenFillAmount);
+                    const takerSellAmount = signedOrder.makerBuyAmount.div(2);
+                    const makerAmountSold = takerSellAmount
+                        .times(signedOrder.makerSellAmount)
+                        .dividedToIntegerBy(signedOrder.makerBuyAmount);
+                    const makerFee = signedOrder.makerFee
+                        .times(makerAmountSold)
+                        .dividedToIntegerBy(signedOrder.makerSellAmount);
+                    const takerFee = signedOrder.takerFee
+                        .times(makerAmountSold)
+                        .dividedToIntegerBy(signedOrder.makerSellAmount);
+                    takerSellAmounts.push(takerSellAmount);
                     balances[makerAddress][makerTokenAddress] = balances[makerAddress][makerTokenAddress].minus(
-                        makerTokenFillAmount,
+                        makerAmountSold,
                     );
                     balances[makerAddress][takerTokenAddress] = balances[makerAddress][takerTokenAddress].add(
-                        takerTokenFillAmount,
+                        takerSellAmount,
                     );
                     balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFee);
                     balances[takerAddress][makerTokenAddress] = balances[takerAddress][makerTokenAddress].add(
-                        makerTokenFillAmount,
+                        makerAmountSold,
                     );
                     balances[takerAddress][takerTokenAddress] = balances[takerAddress][takerTokenAddress].minus(
-                        takerTokenFillAmount,
+                        takerSellAmount,
                     );
                     balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFee);
                     balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add(
@@ -418,7 +418,7 @@ describe('Exchange', () => {
                 });
 
                 await exWrapper.batchFillOrKillOrdersAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmounts,
+                    takerSellAmounts,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
@@ -426,17 +426,17 @@ describe('Exchange', () => {
             });
 
             it('should throw if a single signedOrder does not fill the expected amount', async () => {
-                const takerTokenFillAmounts: BigNumber[] = [];
+                const takerSellAmounts: BigNumber[] = [];
                 _.forEach(signedOrders, signedOrder => {
-                    const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-                    takerTokenFillAmounts.push(takerTokenFillAmount);
+                    const takerSellAmount = signedOrder.makerBuyAmount.div(2);
+                    takerSellAmounts.push(takerSellAmount);
                 });
 
                 await exWrapper.fillOrKillOrderAsync(signedOrders[0], takerAddress);
 
                 return expect(
                     exWrapper.batchFillOrKillOrdersAsync(signedOrders, takerAddress, {
-                        takerTokenFillAmounts,
+                        takerSellAmounts,
                     }),
                 ).to.be.rejectedWith(constants.REVERT);
             });
@@ -444,42 +444,42 @@ describe('Exchange', () => {
 
         describe('batchFillOrdersNoThrow', async () => {
             it('should transfer the correct amounts', async () => {
-                const takerTokenFillAmounts: BigNumber[] = [];
+                const takerSellAmounts: BigNumber[] = [];
                 const makerTokenAddress = rep.address;
                 const takerTokenAddress = dgd.address;
                 _.forEach(signedOrders, signedOrder => {
-                    const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-                    const makerTokenFillAmount = takerTokenFillAmount
-                        .times(signedOrder.makerTokenAmount)
-                        .dividedToIntegerBy(signedOrder.takerTokenAmount);
-                    const makerFeeAmount = signedOrder.makerFeeAmount
-                        .times(makerTokenFillAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
-                    const takerFeeAmount = signedOrder.takerFeeAmount
-                        .times(makerTokenFillAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
-                    takerTokenFillAmounts.push(takerTokenFillAmount);
+                    const takerSellAmount = signedOrder.makerBuyAmount.div(2);
+                    const makerAmountSold = takerSellAmount
+                        .times(signedOrder.makerSellAmount)
+                        .dividedToIntegerBy(signedOrder.makerBuyAmount);
+                    const makerFee = signedOrder.makerFee
+                        .times(makerAmountSold)
+                        .dividedToIntegerBy(signedOrder.makerSellAmount);
+                    const takerFee = signedOrder.takerFee
+                        .times(makerAmountSold)
+                        .dividedToIntegerBy(signedOrder.makerSellAmount);
+                    takerSellAmounts.push(takerSellAmount);
                     balances[makerAddress][makerTokenAddress] = balances[makerAddress][makerTokenAddress].minus(
-                        makerTokenFillAmount,
+                        makerAmountSold,
                     );
                     balances[makerAddress][takerTokenAddress] = balances[makerAddress][takerTokenAddress].add(
-                        takerTokenFillAmount,
+                        takerSellAmount,
                     );
-                    balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFeeAmount);
+                    balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFee);
                     balances[takerAddress][makerTokenAddress] = balances[takerAddress][makerTokenAddress].add(
-                        makerTokenFillAmount,
+                        makerAmountSold,
                     );
                     balances[takerAddress][takerTokenAddress] = balances[takerAddress][takerTokenAddress].minus(
-                        takerTokenFillAmount,
+                        takerSellAmount,
                     );
-                    balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFeeAmount);
+                    balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFee);
                     balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add(
-                        makerFeeAmount.add(takerFeeAmount),
+                        makerFee.add(takerFee),
                     );
                 });
 
                 await exWrapper.batchFillOrdersNoThrowAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmounts,
+                    takerSellAmounts,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
@@ -487,7 +487,7 @@ describe('Exchange', () => {
             });
 
             it('should not throw if an order is invalid and fill the remaining orders', async () => {
-                const takerTokenFillAmounts: BigNumber[] = [];
+                const takerSellAmounts: BigNumber[] = [];
                 const makerTokenAddress = rep.address;
                 const takerTokenAddress = dgd.address;
 
@@ -497,41 +497,41 @@ describe('Exchange', () => {
                 };
                 const validOrders = signedOrders.slice(1);
 
-                takerTokenFillAmounts.push(invalidOrder.takerTokenAmount.div(2));
+                takerSellAmounts.push(invalidOrder.makerBuyAmount.div(2));
                 _.forEach(validOrders, signedOrder => {
-                    const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-                    const makerTokenFillAmount = takerTokenFillAmount
-                        .times(signedOrder.makerTokenAmount)
-                        .dividedToIntegerBy(signedOrder.takerTokenAmount);
-                    const makerFeeAmount = signedOrder.makerFeeAmount
-                        .times(makerTokenFillAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
-                    const takerFeeAmount = signedOrder.takerFeeAmount
-                        .times(makerTokenFillAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
-                    takerTokenFillAmounts.push(takerTokenFillAmount);
+                    const takerSellAmount = signedOrder.makerBuyAmount.div(2);
+                    const makerAmountSold = takerSellAmount
+                        .times(signedOrder.makerSellAmount)
+                        .dividedToIntegerBy(signedOrder.makerBuyAmount);
+                    const makerFee = signedOrder.makerFee
+                        .times(makerAmountSold)
+                        .dividedToIntegerBy(signedOrder.makerSellAmount);
+                    const takerFee = signedOrder.takerFee
+                        .times(makerAmountSold)
+                        .dividedToIntegerBy(signedOrder.makerSellAmount);
+                    takerSellAmounts.push(takerSellAmount);
                     balances[makerAddress][makerTokenAddress] = balances[makerAddress][makerTokenAddress].minus(
-                        makerTokenFillAmount,
+                        makerAmountSold,
                     );
                     balances[makerAddress][takerTokenAddress] = balances[makerAddress][takerTokenAddress].add(
-                        takerTokenFillAmount,
+                        takerSellAmount,
                     );
-                    balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFeeAmount);
+                    balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFee);
                     balances[takerAddress][makerTokenAddress] = balances[takerAddress][makerTokenAddress].add(
-                        makerTokenFillAmount,
+                        makerAmountSold,
                     );
                     balances[takerAddress][takerTokenAddress] = balances[takerAddress][takerTokenAddress].minus(
-                        takerTokenFillAmount,
+                        takerSellAmount,
                     );
-                    balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFeeAmount);
+                    balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFee);
                     balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add(
-                        makerFeeAmount.add(takerFeeAmount),
+                        makerFee.add(takerFee),
                     );
                 });
 
                 const newOrders = [invalidOrder, ...validOrders];
                 await exWrapper.batchFillOrdersNoThrowAsync(newOrders, takerAddress, {
-                    takerTokenFillAmounts,
+                    takerSellAmounts,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
@@ -540,39 +540,33 @@ describe('Exchange', () => {
         });
 
         describe('marketFillOrders', () => {
-            it('should stop when the entire takerTokenFillAmount is filled', async () => {
-                const takerTokenFillAmount = signedOrders[0].takerTokenAmount.plus(
-                    signedOrders[1].takerTokenAmount.div(2),
-                );
-                await exWrapper.marketFillOrdersAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmount,
+            it('should stop when the entire takerSellAmount is filled', async () => {
+                const takerSellAmount = signedOrders[0].makerBuyAmount.plus(signedOrders[1].makerBuyAmount.div(2));
+                await exWrapper.marketSellOrdersAsync(signedOrders, takerAddress, {
+                    takerSellAmount,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
 
-                const makerTokenFillAmount = signedOrders[0].makerTokenAmount.add(
-                    signedOrders[1].makerTokenAmount.dividedToIntegerBy(2),
-                );
-                const makerFee = signedOrders[0].makerFeeAmount.add(
-                    signedOrders[1].makerFeeAmount.dividedToIntegerBy(2),
-                );
-                const takerFee = signedOrders[0].takerFeeAmount.add(
-                    signedOrders[1].takerFeeAmount.dividedToIntegerBy(2),
+                const makerAmountSold = signedOrders[0].makerSellAmount.add(
+                    signedOrders[1].makerSellAmount.dividedToIntegerBy(2),
                 );
+                const makerFee = signedOrders[0].makerFee.add(signedOrders[1].makerFee.dividedToIntegerBy(2));
+                const takerFee = signedOrders[0].takerFee.add(signedOrders[1].takerFee.dividedToIntegerBy(2));
                 expect(newBalances[makerAddress][signedOrders[0].makerTokenAddress]).to.be.bignumber.equal(
-                    balances[makerAddress][signedOrders[0].makerTokenAddress].minus(makerTokenFillAmount),
+                    balances[makerAddress][signedOrders[0].makerTokenAddress].minus(makerAmountSold),
                 );
                 expect(newBalances[makerAddress][signedOrders[0].takerTokenAddress]).to.be.bignumber.equal(
-                    balances[makerAddress][signedOrders[0].takerTokenAddress].add(takerTokenFillAmount),
+                    balances[makerAddress][signedOrders[0].takerTokenAddress].add(takerSellAmount),
                 );
                 expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                     balances[makerAddress][zrx.address].minus(makerFee),
                 );
                 expect(newBalances[takerAddress][signedOrders[0].takerTokenAddress]).to.be.bignumber.equal(
-                    balances[takerAddress][signedOrders[0].takerTokenAddress].minus(takerTokenFillAmount),
+                    balances[takerAddress][signedOrders[0].takerTokenAddress].minus(takerSellAmount),
                 );
                 expect(newBalances[takerAddress][signedOrders[0].makerTokenAddress]).to.be.bignumber.equal(
-                    balances[takerAddress][signedOrders[0].makerTokenAddress].add(makerTokenFillAmount),
+                    balances[takerAddress][signedOrders[0].makerTokenAddress].add(makerAmountSold),
                 );
                 expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                     balances[takerAddress][zrx.address].minus(takerFee),
@@ -582,33 +576,33 @@ describe('Exchange', () => {
                 );
             });
 
-            it('should fill all signedOrders if cannot fill entire takerTokenFillAmount', async () => {
-                const takerTokenFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18);
+            it('should fill all signedOrders if cannot fill entire takerSellAmount', async () => {
+                const takerSellAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18);
                 _.forEach(signedOrders, signedOrder => {
                     balances[makerAddress][signedOrder.makerTokenAddress] = balances[makerAddress][
                         signedOrder.makerTokenAddress
-                    ].minus(signedOrder.makerTokenAmount);
+                    ].minus(signedOrder.makerSellAmount);
                     balances[makerAddress][signedOrder.takerTokenAddress] = balances[makerAddress][
                         signedOrder.takerTokenAddress
-                    ].add(signedOrder.takerTokenAmount);
+                    ].add(signedOrder.makerBuyAmount);
                     balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(
-                        signedOrder.makerFeeAmount,
+                        signedOrder.makerFee,
                     );
                     balances[takerAddress][signedOrder.makerTokenAddress] = balances[takerAddress][
                         signedOrder.makerTokenAddress
-                    ].add(signedOrder.makerTokenAmount);
+                    ].add(signedOrder.makerSellAmount);
                     balances[takerAddress][signedOrder.takerTokenAddress] = balances[takerAddress][
                         signedOrder.takerTokenAddress
-                    ].minus(signedOrder.takerTokenAmount);
+                    ].minus(signedOrder.makerBuyAmount);
                     balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(
-                        signedOrder.takerFeeAmount,
+                        signedOrder.takerFee,
                     );
                     balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add(
-                        signedOrder.makerFeeAmount.add(signedOrder.takerFeeAmount),
+                        signedOrder.makerFee.add(signedOrder.takerFee),
                     );
                 });
-                await exWrapper.marketFillOrdersAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmount,
+                await exWrapper.marketSellOrdersAsync(signedOrders, takerAddress, {
+                    takerSellAmount,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
@@ -623,47 +617,41 @@ describe('Exchange', () => {
                 ];
 
                 return expect(
-                    exWrapper.marketFillOrdersAsync(signedOrders, takerAddress, {
-                        takerTokenFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18),
+                    exWrapper.marketSellOrdersAsync(signedOrders, takerAddress, {
+                        takerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18),
                     }),
                 ).to.be.rejectedWith(constants.REVERT);
             });
         });
 
         describe('marketFillOrdersNoThrow', () => {
-            it('should stop when the entire takerTokenFillAmount is filled', async () => {
-                const takerTokenFillAmount = signedOrders[0].takerTokenAmount.plus(
-                    signedOrders[1].takerTokenAmount.div(2),
-                );
-                await exWrapper.marketFillOrdersNoThrowAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmount,
+            it('should stop when the entire takerSellAmount is filled', async () => {
+                const takerSellAmount = signedOrders[0].makerBuyAmount.plus(signedOrders[1].makerBuyAmount.div(2));
+                await exWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, {
+                    takerSellAmount,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
 
-                const makerTokenFillAmount = signedOrders[0].makerTokenAmount.add(
-                    signedOrders[1].makerTokenAmount.dividedToIntegerBy(2),
-                );
-                const makerFee = signedOrders[0].makerFeeAmount.add(
-                    signedOrders[1].makerFeeAmount.dividedToIntegerBy(2),
-                );
-                const takerFee = signedOrders[0].takerFeeAmount.add(
-                    signedOrders[1].takerFeeAmount.dividedToIntegerBy(2),
+                const makerAmountSold = signedOrders[0].makerSellAmount.add(
+                    signedOrders[1].makerSellAmount.dividedToIntegerBy(2),
                 );
+                const makerFee = signedOrders[0].makerFee.add(signedOrders[1].makerFee.dividedToIntegerBy(2));
+                const takerFee = signedOrders[0].takerFee.add(signedOrders[1].takerFee.dividedToIntegerBy(2));
                 expect(newBalances[makerAddress][signedOrders[0].makerTokenAddress]).to.be.bignumber.equal(
-                    balances[makerAddress][signedOrders[0].makerTokenAddress].minus(makerTokenFillAmount),
+                    balances[makerAddress][signedOrders[0].makerTokenAddress].minus(makerAmountSold),
                 );
                 expect(newBalances[makerAddress][signedOrders[0].takerTokenAddress]).to.be.bignumber.equal(
-                    balances[makerAddress][signedOrders[0].takerTokenAddress].add(takerTokenFillAmount),
+                    balances[makerAddress][signedOrders[0].takerTokenAddress].add(takerSellAmount),
                 );
                 expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                     balances[makerAddress][zrx.address].minus(makerFee),
                 );
                 expect(newBalances[takerAddress][signedOrders[0].takerTokenAddress]).to.be.bignumber.equal(
-                    balances[takerAddress][signedOrders[0].takerTokenAddress].minus(takerTokenFillAmount),
+                    balances[takerAddress][signedOrders[0].takerTokenAddress].minus(takerSellAmount),
                 );
                 expect(newBalances[takerAddress][signedOrders[0].makerTokenAddress]).to.be.bignumber.equal(
-                    balances[takerAddress][signedOrders[0].makerTokenAddress].add(makerTokenFillAmount),
+                    balances[takerAddress][signedOrders[0].makerTokenAddress].add(makerAmountSold),
                 );
                 expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                     balances[takerAddress][zrx.address].minus(takerFee),
@@ -673,33 +661,33 @@ describe('Exchange', () => {
                 );
             });
 
-            it('should fill all signedOrders if cannot fill entire takerTokenFillAmount', async () => {
-                const takerTokenFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18);
+            it('should fill all signedOrders if cannot fill entire takerSellAmount', async () => {
+                const takerSellAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18);
                 _.forEach(signedOrders, signedOrder => {
                     balances[makerAddress][signedOrder.makerTokenAddress] = balances[makerAddress][
                         signedOrder.makerTokenAddress
-                    ].minus(signedOrder.makerTokenAmount);
+                    ].minus(signedOrder.makerSellAmount);
                     balances[makerAddress][signedOrder.takerTokenAddress] = balances[makerAddress][
                         signedOrder.takerTokenAddress
-                    ].add(signedOrder.takerTokenAmount);
+                    ].add(signedOrder.makerBuyAmount);
                     balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(
-                        signedOrder.makerFeeAmount,
+                        signedOrder.makerFee,
                     );
                     balances[takerAddress][signedOrder.makerTokenAddress] = balances[takerAddress][
                         signedOrder.makerTokenAddress
-                    ].add(signedOrder.makerTokenAmount);
+                    ].add(signedOrder.makerSellAmount);
                     balances[takerAddress][signedOrder.takerTokenAddress] = balances[takerAddress][
                         signedOrder.takerTokenAddress
-                    ].minus(signedOrder.takerTokenAmount);
+                    ].minus(signedOrder.makerBuyAmount);
                     balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(
-                        signedOrder.takerFeeAmount,
+                        signedOrder.takerFee,
                     );
                     balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add(
-                        signedOrder.makerFeeAmount.add(signedOrder.takerFeeAmount),
+                        signedOrder.makerFee.add(signedOrder.takerFee),
                     );
                 });
-                await exWrapper.marketFillOrdersNoThrowAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmount,
+                await exWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, {
+                    takerSellAmount,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
@@ -714,8 +702,8 @@ describe('Exchange', () => {
                 ];
 
                 return expect(
-                    exWrapper.marketFillOrdersNoThrowAsync(signedOrders, takerAddress, {
-                        takerTokenFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18),
+                    exWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, {
+                        takerSellAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18),
                     }),
                 ).to.be.rejectedWith(constants.REVERT);
             });
@@ -723,11 +711,11 @@ describe('Exchange', () => {
 
         describe('batchCancelOrders', () => {
             it('should be able to cancel multiple signedOrders', async () => {
-                const takerTokenCancelAmounts = _.map(signedOrders, signedOrder => signedOrder.takerTokenAmount);
+                const takerTokenCancelAmounts = _.map(signedOrders, signedOrder => signedOrder.makerBuyAmount);
                 await exWrapper.batchCancelOrdersAsync(signedOrders, makerAddress);
 
                 await exWrapper.batchFillOrdersAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmounts: takerTokenCancelAmounts,
+                    takerSellAmounts: takerTokenCancelAmounts,
                 });
                 const newBalances = await dmyBalances.getAsync();
                 expect(balances).to.be.deep.equal(newBalances);