Rename token => asset

15 files changed, 656 insertions, 656 deletions

diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/IExchange.sol b/packages/contracts/src/contracts/current/protocol/Exchange/IExchange.sol
index 3af51e915..0550d6c4b 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/IExchange.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/IExchange.sol
@@ -37,8 +37,8 @@ contract IExchange {
         address indexed feeRecipient,
         bytes makerAssetData,
         bytes takerAssetData,
-        uint256 makerTokenFilledAmount,
-        uint256 takerTokenFilledAmount,
+        uint256 makerAssetFilledAmount,
+        uint256 takerAssetFilledAmount,
         uint256 makerFeePaid,
         uint256 takerFeePaid,
         bytes32 indexed orderHash
@@ -49,8 +49,8 @@ contract IExchange {
         address indexed feeRecipient,
         bytes makerAssetData,
         bytes takerAssetData,
-        uint256 makerTokenCancelledAmount,
-        uint256 takerTokenCancelledAmount,
+        uint256 makerAssetCancelledAmount,
+        uint256 takerAssetCancelledAmount,
         bytes32 indexed orderHash
     );
 
@@ -100,8 +100,8 @@ contract IExchange {
         returns (bool isError);
 
     /// @dev Calculates Keccak-256 hash of order with specified parameters.
-    /// @param orderAddresses Array of order's maker, taker, makerToken, takerToken, and feeRecipient.
-    /// @param orderValues Array of order's makerTokenAmount, takerTokenAmount, makerFee, takerFee, expirationTimestampInSec, and salt.
+    /// @param orderAddresses Array of order's maker, taker, makerAsset, takerAsset, and feeRecipient.
+    /// @param orderValues Array of order's makerAssetAmount, takerAssetAmount, makerFee, takerFee, expirationTimestampInSec, and salt.
     /// @return Keccak-256 hash of order.
     function getOrderHash(address[5] orderAddresses, uint256[6] orderValues)
         public view
@@ -124,34 +124,34 @@ contract IExchange {
         returns (bool isValid);
 
     /// @dev Fills the input order.
-    /// @param orderAddresses Array of order's maker, taker, makerToken, takerToken, and feeRecipient.
-    /// @param orderValues Array of order's makerTokenAmount, takerTokenAmount, makerFee, takerFee, expirationTimestampInSec, and salt.
-    /// @param takerTokenFillAmount Desired amount of takerToken to fill.
+    /// @param orderAddresses Array of order's maker, taker, makerAsset, takerAsset, and feeRecipient.
+    /// @param orderValues Array of order's makerAssetAmount, takerAssetAmount, makerFee, takerFee, expirationTimestampInSec, and salt.
+    /// @param takerAssetFillAmount Desired amount of takerAsset to fill.
     /// @param v ECDSA signature parameter v.
     /// @param r ECDSA signature parameters r.
     /// @param s ECDSA signature parameters s.
-    /// @return Total amount of takerToken filled in trade.
+    /// @return Total amount of takerAsset filled in trade.
     function fillOrder(
           address[5] orderAddresses,
           uint256[6] orderValues,
-          uint256 takerTokenFillAmount,
+          uint256 takerAssetFillAmount,
           uint8 v,
           bytes32 r,
           bytes32 s)
           public
-          returns (uint256 takerTokenFilledAmount);
+          returns (uint256 takerAssetFilledAmount);
 
     /// @dev Cancels the input order.
-    /// @param orderAddresses Array of order's maker, taker, makerToken, takerToken, and feeRecipient.
-    /// @param orderValues Array of order's makerTokenAmount, takerTokenAmount, makerFee, takerFee, expirationTimestampInSec, and salt.
-    /// @param takerTokenCancelAmount Desired amount of takerToken to cancel in order.
-    /// @return Amount of takerToken cancelled.
+    /// @param orderAddresses Array of order's maker, taker, makerAsset, takerAsset, and feeRecipient.
+    /// @param orderValues Array of order's makerAssetAmount, takerAssetAmount, makerFee, takerFee, expirationTimestampInSec, and salt.
+    /// @param takerAssetCancelAmount Desired amount of takerAsset to cancel in order.
+    /// @return Amount of takerAsset cancelled.
     function cancelOrder(
         address[5] orderAddresses,
         uint256[6] orderValues,
-        uint256 takerTokenCancelAmount)
+        uint256 takerAssetCancelAmount)
         public
-        returns (uint256 takerTokenCancelledAmount);
+        returns (uint256 takerAssetCancelledAmount);
 
     /// @dev Cancels all orders for a specified maker up to a certain time.
     /// @param salt Orders created with a salt less or equal to this value will be cancelled.
@@ -159,51 +159,51 @@ contract IExchange {
         external;
 
     /// @dev Fills an order with specified parameters and ECDSA signature. Throws if specified amount not filled entirely.
-    /// @param orderAddresses Array of order's maker, taker, makerToken, takerToken, and feeRecipient.
-    /// @param orderValues Array of order's makerTokenAmount, takerTokenAmount, makerFee, takerFee, expirationTimestampInSec, and salt.
-    /// @param takerTokenFillAmount Desired amount of takerToken to fill.
+    /// @param orderAddresses Array of order's maker, taker, makerAsset, takerAsset, and feeRecipient.
+    /// @param orderValues Array of order's makerAssetAmount, takerAssetAmount, makerFee, takerFee, expirationTimestampInSec, and salt.
+    /// @param takerAssetFillAmount Desired amount of takerAsset to fill.
     /// @param v ECDSA signature parameter v.
     /// @param r ECDSA signature parameters r.
     /// @param s ECDSA signature parameters s.
     function fillOrKillOrder(
         address[5] orderAddresses,
         uint256[6] orderValues,
-        uint256 takerTokenFillAmount,
+        uint256 takerAssetFillAmount,
         uint8 v,
         bytes32 r,
         bytes32 s)
         public;
 
     /// @dev Fills an order with specified parameters and ECDSA signature. Returns false if the transaction would otherwise revert.
-    /// @param orderAddresses Array of order's maker, taker, makerToken, takerToken, and feeRecipient.
-    /// @param orderValues Array of order's makerTokenAmount, takerTokenAmount, makerFee, takerFee, expirationTimestampInSec, and salt.
-    /// @param takerTokenFillAmount Desired amount of takerToken to fill.
+    /// @param orderAddresses Array of order's maker, taker, makerAsset, takerAsset, and feeRecipient.
+    /// @param orderValues Array of order's makerAssetAmount, takerAssetAmount, makerFee, takerFee, expirationTimestampInSec, and salt.
+    /// @param takerAssetFillAmount Desired amount of takerAsset to fill.
     /// @param v ECDSA signature parameter v.
     /// @param r ECDSA signature parameters r.
     /// @param s ECDSA signature parameters s.
     /// @return Success if the transaction did not revert.
-    /// @return Total amount of takerToken filled in trade.
+    /// @return Total amount of takerAsset filled in trade.
     function fillOrderNoThrow(
         address[5] orderAddresses,
         uint256[6] orderValues,
-        uint256 takerTokenFillAmount,
+        uint256 takerAssetFillAmount,
         uint8 v,
         bytes32 r,
         bytes32 s)
         public
-        returns (bool success, uint256 takerTokenFilledAmount);
+        returns (bool success, uint256 takerAssetFilledAmount);
 
     /// @dev Synchronously executes multiple calls of fillOrder in a single transaction.
     /// @param orderAddresses Array of address arrays containing individual order addresses.
     /// @param orderValues Array of uint256 arrays containing individual order values.
-    /// @param takerTokenFillAmounts Array of desired amounts of takerToken to fill in orders.
+    /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to fill in orders.
     /// @param v Array ECDSA signature v parameters.
     /// @param r Array of ECDSA signature r parameters.
     /// @param s Array of ECDSA signature s parameters.
     function batchFillOrders(
         address[5][] orderAddresses,
         uint256[6][] orderValues,
-        uint256[] takerTokenFillAmounts,
+        uint256[] takerAssetFillAmounts,
         uint8[] v,
         bytes32[] r,
         bytes32[] s)
@@ -212,14 +212,14 @@ contract IExchange {
     /// @dev Synchronously executes multiple calls of fillOrKill in a single transaction.
     /// @param orderAddresses Array of address arrays containing individual order addresses.
     /// @param orderValues Array of uint256 arrays containing individual order values.
-    /// @param takerTokenFillAmounts Array of desired amounts of takerToken to fill in orders.
+    /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to fill in orders.
     /// @param v Array ECDSA signature v parameters.
     /// @param r Array of ECDSA signature r parameters.
     /// @param s Array of ECDSA signature s parameters.
     function batchFillOrKillOrders(
         address[5][] orderAddresses,
         uint256[6][] orderValues,
-        uint256[] takerTokenFillAmounts,
+        uint256[] takerAssetFillAmounts,
         uint8[] v,
         bytes32[] r,
         bytes32[] s)
@@ -228,49 +228,49 @@ contract IExchange {
     /// @dev Synchronously executes multiple calls of fillOrderNoThrow in a single transaction.
     /// @param orderAddresses Array of address arrays containing individual order addresses.
     /// @param orderValues Array of uint256 arrays containing individual order values.
-    /// @param takerTokenFillAmounts Array of desired amounts of takerToken to fill in orders.
+    /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to fill in orders.
     /// @param v Array ECDSA signature v parameters.
     /// @param r Array of ECDSA signature r parameters.
     /// @param s Array of ECDSA signature s parameters.
     function batchFillOrdersNoThrow(
         address[5][] orderAddresses,
         uint256[6][] orderValues,
-        uint256[] takerTokenFillAmounts,
+        uint256[] takerAssetFillAmounts,
         uint8[] v,
         bytes32[] r,
         bytes32[] s)
         external;
 
-    /// @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 takerAssetFillAmount filled.
     /// @param orderAddresses Array of address arrays containing individual order addresses.
     /// @param orderValues Array of uint256 arrays containing individual order values.
-    /// @param takerTokenFillAmount Desired total amount of takerToken to fill in orders.
+    /// @param takerAssetFillAmount Desired total amount of takerAsset to fill in orders.
     /// @param v Array ECDSA signature v parameters.
     /// @param r Array of ECDSA signature r parameters.
     /// @param s Array of ECDSA signature s parameters.
-    /// @return Total amount of takerTokenFillAmount filled in orders.
+    /// @return Total amount of takerAssetFillAmount filled in orders.
     function marketFillOrders(
         address[5][] orderAddresses,
         uint256[6][] orderValues,
-        uint256 takerTokenFillAmount,
+        uint256 takerAssetFillAmount,
         uint8[] v,
         bytes32[] r,
         bytes32[] s)
         external
         returns (uint256 totalTakerTokenFilledAmount);
 
-    /// @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 takerAssetFillAmount filled.
     /// @param orderAddresses Array of address arrays containing individual order addresses.
     /// @param orderValues Array of uint256 arrays containing individual order values.
-    /// @param takerTokenFillAmount Desired total amount of takerToken to fill in orders.
+    /// @param takerAssetFillAmount Desired total amount of takerAsset to fill in orders.
     /// @param v Array ECDSA signature v parameters.
     /// @param r Array of ECDSA signature r parameters.
     /// @param s Array of ECDSA signature s parameters.
-    /// @return Total amount of takerTokenFillAmount filled in orders.
+    /// @return Total amount of takerAssetFillAmount filled in orders.
     function marketFillOrdersNoThrow(
         address[5][] orderAddresses,
         uint256[6][] orderValues,
-        uint256 takerTokenFillAmount,
+        uint256 takerAssetFillAmount,
         uint8[] v,
         bytes32[] r,
         bytes32[] s)
@@ -280,10 +280,10 @@ contract IExchange {
     /// @dev Synchronously cancels multiple orders in a single transaction.
     /// @param orderAddresses Array of address arrays containing individual order addresses.
     /// @param orderValues Array of uint256 arrays containing individual order values.
-    /// @param takerTokenCancelAmounts Array of desired amounts of takerToken to cancel in orders.
+    /// @param takerAssetCancelAmounts Array of desired amounts of takerAsset to cancel in orders.
     function batchCancelOrders(
         address[5][] orderAddresses,
         uint256[6][] orderValues,
-        uint256[] takerTokenCancelAmounts)
+        uint256[] takerAssetCancelAmounts)
         external;
 }
diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol b/packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol
index d47a0fbbe..61a4a382d 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/LibOrder.sol
@@ -26,8 +26,8 @@ contract LibOrder {
         "address makerAddress",
         "address takerAddress",
         "address feeRecipientAddress",
-        "uint256 makerTokenAmount",
-        "uint256 takerTokenAmount",
+        "uint256 makerAssetAmount",
+        "uint256 takerAssetAmount",
         "uint256 makerFee",
         "uint256 takerFee",
         "uint256 expirationTimeSeconds",
@@ -40,8 +40,8 @@ contract LibOrder {
         address makerAddress;
         address takerAddress;
         address feeRecipientAddress;
-        uint256 makerTokenAmount;
-        uint256 takerTokenAmount;
+        uint256 makerAssetAmount;
+        uint256 takerAssetAmount;
         uint256 makerFee;
         uint256 takerFee;
         uint256 expirationTimeSeconds;
@@ -66,8 +66,8 @@ contract LibOrder {
                 order.makerAddress,
                 order.takerAddress,
                 order.feeRecipientAddress,
-                order.makerTokenAmount,
-                order.takerTokenAmount,
+                order.makerAssetAmount,
+                order.takerAssetAmount,
                 order.makerFee,
                 order.takerFee,
                 order.expirationTimeSeconds,
diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol b/packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol
index ec1bd57ce..10985d6d3 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/MixinExchangeCore.sol
@@ -39,7 +39,7 @@ contract MixinExchangeCore is
     LibErrors,
     LibPartialAmount
 {
-    // Mapping of orderHash => amount of takerToken already bought by maker
+    // Mapping of orderHash => amount of takerAsset already bought by maker
     mapping (bytes32 => uint256) public filled;
 
     // Mapping of orderHash => cancelled
@@ -55,8 +55,8 @@ contract MixinExchangeCore is
         address indexed feeRecipientAddress,
         bytes makerAssetData,
         bytes takerAssetData,
-        uint256 makerTokenFilledAmount,
-        uint256 takerTokenFilledAmount,
+        uint256 makerAssetFilledAmount,
+        uint256 takerAssetFilledAmount,
         uint256 makerFeePaid,
         uint256 takerFeePaid,
         bytes32 indexed orderHash
@@ -81,12 +81,12 @@ contract MixinExchangeCore is
 
     /// @dev Fills the input order.
     /// @param order Order struct containing order specifications.
-    /// @param takerTokenFillAmount Desired amount of takerToken to sell.
+    /// @param takerAssetFillAmount Desired amount of takerAsset to sell.
     /// @param signature Proof that order has been created by maker.
     /// @return Amounts filled and fees paid by maker and taker.
     function fillOrder(
         Order memory order,
-        uint256 takerTokenFillAmount,
+        uint256 takerAssetFillAmount,
         bytes memory signature)
         public
         returns (FillResults memory fillResults)
@@ -109,8 +109,8 @@ 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(order.makerAssetAmount > 0);
+            require(order.takerAssetAmount > 0);
             require(isValidSignature(orderHash, order.makerAddress, signature));
         }
 
@@ -118,7 +118,7 @@ contract MixinExchangeCore is
         if (order.takerAddress != address(0)) {
             require(order.takerAddress == msg.sender);
         }
-        require(takerTokenFillAmount > 0);
+        require(takerAssetFillAmount > 0);
 
         // Validate order expiration
         if (block.timestamp >= order.expirationTimeSeconds) {
@@ -127,26 +127,26 @@ contract MixinExchangeCore is
         }
 
         // Validate order availability
-        uint256 remainingTakerTokenFillAmount = safeSub(order.takerTokenAmount, filled[orderHash]);
+        uint256 remainingTakerTokenFillAmount = safeSub(order.takerAssetAmount, filled[orderHash]);
         if (remainingTakerTokenFillAmount == 0) {
             emit ExchangeError(uint8(Errors.ORDER_FULLY_FILLED), orderHash);
             return fillResults;
         }
 
         // Validate fill order rounding
-        fillResults.takerTokenFilledAmount = min256(takerTokenFillAmount, remainingTakerTokenFillAmount);
-        if (isRoundingError(fillResults.takerTokenFilledAmount, order.takerTokenAmount, order.makerTokenAmount)) {
+        fillResults.takerAssetFilledAmount = min256(takerAssetFillAmount, remainingTakerTokenFillAmount);
+        if (isRoundingError(fillResults.takerAssetFilledAmount, order.takerAssetAmount, order.makerAssetAmount)) {
             emit ExchangeError(uint8(Errors.ROUNDING_ERROR_TOO_LARGE), orderHash);
-            fillResults.takerTokenFilledAmount = 0;
+            fillResults.takerAssetFilledAmount = 0;
             return fillResults;
         }
 
         // Update state
-        filled[orderHash] = safeAdd(filled[orderHash], fillResults.takerTokenFilledAmount);
+        filled[orderHash] = safeAdd(filled[orderHash], fillResults.takerAssetFilledAmount);
 
         // Settle order
-        (fillResults.makerTokenFilledAmount, fillResults.makerFeePaid, fillResults.takerFeePaid) =
-            settleOrder(order, msg.sender, fillResults.takerTokenFilledAmount);
+        (fillResults.makerAssetFilledAmount, fillResults.makerFeePaid, fillResults.takerFeePaid) =
+            settleOrder(order, msg.sender, fillResults.takerAssetFilledAmount);
 
         // Log order
         emit Fill(
@@ -155,8 +155,8 @@ contract MixinExchangeCore is
             order.feeRecipientAddress,
             order.makerAssetData,
             order.takerAssetData,
-            fillResults.makerTokenFilledAmount,
-            fillResults.takerTokenFilledAmount,
+            fillResults.makerAssetFilledAmount,
+            fillResults.takerAssetFilledAmount,
             fillResults.makerFeePaid,
             fillResults.takerFeePaid,
             orderHash
@@ -176,8 +176,8 @@ contract MixinExchangeCore is
         bytes32 orderHash = getOrderHash(order);
 
         // Validate the order
-        require(order.makerTokenAmount > 0);
-        require(order.takerTokenAmount > 0);
+        require(order.makerAssetAmount > 0);
+        require(order.takerAssetAmount > 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 718572d50..5fff2cd60 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol
@@ -57,30 +57,30 @@ contract MixinSettlementProxy is
     function settleOrder(
         Order memory order,
         address takerAddress,
-        uint256 takerTokenFilledAmount)
+        uint256 takerAssetFilledAmount)
         internal
         returns (
-            uint256 makerTokenFilledAmount,
+            uint256 makerAssetFilledAmount,
             uint256 makerFeePaid,
             uint256 takerFeePaid
         )
     {
-        makerTokenFilledAmount = getPartialAmount(takerTokenFilledAmount, order.takerTokenAmount, order.makerTokenAmount);
+        makerAssetFilledAmount = getPartialAmount(takerAssetFilledAmount, order.takerAssetAmount, order.makerAssetAmount);
         ASSET_PROXY_DISPATCHER.transferFrom(
             order.makerAssetData,
             order.makerAddress,
             takerAddress,
-            makerTokenFilledAmount
+            makerAssetFilledAmount
         );
         ASSET_PROXY_DISPATCHER.transferFrom(
             order.takerAssetData,
             takerAddress,
             order.makerAddress,
-            takerTokenFilledAmount
+            takerAssetFilledAmount
         );
         if (order.feeRecipientAddress != address(0)) {
             if (order.makerFee > 0) {
-                makerFeePaid = getPartialAmount(takerTokenFilledAmount, order.takerTokenAmount, order.makerFee);
+                makerFeePaid = getPartialAmount(takerAssetFilledAmount, order.takerAssetAmount, order.makerFee);
                 ASSET_PROXY_DISPATCHER.transferFrom(
                     ZRX_PROXY_DATA,
                     order.makerAddress,
@@ -89,7 +89,7 @@ contract MixinSettlementProxy is
                 );
             }
             if (order.takerFee > 0) {
-                takerFeePaid = getPartialAmount(takerTokenFilledAmount, order.takerTokenAmount, order.takerFee);
+                takerFeePaid = getPartialAmount(takerAssetFilledAmount, order.takerAssetAmount, order.takerFee);
                 ASSET_PROXY_DISPATCHER.transferFrom(
                     ZRX_PROXY_DATA,
                     takerAddress,
@@ -98,6 +98,6 @@ contract MixinSettlementProxy is
                 );
             }
         }
-        return (makerTokenFilledAmount, makerFeePaid, takerFeePaid);
+        return (makerAssetFilledAmount, 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 027fcd87f..caa391aed 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/MixinWrapperFunctions.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/MixinWrapperFunctions.sol
@@ -31,35 +31,35 @@ contract MixinWrapperFunctions is
     LibBytes,
     LibPartialAmount
 {
-    /// @dev Fills the input order. Reverts if exact takerTokenFillAmount not filled.
+    /// @dev Fills the input order. Reverts if exact takerAssetFillAmount not filled.
     /// @param order Order struct containing order specifications.
-    /// @param takerTokenFillAmount Desired amount of takerToken to sell.
+    /// @param takerAssetFillAmount Desired amount of takerAsset to sell.
     /// @param signature Proof that order has been created by maker.
     function fillOrKillOrder(
         Order memory order,
-        uint256 takerTokenFillAmount,
+        uint256 takerAssetFillAmount,
         bytes memory signature)
         public
         returns (FillResults memory fillResults)
     {
         fillResults = fillOrder(
             order,
-            takerTokenFillAmount,
+            takerAssetFillAmount,
             signature
         );
-        require(fillResults.takerTokenFilledAmount == takerTokenFillAmount);
+        require(fillResults.takerAssetFilledAmount == takerAssetFillAmount);
         return fillResults;
     }
 
     /// @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 sell.
+    /// @param takerAssetFillAmount Desired amount of takerAsset to sell.
     /// @param signature Proof that order has been created by maker.
     /// @return Amounts filled and fees paid by maker and taker.
     function fillOrderNoThrow(
         Order memory order,
-        uint256 takerTokenFillAmount,
+        uint256 takerAssetFillAmount,
         bytes memory signature)
         public
         returns (FillResults memory fillResults)
@@ -73,14 +73,14 @@ contract MixinWrapperFunctions is
         // | Header   | 0x00   | 4       | function selector                           |
         // | Params   |        | 3 * 32  | function parameters:                        |
         // |          | 0x00   |         |   1. offset to order (*)                    |
-        // |          | 0x20   |         |   2. takerTokenFillAmount                   |
+        // |          | 0x20   |         |   2. takerAssetFillAmount                   |
         // |          | 0x40   |         |   3. offset to signature (*)                |
         // | Data     |        | 11 * 32 | order:                                      |
         // |          | 0x000  |         |   1.  makerAddress                          |
         // |          | 0x020  |         |   2.  takerAddress                          |
         // |          | 0x040  |         |   3.  feeRecipientAddress                   |
-        // |          | 0x060  |         |   4.  makerTokenAmount                      |
-        // |          | 0x080  |         |   5.  takerTokenAmount                      |
+        // |          | 0x060  |         |   4.  makerAssetAmount                      |
+        // |          | 0x080  |         |   5.  takerAssetAmount                      |
         // |          | 0x0A0  |         |   6.  makerFeeAmount                        |
         // |          | 0x0C0  |         |   7.  takerFeeAmount                        |
         // |          | 0x0E0  |         |   8.  expirationTimeSeconds                 |
@@ -150,8 +150,8 @@ contract MixinWrapperFunctions is
             mstore(dataAreaEnd, mload(sourceOffset))                            // makerAddress
             mstore(add(dataAreaEnd, 0x20), mload(add(sourceOffset, 0x20)))      // takerAddress
             mstore(add(dataAreaEnd, 0x40), mload(add(sourceOffset, 0x40)))      // feeRecipientAddress
-            mstore(add(dataAreaEnd, 0x60), mload(add(sourceOffset, 0x60)))      // makerTokenAmount
-            mstore(add(dataAreaEnd, 0x80), mload(add(sourceOffset, 0x80)))      // takerTokenAmount
+            mstore(add(dataAreaEnd, 0x60), mload(add(sourceOffset, 0x60)))      // makerAssetAmount
+            mstore(add(dataAreaEnd, 0x80), mload(add(sourceOffset, 0x80)))      // takerAssetAmount
             mstore(add(dataAreaEnd, 0xA0), mload(add(sourceOffset, 0xA0)))      // makerFeeAmount
             mstore(add(dataAreaEnd, 0xC0), mload(add(sourceOffset, 0xC0)))      // takerFeeAmount
             mstore(add(dataAreaEnd, 0xE0), mload(add(sourceOffset, 0xE0)))      // expirationTimeSeconds
@@ -199,8 +199,8 @@ contract MixinWrapperFunctions is
                 sourceOffset := add(sourceOffset, 0x20)
             }
 
-            /////// Write takerTokenFillAmount ///////
-            mstore(paramsAreaOffset, takerTokenFillAmount)
+            /////// Write takerAssetFillAmount ///////
+            mstore(paramsAreaOffset, takerAssetFillAmount)
             paramsAreaOffset := add(paramsAreaOffset, 0x20)
 
             /////// Write signature ///////
@@ -252,18 +252,18 @@ contract MixinWrapperFunctions is
 
     /// @dev Synchronously executes multiple calls of fillOrder.
     /// @param orders Array of order specifications.
-    /// @param takerTokenFillAmounts Array of desired amounts of takerToken to sell in orders.
+    /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to sell in orders.
     /// @param signatures Proofs that orders have been created by makers.
     function batchFillOrders(
         Order[] memory orders,
-        uint256[] memory takerTokenFillAmounts,
+        uint256[] memory takerAssetFillAmounts,
         bytes[] memory signatures)
         public
     {
         for (uint256 i = 0; i < orders.length; i++) {
             fillOrder(
                 orders[i],
-                takerTokenFillAmounts[i],
+                takerAssetFillAmounts[i],
                 signatures[i]
             );
         }
@@ -271,18 +271,18 @@ contract MixinWrapperFunctions is
 
     /// @dev Synchronously executes multiple calls of fillOrKill.
     /// @param orders Array of order specifications.
-    /// @param takerTokenFillAmounts Array of desired amounts of takerToken to sell in orders.
+    /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to sell in orders.
     /// @param signatures Proofs that orders have been created by makers.
     function batchFillOrKillOrders(
         Order[] memory orders,
-        uint256[] memory takerTokenFillAmounts,
+        uint256[] memory takerAssetFillAmounts,
         bytes[] memory signatures)
         public
     {
         for (uint256 i = 0; i < orders.length; i++) {
             fillOrKillOrder(
                 orders[i],
-                takerTokenFillAmounts[i],
+                takerAssetFillAmounts[i],
                 signatures[i]
             );
         }
@@ -291,31 +291,31 @@ 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 order specifications.
-    /// @param takerTokenFillAmounts Array of desired amounts of takerToken to sell in orders.
+    /// @param takerAssetFillAmounts Array of desired amounts of takerAsset to sell in orders.
     /// @param signatures Proofs that orders have been created by makers.
     function batchFillOrdersNoThrow(
         Order[] memory orders,
-        uint256[] memory takerTokenFillAmounts,
+        uint256[] memory takerAssetFillAmounts,
         bytes[] memory signatures)
         public
     {
         for (uint256 i = 0; i < orders.length; i++) {
             fillOrderNoThrow(
                 orders[i],
-                takerTokenFillAmounts[i],
+                takerAssetFillAmounts[i],
                 signatures[i]
             );
         }
     }
 
-    /// @dev Synchronously executes multiple calls of fillOrder until total amount of takerToken is sold by taker.
+    /// @dev Synchronously executes multiple calls of fillOrder until total amount of takerAsset is sold by taker.
     /// @param orders Array of order specifications.
-    /// @param takerTokenFillAmount Desired amount of takerToken to sell.
+    /// @param takerAssetFillAmount Desired amount of takerAsset to sell.
     /// @param signatures Proofs that orders have been created by makers.
     /// @return Amounts filled and fees paid by makers and taker.
     function marketSellOrders(
         Order[] memory orders,
-        uint256 takerTokenFillAmount,
+        uint256 takerAssetFillAmount,
         bytes[] memory signatures)
         public
         returns (FillResults memory totalFillResults)
@@ -325,10 +325,10 @@ contract MixinWrapperFunctions is
             // Token being sold by taker must be the same for each order
             require(areBytesEqual(orders[i].takerAssetData, orders[0].takerAssetData));
 
-            // Calculate the remaining amount of takerToken to sell
-            uint256 remainingTakerTokenFillAmount = safeSub(takerTokenFillAmount, totalFillResults.takerTokenFilledAmount);
+            // Calculate the remaining amount of takerAsset to sell
+            uint256 remainingTakerTokenFillAmount = safeSub(takerAssetFillAmount, totalFillResults.takerAssetFilledAmount);
 
-            // Attempt to sell the remaining amount of takerToken
+            // Attempt to sell the remaining amount of takerAsset
             FillResults memory singleFillResults = fillOrder(
                 orders[i],
                 remainingTakerTokenFillAmount,
@@ -338,23 +338,23 @@ contract MixinWrapperFunctions is
             // Update amounts filled and fees paid by maker and taker
             addFillResults(totalFillResults, singleFillResults);
 
-            // Stop execution if the entire amount of takerToken has been sold
-            if (totalFillResults.takerTokenFilledAmount == takerTokenFillAmount) {
+            // Stop execution if the entire amount of takerAsset has been sold
+            if (totalFillResults.takerAssetFilledAmount == takerAssetFillAmount) {
                 break;
             }
         }
         return totalFillResults;
     }
 
-    /// @dev Synchronously executes multiple calls of fillOrder until total amount of takerToken is sold by taker.
+    /// @dev Synchronously executes multiple calls of fillOrder until total amount of takerAsset is sold by taker.
     ///      Returns false if the transaction would otherwise revert.
     /// @param orders Array of order specifications.
-    /// @param takerTokenFillAmount Desired amount of takerToken to sell.
+    /// @param takerAssetFillAmount Desired amount of takerAsset to sell.
     /// @param signatures Proofs that orders have been signed by makers.
     /// @return Amounts filled and fees paid by makers and taker.
     function marketSellOrdersNoThrow(
         Order[] memory orders,
-        uint256 takerTokenFillAmount,
+        uint256 takerAssetFillAmount,
         bytes[] memory signatures)
         public
         returns (FillResults memory totalFillResults)
@@ -364,10 +364,10 @@ contract MixinWrapperFunctions is
             // Token being sold by taker must be the same for each order
             require(areBytesEqual(orders[i].takerAssetData, orders[0].takerAssetData));
 
-            // Calculate the remaining amount of takerToken to sell
-            uint256 remainingTakerTokenFillAmount = safeSub(takerTokenFillAmount, totalFillResults.takerTokenFilledAmount);
+            // Calculate the remaining amount of takerAsset to sell
+            uint256 remainingTakerTokenFillAmount = safeSub(takerAssetFillAmount, totalFillResults.takerAssetFilledAmount);
 
-            // Attempt to sell the remaining amount of takerToken
+            // Attempt to sell the remaining amount of takerAsset
             FillResults memory singleFillResults = fillOrderNoThrow(
                 orders[i],
                 remainingTakerTokenFillAmount,
@@ -377,22 +377,22 @@ contract MixinWrapperFunctions is
             // Update amounts filled and fees paid by maker and taker
             addFillResults(totalFillResults, singleFillResults);
 
-            // Stop execution if the entire amount of takerToken has been sold
-            if (totalFillResults.takerTokenFilledAmount == takerTokenFillAmount) {
+            // Stop execution if the entire amount of takerAsset has been sold
+            if (totalFillResults.takerAssetFilledAmount == takerAssetFillAmount) {
                 break;
             }
         }
         return totalFillResults;
     }
 
-    /// @dev Synchronously executes multiple calls of fillOrder until total amount of makerToken is bought by taker.
+    /// @dev Synchronously executes multiple calls of fillOrder until total amount of makerAsset is bought by taker.
     /// @param orders Array of order specifications.
-    /// @param makerTokenFillAmount Desired amount of makerToken to buy.
+    /// @param makerAssetFillAmount Desired amount of makerAsset to buy.
     /// @param signatures Proofs that orders have been signed by makers.
     /// @return Amounts filled and fees paid by makers and taker.
     function marketBuyOrders(
         Order[] memory orders,
-        uint256 makerTokenFillAmount,
+        uint256 makerAssetFillAmount,
         bytes[] memory signatures)
         public
         returns (FillResults memory totalFillResults)
@@ -402,18 +402,18 @@ contract MixinWrapperFunctions is
             // Token being bought by taker must be the same for each order
             require(areBytesEqual(orders[i].makerAssetData, orders[0].makerAssetData));
 
-            // Calculate the remaining amount of makerToken to buy
-            uint256 remainingMakerTokenFillAmount = safeSub(makerTokenFillAmount, totalFillResults.makerTokenFilledAmount);
+            // Calculate the remaining amount of makerAsset to buy
+            uint256 remainingMakerTokenFillAmount = safeSub(makerAssetFillAmount, totalFillResults.makerAssetFilledAmount);
 
-            // Convert the remaining amount of makerToken to buy into remaining amount
-            // of takerToken to sell, assuming entire amount can be sold in the current order
+            // Convert the remaining amount of makerAsset to buy into remaining amount
+            // of takerAsset to sell, assuming entire amount can be sold in the current order
             uint256 remainingTakerTokenFillAmount = getPartialAmount(
-                orders[i].takerTokenAmount,
-                orders[i].makerTokenAmount,
+                orders[i].takerAssetAmount,
+                orders[i].makerAssetAmount,
                 remainingMakerTokenFillAmount
             );
 
-            // Attempt to sell the remaining amount of takerToken
+            // Attempt to sell the remaining amount of takerAsset
             FillResults memory singleFillResults = fillOrder(
                 orders[i],
                 remainingTakerTokenFillAmount,
@@ -423,8 +423,8 @@ contract MixinWrapperFunctions is
             // Update amounts filled and fees paid by maker and taker
             addFillResults(totalFillResults, singleFillResults);
 
-            // Stop execution if the entire amount of makerToken has been bought
-            if (totalFillResults.makerTokenFilledAmount == makerTokenFillAmount) {
+            // Stop execution if the entire amount of makerAsset has been bought
+            if (totalFillResults.makerAssetFilledAmount == makerAssetFillAmount) {
                 break;
             }
         }
@@ -434,12 +434,12 @@ contract MixinWrapperFunctions is
     /// @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 order specifications.
-    /// @param makerTokenFillAmount Desired amount of makerToken to buy.
+    /// @param makerAssetFillAmount Desired amount of makerAsset to buy.
     /// @param signatures Proofs that orders have been signed by makers.
     /// @return Amounts filled and fees paid by makers and taker.
     function marketBuyOrdersNoThrow(
         Order[] memory orders,
-        uint256 makerTokenFillAmount,
+        uint256 makerAssetFillAmount,
         bytes[] memory signatures)
         public
         returns (FillResults memory totalFillResults)
@@ -449,18 +449,18 @@ contract MixinWrapperFunctions is
             // Token being bought by taker must be the same for each order
             require(areBytesEqual(orders[i].makerAssetData, orders[0].makerAssetData));
 
-            // Calculate the remaining amount of makerToken to buy
-            uint256 remainingMakerTokenFillAmount = safeSub(makerTokenFillAmount, totalFillResults.makerTokenFilledAmount);
+            // Calculate the remaining amount of makerAsset to buy
+            uint256 remainingMakerTokenFillAmount = safeSub(makerAssetFillAmount, totalFillResults.makerAssetFilledAmount);
 
-            // Convert the remaining amount of makerToken to buy into remaining amount
-            // of takerToken to sell, assuming entire amount can be sold in the current order
+            // Convert the remaining amount of makerAsset to buy into remaining amount
+            // of takerAsset to sell, assuming entire amount can be sold in the current order
             uint256 remainingTakerTokenFillAmount = getPartialAmount(
-                orders[i].takerTokenAmount,
-                orders[i].makerTokenAmount,
+                orders[i].takerAssetAmount,
+                orders[i].makerAssetAmount,
                 remainingMakerTokenFillAmount
             );
 
-            // Attempt to sell the remaining amount of takerToken
+            // Attempt to sell the remaining amount of takerAsset
             FillResults memory singleFillResults = fillOrderNoThrow(
                 orders[i],
                 remainingTakerTokenFillAmount,
@@ -470,8 +470,8 @@ contract MixinWrapperFunctions is
             // Update amounts filled and fees paid by maker and taker
             addFillResults(totalFillResults, singleFillResults);
 
-            // Stop execution if the entire amount of makerToken has been bought
-            if (totalFillResults.makerTokenFilledAmount == makerTokenFillAmount) {
+            // Stop execution if the entire amount of makerAsset has been bought
+            if (totalFillResults.makerAssetFilledAmount == makerAssetFillAmount) {
                 break;
             }
         }
@@ -496,8 +496,8 @@ contract MixinWrapperFunctions is
         internal
         pure
     {
-        totalFillResults.makerTokenFilledAmount = safeAdd(totalFillResults.makerTokenFilledAmount, singleFillResults.makerTokenFilledAmount);
-        totalFillResults.takerTokenFilledAmount = safeAdd(totalFillResults.takerTokenFilledAmount, singleFillResults.takerTokenFilledAmount);
+        totalFillResults.makerAssetFilledAmount = safeAdd(totalFillResults.makerAssetFilledAmount, singleFillResults.makerAssetFilledAmount);
+        totalFillResults.takerAssetFilledAmount = safeAdd(totalFillResults.takerAssetFilledAmount, singleFillResults.takerAssetFilledAmount);
         totalFillResults.makerFeePaid = safeAdd(totalFillResults.makerFeePaid, singleFillResults.makerFeePaid);
         totalFillResults.takerFeePaid = safeAdd(totalFillResults.takerFeePaid, singleFillResults.takerFeePaid);
     }
diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MExchangeCore.sol b/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MExchangeCore.sol
index d2ec4da04..9a7f80109 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MExchangeCore.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MExchangeCore.sol
@@ -24,15 +24,15 @@ import "../LibOrder.sol";
 contract MExchangeCore is LibOrder {
 
     struct FillResults {
-        uint256 makerTokenFilledAmount;
-        uint256 takerTokenFilledAmount;
+        uint256 makerAssetFilledAmount;
+        uint256 takerAssetFilledAmount;
         uint256 makerFeePaid;
         uint256 takerFeePaid;
     }
 
     function fillOrder(
         Order memory order,
-        uint256 takerTokenFillAmount,
+        uint256 takerAssetFillAmount,
         bytes memory signature)
         public
         returns (FillResults memory fillResults);
diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MSettlement.sol b/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MSettlement.sol
index a9911c8ce..172138f2d 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MSettlement.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/mixins/MSettlement.sol
@@ -26,10 +26,10 @@ contract MSettlement is LibOrder {
     function settleOrder(
         Order memory order,
         address takerAddress,
-        uint256 takerTokenFilledAmount)
+        uint256 takerAssetFilledAmount)
         internal
         returns (
-            uint256 makerTokenFilledAmount,
+            uint256 makerAssetFilledAmount,
             uint256 makerFeePaid,
             uint256 takerFeePaid
         );
diff --git a/packages/contracts/src/utils/exchange_wrapper.ts b/packages/contracts/src/utils/exchange_wrapper.ts
index cda012aa9..927513fe3 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: { takerAssetFillAmount?: BigNumber } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = orderUtils.createFill(signedOrder, opts.takerTokenFillAmount);
+        const params = orderUtils.createFill(signedOrder, opts.takerAssetFillAmount);
         const txHash = await this._exchange.fillOrder.sendTransactionAsync(
             params.order,
-            params.takerTokenFillAmount,
+            params.takerAssetFillAmount,
             params.signature,
             { from },
         );
@@ -43,12 +43,12 @@ export class ExchangeWrapper {
     public async fillOrKillOrderAsync(
         signedOrder: SignedOrder,
         from: string,
-        opts: { takerTokenFillAmount?: BigNumber } = {},
+        opts: { takerAssetFillAmount?: BigNumber } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = orderUtils.createFill(signedOrder, opts.takerTokenFillAmount);
+        const params = orderUtils.createFill(signedOrder, opts.takerAssetFillAmount);
         const txHash = await this._exchange.fillOrKillOrder.sendTransactionAsync(
             params.order,
-            params.takerTokenFillAmount,
+            params.takerAssetFillAmount,
             params.signature,
             { from },
         );
@@ -58,12 +58,12 @@ export class ExchangeWrapper {
     public async fillOrderNoThrowAsync(
         signedOrder: SignedOrder,
         from: string,
-        opts: { takerTokenFillAmount?: BigNumber } = {},
+        opts: { takerAssetFillAmount?: BigNumber } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = orderUtils.createFill(signedOrder, opts.takerTokenFillAmount);
+        const params = orderUtils.createFill(signedOrder, opts.takerAssetFillAmount);
         const txHash = await this._exchange.fillOrderNoThrow.sendTransactionAsync(
             params.order,
-            params.takerTokenFillAmount,
+            params.takerAssetFillAmount,
             params.signature,
             { from },
         );
@@ -73,12 +73,12 @@ export class ExchangeWrapper {
     public async batchFillOrdersAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { takerTokenFillAmounts?: BigNumber[] } = {},
+        opts: { takerAssetFillAmounts?: BigNumber[] } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createBatchFill(orders, opts.takerTokenFillAmounts);
+        const params = formatters.createBatchFill(orders, opts.takerAssetFillAmounts);
         const txHash = await this._exchange.batchFillOrders.sendTransactionAsync(
             params.orders,
-            params.takerTokenFillAmounts,
+            params.takerAssetFillAmounts,
             params.signatures,
             { from },
         );
@@ -88,12 +88,12 @@ export class ExchangeWrapper {
     public async batchFillOrKillOrdersAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { takerTokenFillAmounts?: BigNumber[] } = {},
+        opts: { takerAssetFillAmounts?: BigNumber[] } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createBatchFill(orders, opts.takerTokenFillAmounts);
+        const params = formatters.createBatchFill(orders, opts.takerAssetFillAmounts);
         const txHash = await this._exchange.batchFillOrKillOrders.sendTransactionAsync(
             params.orders,
-            params.takerTokenFillAmounts,
+            params.takerAssetFillAmounts,
             params.signatures,
             { from },
         );
@@ -103,12 +103,12 @@ export class ExchangeWrapper {
     public async batchFillOrdersNoThrowAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { takerTokenFillAmounts?: BigNumber[] } = {},
+        opts: { takerAssetFillAmounts?: BigNumber[] } = {},
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createBatchFill(orders, opts.takerTokenFillAmounts);
+        const params = formatters.createBatchFill(orders, opts.takerAssetFillAmounts);
         const txHash = await this._exchange.batchFillOrdersNoThrow.sendTransactionAsync(
             params.orders,
-            params.takerTokenFillAmounts,
+            params.takerAssetFillAmounts,
             params.signatures,
             { from },
         );
@@ -118,12 +118,12 @@ export class ExchangeWrapper {
     public async marketSellOrdersAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { takerTokenFillAmount: BigNumber },
+        opts: { takerAssetFillAmount: BigNumber },
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createMarketSellOrders(orders, opts.takerTokenFillAmount);
+        const params = formatters.createMarketSellOrders(orders, opts.takerAssetFillAmount);
         const txHash = await this._exchange.marketSellOrders.sendTransactionAsync(
             params.orders,
-            params.takerTokenFillAmount,
+            params.takerAssetFillAmount,
             params.signatures,
             { from },
         );
@@ -133,12 +133,12 @@ export class ExchangeWrapper {
     public async marketSellOrdersNoThrowAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { takerTokenFillAmount: BigNumber },
+        opts: { takerAssetFillAmount: BigNumber },
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createMarketSellOrders(orders, opts.takerTokenFillAmount);
+        const params = formatters.createMarketSellOrders(orders, opts.takerAssetFillAmount);
         const txHash = await this._exchange.marketSellOrdersNoThrow.sendTransactionAsync(
             params.orders,
-            params.takerTokenFillAmount,
+            params.takerAssetFillAmount,
             params.signatures,
             { from },
         );
@@ -148,12 +148,12 @@ export class ExchangeWrapper {
     public async marketBuyOrdersAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { makerTokenFillAmount: BigNumber },
+        opts: { makerAssetFillAmount: BigNumber },
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createMarketBuyOrders(orders, opts.makerTokenFillAmount);
+        const params = formatters.createMarketBuyOrders(orders, opts.makerAssetFillAmount);
         const txHash = await this._exchange.marketBuyOrders.sendTransactionAsync(
             params.orders,
-            params.makerTokenFillAmount,
+            params.makerAssetFillAmount,
             params.signatures,
             { from },
         );
@@ -163,12 +163,12 @@ export class ExchangeWrapper {
     public async marketBuyOrdersNoThrowAsync(
         orders: SignedOrder[],
         from: string,
-        opts: { makerTokenFillAmount: BigNumber },
+        opts: { makerAssetFillAmount: BigNumber },
     ): Promise<TransactionReceiptWithDecodedLogs> {
-        const params = formatters.createMarketBuyOrders(orders, opts.makerTokenFillAmount);
+        const params = formatters.createMarketBuyOrders(orders, opts.makerAssetFillAmount);
         const txHash = await this._exchange.marketBuyOrdersNoThrow.sendTransactionAsync(
             params.orders,
-            params.makerTokenFillAmount,
+            params.makerAssetFillAmount,
             params.signatures,
             { from },
         );
diff --git a/packages/contracts/src/utils/formatters.ts b/packages/contracts/src/utils/formatters.ts
index fce10c448..e706c15b5 100644
--- a/packages/contracts/src/utils/formatters.ts
+++ b/packages/contracts/src/utils/formatters.ts
@@ -5,27 +5,27 @@ import { orderUtils } from './order_utils';
 import { BatchCancelOrders, BatchFillOrders, MarketBuyOrders, MarketSellOrders, SignedOrder } from './types';
 
 export const formatters = {
-    createBatchFill(signedOrders: SignedOrder[], takerTokenFillAmounts: BigNumber[] = []) {
+    createBatchFill(signedOrders: SignedOrder[], takerAssetFillAmounts: BigNumber[] = []) {
         const batchFill: BatchFillOrders = {
             orders: [],
             signatures: [],
-            takerTokenFillAmounts,
+            takerAssetFillAmounts,
         };
         _.forEach(signedOrders, signedOrder => {
             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 (takerAssetFillAmounts.length < signedOrders.length) {
+                batchFill.takerAssetFillAmounts.push(signedOrder.takerAssetAmount);
             }
         });
         return batchFill;
     },
-    createMarketSellOrders(signedOrders: SignedOrder[], takerTokenFillAmount: BigNumber) {
+    createMarketSellOrders(signedOrders: SignedOrder[], takerAssetFillAmount: BigNumber) {
         const marketSellOrders: MarketSellOrders = {
             orders: [],
             signatures: [],
-            takerTokenFillAmount,
+            takerAssetFillAmount,
         };
         _.forEach(signedOrders, signedOrder => {
             const orderStruct = orderUtils.getOrderStruct(signedOrder);
@@ -34,11 +34,11 @@ export const formatters = {
         });
         return marketSellOrders;
     },
-    createMarketBuyOrders(signedOrders: SignedOrder[], makerTokenFillAmount: BigNumber) {
+    createMarketBuyOrders(signedOrders: SignedOrder[], makerAssetFillAmount: BigNumber) {
         const marketBuyOrders: MarketBuyOrders = {
             orders: [],
             signatures: [],
-            makerTokenFillAmount,
+            makerAssetFillAmount,
         };
         _.forEach(signedOrders, signedOrder => {
             const orderStruct = orderUtils.getOrderStruct(signedOrder);
diff --git a/packages/contracts/src/utils/order_utils.ts b/packages/contracts/src/utils/order_utils.ts
index 18892b4d4..52eb44941 100644
--- a/packages/contracts/src/utils/order_utils.ts
+++ b/packages/contracts/src/utils/order_utils.ts
@@ -7,18 +7,18 @@ import { crypto } from './crypto';
 import { OrderStruct, SignatureType, SignedOrder, UnsignedOrder } from './types';
 
 export const orderUtils = {
-    createFill: (signedOrder: SignedOrder, takerTokenFillAmount?: BigNumber) => {
+    createFill: (signedOrder: SignedOrder, takerAssetFillAmount?: BigNumber) => {
         const fill = {
             order: orderUtils.getOrderStruct(signedOrder),
-            takerTokenFillAmount: takerTokenFillAmount || signedOrder.takerTokenAmount,
+            takerAssetFillAmount: takerAssetFillAmount || signedOrder.takerAssetAmount,
             signature: signedOrder.signature,
         };
         return fill;
     },
-    createCancel(signedOrder: SignedOrder, takerTokenCancelAmount?: BigNumber) {
+    createCancel(signedOrder: SignedOrder, takerAssetCancelAmount?: BigNumber) {
         const cancel = {
             order: orderUtils.getOrderStruct(signedOrder),
-            takerTokenCancelAmount: takerTokenCancelAmount || signedOrder.takerTokenAmount,
+            takerAssetCancelAmount: takerAssetCancelAmount || signedOrder.takerAssetAmount,
         };
         return cancel;
     },
@@ -27,8 +27,8 @@ export const orderUtils = {
             makerAddress: signedOrder.makerAddress,
             takerAddress: signedOrder.takerAddress,
             feeRecipientAddress: signedOrder.feeRecipientAddress,
-            makerTokenAmount: signedOrder.makerTokenAmount,
-            takerTokenAmount: signedOrder.takerTokenAmount,
+            makerAssetAmount: signedOrder.makerAssetAmount,
+            takerAssetAmount: signedOrder.takerAssetAmount,
             makerFee: signedOrder.makerFee,
             takerFee: signedOrder.takerFee,
             expirationTimeSeconds: signedOrder.expirationTimeSeconds,
@@ -44,8 +44,8 @@ export const orderUtils = {
             'address makerAddress',
             'address takerAddress',
             'address feeRecipientAddress',
-            'uint256 makerTokenAmount',
-            'uint256 takerTokenAmount',
+            'uint256 makerAssetAmount',
+            'uint256 takerAssetAmount',
             'uint256 makerFee',
             'uint256 takerFee',
             'uint256 expirationTimeSeconds',
@@ -58,8 +58,8 @@ export const orderUtils = {
             order.makerAddress,
             order.takerAddress,
             order.feeRecipientAddress,
-            order.makerTokenAmount,
-            order.takerTokenAmount,
+            order.makerAssetAmount,
+            order.takerAssetAmount,
             order.makerFee,
             order.takerFee,
             order.expirationTimeSeconds,
diff --git a/packages/contracts/src/utils/types.ts b/packages/contracts/src/utils/types.ts
index 69792b846..8bc9641fc 100644
--- a/packages/contracts/src/utils/types.ts
+++ b/packages/contracts/src/utils/types.ts
@@ -14,19 +14,19 @@ export interface SubmissionContractEventArgs {
 export interface BatchFillOrders {
     orders: OrderStruct[];
     signatures: string[];
-    takerTokenFillAmounts: BigNumber[];
+    takerAssetFillAmounts: BigNumber[];
 }
 
 export interface MarketSellOrders {
     orders: OrderStruct[];
     signatures: string[];
-    takerTokenFillAmount: BigNumber;
+    takerAssetFillAmount: BigNumber;
 }
 
 export interface MarketBuyOrders {
     orders: OrderStruct[];
     signatures: string[];
-    makerTokenFillAmount: BigNumber;
+    makerAssetFillAmount: BigNumber;
 }
 
 export interface BatchCancelOrders {
@@ -47,10 +47,10 @@ export interface DefaultOrderParams {
     exchangeAddress: string;
     makerAddress: string;
     feeRecipientAddress: string;
-    makerTokenAddress: string;
-    takerTokenAddress: string;
-    makerTokenAmount: BigNumber;
-    takerTokenAmount: BigNumber;
+    makerAssetAddress: string;
+    takerAssetAddress: string;
+    makerAssetAmount: BigNumber;
+    takerAssetAmount: BigNumber;
     makerFee: BigNumber;
     takerFee: BigNumber;
     makerAssetData: string;
@@ -137,8 +137,8 @@ export interface OrderStruct {
     makerAddress: string;
     takerAddress: string;
     feeRecipientAddress: string;
-    makerTokenAmount: BigNumber;
-    takerTokenAmount: BigNumber;
+    makerAssetAmount: BigNumber;
+    takerAssetAmount: BigNumber;
     makerFee: BigNumber;
     takerFee: BigNumber;
     expirationTimeSeconds: BigNumber;
diff --git a/packages/contracts/test/asset_proxy_dispatcher/proxies.ts b/packages/contracts/test/asset_proxy_dispatcher/proxies.ts
index 8b4f3faed..2b0d80338 100644
--- a/packages/contracts/test/asset_proxy_dispatcher/proxies.ts
+++ b/packages/contracts/test/asset_proxy_dispatcher/proxies.ts
@@ -34,7 +34,7 @@ describe('Asset Transfer Proxies', () => {
     let dmyBalances: Balances;
     let erc20Proxy: ERC20ProxyContract;
     let erc721Proxy: ERC721ProxyContract;
-    const makerTokenId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
+    const makerAssetId = new BigNumber('0x1010101010101010101010101010101010101010101010101010101010101010');
     const testAddressPaddedWithZeros = '0x0000000000000000056000000000000000000010';
     const INITIAL_BALANCE = new BigNumber(10000);
 
@@ -82,7 +82,7 @@ describe('Asset Transfer Proxies', () => {
         await erc721Token.setApprovalForAll.sendTransactionAsync(erc721Proxy.address, true, {
             from: takerAddress,
         });
-        await erc721Token.mint.sendTransactionAsync(makerAddress, makerTokenId, { from: tokenOwner });
+        await erc721Token.mint.sendTransactionAsync(makerAddress, makerAssetId, { from: tokenOwner });
     });
     beforeEach(async () => {
         await blockchainLifecycle.startAsync();
@@ -170,9 +170,9 @@ describe('Asset Transfer Proxies', () => {
     describe('Transfer Proxy - ERC721', () => {
         it('should successfully transfer tokens', async () => {
             // Construct metadata for ERC721 proxy
-            const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId);
+            const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId);
             // Verify pre-condition
-            const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(ownerMakerToken).to.be.bignumber.equal(makerAddress);
             // Perform a transfer from makerAddress to takerAddress
             const balances = await dmyBalances.getAsync();
@@ -185,15 +185,15 @@ describe('Asset Transfer Proxies', () => {
                 { from: assetProxyDispatcherAddress },
             );
             // Verify transfer was successful
-            const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress);
         });
 
         it('should throw if transferring 0 amount of a token', async () => {
             // Construct metadata for ERC721 proxy
-            const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId);
+            const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId);
             // Verify pre-condition
-            const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(ownerMakerToken).to.be.bignumber.equal(makerAddress);
             // Perform a transfer from makerAddress to takerAddress
             const balances = await dmyBalances.getAsync();
@@ -211,9 +211,9 @@ describe('Asset Transfer Proxies', () => {
 
         it('should throw if transferring > 1 amount of a token', async () => {
             // Construct metadata for ERC721 proxy
-            const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId);
+            const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId);
             // Verify pre-condition
-            const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const ownerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(ownerMakerToken).to.be.bignumber.equal(makerAddress);
             // Perform a transfer from makerAddress to takerAddress
             const balances = await dmyBalances.getAsync();
@@ -231,7 +231,7 @@ describe('Asset Transfer Proxies', () => {
 
         it('should throw if allowances are too low', async () => {
             // Construct metadata for ERC721 proxy
-            const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId);
+            const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId);
             // Remove transfer approval for makerAddress.
             await erc721Token.setApprovalForAll.sendTransactionAsync(erc721Proxy.address, false, {
                 from: makerAddress,
@@ -247,7 +247,7 @@ describe('Asset Transfer Proxies', () => {
 
         it('should throw if requesting address is not authorized', async () => {
             // Construct metadata for ERC721 proxy
-            const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId);
+            const encodedProxyMetadata = proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId);
             // Perform a transfer from makerAddress to takerAddress
             const amount = new BigNumber(1);
             return expect(
diff --git a/packages/contracts/test/exchange/core.ts b/packages/contracts/test/exchange/core.ts
index a33b06a12..b2f6aaa74 100644
--- a/packages/contracts/test/exchange/core.ts
+++ b/packages/contracts/test/exchange/core.ts
@@ -147,8 +147,8 @@ describe('Exchange', () => {
             exchangeAddress: exchange.address,
             makerAddress,
             feeRecipientAddress,
-            makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-            takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+            makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+            takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             makerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
             takerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
             makerAssetData: proxyUtils.encodeERC20ProxyData(defaultMakerTokenAddress),
@@ -214,80 +214,80 @@ describe('Exchange', () => {
 
         it('should create an unfillable order', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(1001),
-                takerTokenAmount: new BigNumber(3),
+                makerAssetAmount: new BigNumber(1001),
+                takerAssetAmount: new BigNumber(3),
             });
 
-            const takerTokenFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount(
+            const takerAssetFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(takerTokenFilledAmountBefore).to.be.bignumber.equal(0);
+            expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0);
 
             const fillTakerTokenAmount1 = new BigNumber(2);
             await exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount: fillTakerTokenAmount1,
+                takerAssetFillAmount: fillTakerTokenAmount1,
             });
 
-            const takerTokenFilledAmountAfter1 = await exWrapper.getTakerTokenFilledAmount(
+            const takerAssetFilledAmountAfter1 = await exWrapper.getTakerTokenFilledAmount(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(takerTokenFilledAmountAfter1).to.be.bignumber.equal(fillTakerTokenAmount1);
+            expect(takerAssetFilledAmountAfter1).to.be.bignumber.equal(fillTakerTokenAmount1);
 
             const fillTakerTokenAmount2 = new BigNumber(1);
             await exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount: fillTakerTokenAmount2,
+                takerAssetFillAmount: fillTakerTokenAmount2,
             });
 
-            const takerTokenFilledAmountAfter2 = await exWrapper.getTakerTokenFilledAmount(
+            const takerAssetFilledAmountAfter2 = await exWrapper.getTakerTokenFilledAmount(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(takerTokenFilledAmountAfter2).to.be.bignumber.equal(takerTokenFilledAmountAfter1);
+            expect(takerAssetFilledAmountAfter2).to.be.bignumber.equal(takerAssetFilledAmountAfter1);
         });
 
-        it('should transfer the correct amounts when makerTokenAmount === takerTokenAmount', async () => {
+        it('should transfer the correct amounts when makerAssetAmount === takerAssetAmount', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
             });
 
-            const takerTokenFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount(
+            const takerAssetFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(takerTokenFilledAmountBefore).to.be.bignumber.equal(0);
+            expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0);
 
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
 
             const makerAmountBoughtAfter = await exWrapper.getTakerTokenFilledAmount(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerTokenFillAmount);
+            expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerAssetFillAmount);
 
             const newBalances = await dmyBalances.getAsync();
 
-            const makerTokenFilledAmount = takerTokenFillAmount
-                .times(signedOrder.makerTokenAmount)
-                .dividedToIntegerBy(signedOrder.takerTokenAmount);
+            const makerAssetFilledAmount = takerAssetFillAmount
+                .times(signedOrder.makerAssetAmount)
+                .dividedToIntegerBy(signedOrder.takerAssetAmount);
             const makerFeePaid = signedOrder.makerFee
-                .times(makerTokenFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                .times(makerAssetFilledAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount);
             const takerFeePaid = signedOrder.takerFee
-                .times(makerTokenFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                .times(makerAssetFilledAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount);
             expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount),
+                balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount),
             );
             expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(makerFeePaid),
             );
             expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount),
             );
             expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount),
+                balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[takerAddress][zrx.address].minus(takerFeePaid),
@@ -297,50 +297,50 @@ describe('Exchange', () => {
             );
         });
 
-        it('should transfer the correct amounts when makerTokenAmount > takerTokenAmount', async () => {
+        it('should transfer the correct amounts when makerAssetAmount > takerAssetAmount', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+                takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
             });
 
-            const takerTokenFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount(
+            const takerAssetFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(takerTokenFilledAmountBefore).to.be.bignumber.equal(0);
+            expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0);
 
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
 
             const makerAmountBoughtAfter = await exWrapper.getTakerTokenFilledAmount(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerTokenFillAmount);
+            expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerAssetFillAmount);
 
             const newBalances = await dmyBalances.getAsync();
 
-            const makerTokenFilledAmount = takerTokenFillAmount
-                .times(signedOrder.makerTokenAmount)
-                .dividedToIntegerBy(signedOrder.takerTokenAmount);
+            const makerAssetFilledAmount = takerAssetFillAmount
+                .times(signedOrder.makerAssetAmount)
+                .dividedToIntegerBy(signedOrder.takerAssetAmount);
             const makerFeePaid = signedOrder.makerFee
-                .times(makerTokenFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                .times(makerAssetFilledAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount);
             const takerFeePaid = signedOrder.takerFee
-                .times(makerTokenFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                .times(makerAssetFilledAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount);
             expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount),
+                balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount),
             );
             expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(makerFeePaid),
             );
             expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount),
             );
             expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount),
+                balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[takerAddress][zrx.address].minus(takerFeePaid),
@@ -350,50 +350,50 @@ describe('Exchange', () => {
             );
         });
 
-        it('should transfer the correct amounts when makerTokenAmount < takerTokenAmount', async () => {
+        it('should transfer the correct amounts when makerAssetAmount < takerAssetAmount', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+                makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             });
 
-            const takerTokenFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount(
+            const takerAssetFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(takerTokenFilledAmountBefore).to.be.bignumber.equal(0);
+            expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0);
 
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
 
             const makerAmountBoughtAfter = await exWrapper.getTakerTokenFilledAmount(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerTokenFillAmount);
+            expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerAssetFillAmount);
 
             const newBalances = await dmyBalances.getAsync();
 
-            const makerTokenFilledAmount = takerTokenFillAmount
-                .times(signedOrder.makerTokenAmount)
-                .dividedToIntegerBy(signedOrder.takerTokenAmount);
+            const makerAssetFilledAmount = takerAssetFillAmount
+                .times(signedOrder.makerAssetAmount)
+                .dividedToIntegerBy(signedOrder.takerAssetAmount);
             const makerFeePaid = signedOrder.makerFee
-                .times(makerTokenFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                .times(makerAssetFilledAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount);
             const takerFeePaid = signedOrder.takerFee
-                .times(makerTokenFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                .times(makerAssetFilledAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount);
             expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount),
+                balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount),
             );
             expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(makerFeePaid),
             );
             expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount),
             );
             expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount),
+                balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[takerAddress][zrx.address].minus(takerFeePaid),
@@ -406,49 +406,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),
+                makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             });
 
-            const takerTokenFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount(
+            const takerAssetFilledAmountBefore = await exWrapper.getTakerTokenFilledAmount(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            expect(takerTokenFilledAmountBefore).to.be.bignumber.equal(0);
+            expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0);
 
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
 
             const makerAmountBoughtAfter = await exWrapper.getTakerTokenFilledAmount(
                 orderUtils.getOrderHashHex(signedOrder),
             );
-            const expectedMakerAmountBoughtAfter = takerTokenFillAmount.add(takerTokenFilledAmountBefore);
+            const expectedMakerAmountBoughtAfter = takerAssetFillAmount.add(takerAssetFilledAmountBefore);
             expect(makerAmountBoughtAfter).to.be.bignumber.equal(expectedMakerAmountBoughtAfter);
 
             const newBalances = await dmyBalances.getAsync();
 
-            const makerTokenFilledAmount = takerTokenFillAmount
-                .times(signedOrder.makerTokenAmount)
-                .dividedToIntegerBy(signedOrder.takerTokenAmount);
+            const makerAssetFilledAmount = takerAssetFillAmount
+                .times(signedOrder.makerAssetAmount)
+                .dividedToIntegerBy(signedOrder.takerAssetAmount);
             const makerFeePaid = signedOrder.makerFee
-                .times(makerTokenFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                .times(makerAssetFilledAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount);
             const takerFeePaid = signedOrder.takerFee
-                .times(makerTokenFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                .times(makerAssetFilledAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount);
             expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount),
+                balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount),
             );
             expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(makerFeePaid),
             );
             expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount),
             );
             expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount),
+                balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[takerAddress][zrx.address].minus(takerFeePaid),
@@ -458,33 +458,33 @@ 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 takerAssetFillAmount > remaining takerAssetAmount', async () => {
+            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
 
             const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount: signedOrder.takerTokenAmount,
+                takerAssetFillAmount: signedOrder.takerAssetAmount,
             });
             const log = res.logs[0] as LogWithDecodedArgs<FillContractEventArgs>;
-            expect(log.args.takerTokenFilledAmount).to.be.bignumber.equal(
-                signedOrder.takerTokenAmount.minus(takerTokenFillAmount),
+            expect(log.args.takerAssetFilledAmount).to.be.bignumber.equal(
+                signedOrder.takerAssetAmount.minus(takerAssetFillAmount),
             );
             const newBalances = await dmyBalances.getAsync();
 
             expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultMakerTokenAddress].minus(signedOrder.makerTokenAmount),
+                balances[makerAddress][defaultMakerTokenAddress].minus(signedOrder.makerAssetAmount),
             );
             expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultTakerTokenAddress].add(signedOrder.takerTokenAmount),
+                balances[makerAddress][defaultTakerTokenAddress].add(signedOrder.takerAssetAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(signedOrder.makerFee),
             );
             expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultTakerTokenAddress].minus(signedOrder.takerTokenAmount),
+                balances[takerAddress][defaultTakerTokenAddress].minus(signedOrder.takerAssetAmount),
             );
             expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultMakerTokenAddress].add(signedOrder.makerTokenAmount),
+                balances[takerAddress][defaultMakerTokenAddress].add(signedOrder.makerAssetAmount),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[takerAddress][zrx.address].minus(signedOrder.takerFee),
@@ -497,14 +497,14 @@ describe('Exchange', () => {
         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),
+                takerAssetFillAmount: signedOrder.takerAssetAmount.div(divisor),
             });
             expect(res.logs).to.have.length(1);
 
             const log = res.logs[0] as LogWithDecodedArgs<FillContractEventArgs>;
             const logArgs = log.args;
-            const expectedFilledMakerTokenAmount = signedOrder.makerTokenAmount.div(divisor);
-            const expectedFilledTakerTokenAmount = signedOrder.takerTokenAmount.div(divisor);
+            const expectedFilledMakerTokenAmount = signedOrder.makerAssetAmount.div(divisor);
+            const expectedFilledTakerTokenAmount = signedOrder.takerAssetAmount.div(divisor);
             const expectedFeeMPaid = signedOrder.makerFee.div(divisor);
             const expectedFeeTPaid = signedOrder.takerFee.div(divisor);
 
@@ -513,8 +513,8 @@ describe('Exchange', () => {
             expect(signedOrder.feeRecipientAddress).to.be.equal(logArgs.feeRecipientAddress);
             expect(signedOrder.makerAssetData).to.be.equal(logArgs.makerAssetData);
             expect(signedOrder.takerAssetData).to.be.equal(logArgs.takerAssetData);
-            expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerTokenFilledAmount);
-            expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerTokenFilledAmount);
+            expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerAssetFilledAmount);
+            expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerAssetFilledAmount);
             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);
@@ -526,14 +526,14 @@ describe('Exchange', () => {
             });
             const divisor = 2;
             const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount: signedOrder.takerTokenAmount.div(divisor),
+                takerAssetFillAmount: signedOrder.takerAssetAmount.div(divisor),
             });
             expect(res.logs).to.have.length(1);
 
             const log = res.logs[0] as LogWithDecodedArgs<FillContractEventArgs>;
             const logArgs = log.args;
-            const expectedFilledMakerTokenAmount = signedOrder.makerTokenAmount.div(divisor);
-            const expectedFilledTakerTokenAmount = signedOrder.takerTokenAmount.div(divisor);
+            const expectedFilledMakerTokenAmount = signedOrder.makerAssetAmount.div(divisor);
+            const expectedFilledTakerTokenAmount = signedOrder.takerAssetAmount.div(divisor);
             const expectedFeeMPaid = new BigNumber(0);
             const expectedFeeTPaid = new BigNumber(0);
 
@@ -542,8 +542,8 @@ describe('Exchange', () => {
             expect(signedOrder.feeRecipientAddress).to.be.equal(logArgs.feeRecipientAddress);
             expect(signedOrder.makerAssetData).to.be.equal(logArgs.makerAssetData);
             expect(signedOrder.takerAssetData).to.be.equal(logArgs.takerAssetData);
-            expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerTokenFilledAmount);
-            expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerTokenFilledAmount);
+            expect(expectedFilledMakerTokenAmount).to.be.bignumber.equal(logArgs.makerAssetFilledAmount);
+            expect(expectedFilledTakerTokenAmount).to.be.bignumber.equal(logArgs.takerAssetFilledAmount);
             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);
@@ -552,15 +552,15 @@ describe('Exchange', () => {
         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),
+                makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                takerAssetAmount: 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),
+                makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(10), 18),
             });
 
             const invalidR = ethUtil.sha3('invalidR');
@@ -572,35 +572,35 @@ describe('Exchange', () => {
             return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
         });
 
-        it('should throw if makerTokenAmount is 0', async () => {
+        it('should throw if makerAssetAmount is 0', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(0),
+                makerAssetAmount: new BigNumber(0),
             });
 
             return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
         });
 
-        it('should throw if takerTokenAmount is 0', async () => {
+        it('should throw if takerAssetAmount is 0', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                takerTokenAmount: new BigNumber(0),
+                takerAssetAmount: new BigNumber(0),
             });
 
             return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
         });
 
-        it('should throw if takerTokenFillAmount is 0', async () => {
+        it('should throw if takerAssetFillAmount is 0', async () => {
             signedOrder = orderFactory.newSignedOrder();
 
             return expect(
                 exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                    takerTokenFillAmount: new BigNumber(0),
+                    takerAssetFillAmount: 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),
+                makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18),
             });
 
             return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
@@ -608,7 +608,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),
+                takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18),
             });
 
             return expect(exWrapper.fillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
@@ -678,17 +678,17 @@ describe('Exchange', () => {
             return expect(exWrapper.cancelOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(constants.REVERT);
         });
 
-        it('should throw if makerTokenAmount is 0', async () => {
+        it('should throw if makerAssetAmount is 0', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(0),
+                makerAssetAmount: new BigNumber(0),
             });
 
             return expect(exWrapper.cancelOrderAsync(signedOrder, makerAddress)).to.be.rejectedWith(constants.REVERT);
         });
 
-        it('should throw if takerTokenAmount is 0', async () => {
+        it('should throw if takerAssetAmount is 0', async () => {
             signedOrder = orderFactory.newSignedOrder({
-                takerTokenAmount: new BigNumber(0),
+                takerAssetAmount: new BigNumber(0),
             });
 
             return expect(exWrapper.cancelOrderAsync(signedOrder, makerAddress)).to.be.rejectedWith(constants.REVERT);
@@ -697,7 +697,7 @@ describe('Exchange', () => {
         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),
+                takerAssetFillAmount: signedOrder.takerAssetAmount.div(2),
             });
 
             const newBalances = await dmyBalances.getAsync();
@@ -770,31 +770,31 @@ 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),
+                    makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(9), 18),
+                    takerAssetAmount: 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),
+                    makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(79), 18),
+                    takerAssetAmount: 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),
+                    makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(979), 18),
+                    takerAssetAmount: 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),
+                    makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(7979), 18),
+                    takerAssetAmount: 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 fillMakerTokenAmount = signedOrders[2].makerAssetAmount.add(signedOrders[3].makerAssetAmount);
+            const fillTakerTokenAmount = signedOrders[2].takerAssetAmount.add(signedOrders[3].takerAssetAmount);
             const makerFee = signedOrders[2].makerFee.add(signedOrders[3].makerFee);
             const takerFee = signedOrders[2].takerFee.add(signedOrders[3].takerFee);
             expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
@@ -824,165 +824,165 @@ describe('Exchange', () => {
     describe('Testing Exchange of ERC721 Tokens', () => {
         it('should successfully exchange a single token between the maker and taker (via fillOrder)', async () => {
             // Construct Exchange parameters
-            const makerTokenId = erc721MakerTokenIds[0];
-            const takerTokenId = erc721TakerTokenIds[1];
+            const makerAssetId = erc721MakerTokenIds[0];
+            const takerAssetId = erc721TakerTokenIds[1];
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(1),
-                takerTokenAmount: new BigNumber(1),
-                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId),
-                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId),
+                makerAssetAmount: new BigNumber(1),
+                takerAssetAmount: new BigNumber(1),
+                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId),
+                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId),
             });
             // Verify pre-conditions
-            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
-            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
+            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId);
             expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
             // Call Exchange
-            const takerTokenFillAmount = signedOrder.takerTokenAmount;
-            const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+            const takerAssetFillAmount = signedOrder.takerAssetAmount;
+            const res = await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
             // Verify post-conditions
-            const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress);
-            const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
+            const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId);
             expect(newOwnerTakerToken).to.be.bignumber.equal(makerAddress);
         });
 
-        it('should throw when maker does not own the token with id makerTokenId', async () => {
+        it('should throw when maker does not own the token with id makerAssetId', async () => {
             // Construct Exchange parameters
-            const makerTokenId = erc721TakerTokenIds[0];
-            const takerTokenId = erc721TakerTokenIds[1];
+            const makerAssetId = erc721TakerTokenIds[0];
+            const takerAssetId = erc721TakerTokenIds[1];
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(1),
-                takerTokenAmount: new BigNumber(1),
-                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId),
-                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId),
+                makerAssetAmount: new BigNumber(1),
+                takerAssetAmount: new BigNumber(1),
+                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId),
+                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId),
             });
             // Verify pre-conditions
-            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(initialOwnerMakerToken).to.be.bignumber.not.equal(makerAddress);
-            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
+            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId);
             expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
             // Call Exchange
-            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            const takerAssetFillAmount = signedOrder.takerAssetAmount;
             return expect(
-                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }),
+                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }),
             ).to.be.rejectedWith(constants.REVERT);
         });
 
-        it('should throw when taker does not own the token with id takerTokenId', async () => {
+        it('should throw when taker does not own the token with id takerAssetId', async () => {
             // Construct Exchange parameters
-            const makerTokenId = erc721MakerTokenIds[0];
-            const takerTokenId = erc721MakerTokenIds[1];
+            const makerAssetId = erc721MakerTokenIds[0];
+            const takerAssetId = erc721MakerTokenIds[1];
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(1),
-                takerTokenAmount: new BigNumber(1),
-                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId),
-                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId),
+                makerAssetAmount: new BigNumber(1),
+                takerAssetAmount: new BigNumber(1),
+                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId),
+                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId),
             });
             // Verify pre-conditions
-            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
-            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
+            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId);
             expect(initialOwnerTakerToken).to.be.bignumber.not.equal(takerAddress);
             // Call Exchange
-            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            const takerAssetFillAmount = signedOrder.takerAssetAmount;
             return expect(
-                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }),
+                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }),
             ).to.be.rejectedWith(constants.REVERT);
         });
 
-        it('should throw when makerTokenAmount is greater than 1', async () => {
+        it('should throw when makerAssetAmount is greater than 1', async () => {
             // Construct Exchange parameters
-            const makerTokenId = erc721MakerTokenIds[0];
-            const takerTokenId = erc721TakerTokenIds[0];
+            const makerAssetId = erc721MakerTokenIds[0];
+            const takerAssetId = erc721TakerTokenIds[0];
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(2),
-                takerTokenAmount: new BigNumber(1),
-                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId),
-                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId),
+                makerAssetAmount: new BigNumber(2),
+                takerAssetAmount: new BigNumber(1),
+                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId),
+                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId),
             });
             // Verify pre-conditions
-            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
-            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
+            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId);
             expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
             // Call Exchange
-            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            const takerAssetFillAmount = signedOrder.takerAssetAmount;
             return expect(
-                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }),
+                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }),
             ).to.be.rejectedWith(constants.REVERT);
         });
 
-        it('should throw when takerTokenAmount is greater than 1', async () => {
+        it('should throw when takerAssetAmount is greater than 1', async () => {
             // Construct Exchange parameters
-            const makerTokenId = erc721MakerTokenIds[0];
-            const takerTokenId = erc721TakerTokenIds[0];
+            const makerAssetId = erc721MakerTokenIds[0];
+            const takerAssetId = erc721TakerTokenIds[0];
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(1),
-                takerTokenAmount: new BigNumber(500),
-                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId),
-                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId),
+                makerAssetAmount: new BigNumber(1),
+                takerAssetAmount: new BigNumber(500),
+                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId),
+                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId),
             });
             // Verify pre-conditions
-            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
-            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
+            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId);
             expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
             // Call Exchange
-            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            const takerAssetFillAmount = signedOrder.takerAssetAmount;
             return expect(
-                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }),
+                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }),
             ).to.be.rejectedWith(constants.REVERT);
         });
 
         it('should throw on partial fill', async () => {
             // Construct Exchange parameters
-            const makerTokenId = erc721MakerTokenIds[0];
-            const takerTokenId = erc721TakerTokenIds[0];
+            const makerAssetId = erc721MakerTokenIds[0];
+            const takerAssetId = erc721TakerTokenIds[0];
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(1),
-                takerTokenAmount: new BigNumber(0),
-                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId),
-                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId),
+                makerAssetAmount: new BigNumber(1),
+                takerAssetAmount: new BigNumber(0),
+                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId),
+                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId),
             });
             // Verify pre-conditions
-            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
-            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
+            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId);
             expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
             // Call Exchange
-            const takerTokenFillAmount = signedOrder.takerTokenAmount;
+            const takerAssetFillAmount = signedOrder.takerAssetAmount;
             return expect(
-                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount }),
+                exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }),
             ).to.be.rejectedWith(constants.REVERT);
         });
 
-        it('should successfully fill order when makerToken is ERC721 and takerToken is ERC20', async () => {
+        it('should successfully fill order when makerAsset is ERC721 and takerAsset is ERC20', async () => {
             // Construct Exchange parameters
-            const makerTokenId = erc721MakerTokenIds[0];
+            const makerAssetId = erc721MakerTokenIds[0];
             signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(1),
-                takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId),
+                makerAssetAmount: new BigNumber(1),
+                takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId),
                 takerAssetData: proxyUtils.encodeERC20ProxyData(defaultTakerTokenAddress),
             });
             // Verify pre-conditions
-            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
             // Call Exchange
             balances = await dmyBalances.getAsync();
-            const takerTokenFillAmount = signedOrder.takerTokenAmount;
-            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+            const takerAssetFillAmount = signedOrder.takerAssetAmount;
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
             // Verify ERC721 token was transferred from Maker to Taker
-            const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress);
             // Verify ERC20 tokens were transferred from Taker to Maker & fees were paid correctly
             const newBalances = await dmyBalances.getAsync();
             expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount),
             );
             expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(signedOrder.makerFee),
@@ -995,32 +995,32 @@ describe('Exchange', () => {
             );
         });
 
-        it('should successfully fill order when makerToken is ERC20 and takerToken is ERC721', async () => {
+        it('should successfully fill order when makerAsset is ERC20 and takerAsset is ERC721', async () => {
             // Construct Exchange parameters
-            const takerTokenId = erc721TakerTokenIds[0];
+            const takerAssetId = erc721TakerTokenIds[0];
             signedOrder = orderFactory.newSignedOrder({
-                takerTokenAmount: new BigNumber(1),
-                makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId),
+                takerAssetAmount: new BigNumber(1),
+                makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId),
                 makerAssetData: proxyUtils.encodeERC20ProxyData(defaultMakerTokenAddress),
             });
             // Verify pre-conditions
-            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
+            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId);
             expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
             // Call Exchange
             balances = await dmyBalances.getAsync();
-            const takerTokenFillAmount = signedOrder.takerTokenAmount;
-            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+            const takerAssetFillAmount = signedOrder.takerAssetAmount;
+            await exWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
             // Verify ERC721 token was transferred from Taker to Maker
-            const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
+            const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId);
             expect(newOwnerTakerToken).to.be.bignumber.equal(makerAddress);
             // Verify ERC20 tokens were transferred from Maker to Taker & fees were paid correctly
             const newBalances = await dmyBalances.getAsync();
             expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultMakerTokenAddress].add(signedOrder.makerTokenAmount),
+                balances[takerAddress][defaultMakerTokenAddress].add(signedOrder.makerAssetAmount),
             );
             expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultMakerTokenAddress].minus(signedOrder.makerTokenAmount),
+                balances[makerAddress][defaultMakerTokenAddress].minus(signedOrder.makerAssetAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(signedOrder.makerFee),
diff --git a/packages/contracts/test/exchange/helpers.ts b/packages/contracts/test/exchange/helpers.ts
index f758de1c9..dada8920b 100644
--- a/packages/contracts/test/exchange/helpers.ts
+++ b/packages/contracts/test/exchange/helpers.ts
@@ -54,8 +54,8 @@ describe('Exchange', () => {
             exchangeAddress: exchange.address,
             makerAddress,
             feeRecipientAddress,
-            makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-            takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+            makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+            takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             makerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
             takerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
             makerAssetData: proxyUtils.encodeERC20ProxyData(rep.address),
diff --git a/packages/contracts/test/exchange/wrapper.ts b/packages/contracts/test/exchange/wrapper.ts
index e6e2d7060..9c16697bc 100644
--- a/packages/contracts/test/exchange/wrapper.ts
+++ b/packages/contracts/test/exchange/wrapper.ts
@@ -125,8 +125,8 @@ describe('Exchange', () => {
             exchangeAddress: exchange.address,
             makerAddress,
             feeRecipientAddress,
-            makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
-            takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
+            makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+            takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             makerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
             takerFee: ZeroEx.toBaseUnitAmount(new BigNumber(1), 18),
             makerAssetData: proxyUtils.encodeERC20ProxyData(defaultMakerTokenAddress),
@@ -169,39 +169,39 @@ 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),
+                makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             });
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
+            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
             await exWrapper.fillOrKillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount,
+                takerAssetFillAmount,
             });
 
             const newBalances = await dmyBalances.getAsync();
 
-            const makerTokenFilledAmount = takerTokenFillAmount
-                .times(signedOrder.makerTokenAmount)
-                .dividedToIntegerBy(signedOrder.takerTokenAmount);
+            const makerAssetFilledAmount = takerAssetFillAmount
+                .times(signedOrder.makerAssetAmount)
+                .dividedToIntegerBy(signedOrder.takerAssetAmount);
             const makerFee = signedOrder.makerFee
-                .times(makerTokenFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                .times(makerAssetFilledAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount);
             const takerFee = signedOrder.takerFee
-                .times(makerTokenFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                .times(makerAssetFilledAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount);
             expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount),
+                balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount),
             );
             expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(makerFee),
             );
             expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount),
             );
             expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount),
+                balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[takerAddress][zrx.address].minus(takerFee),
@@ -221,11 +221,11 @@ describe('Exchange', () => {
             );
         });
 
-        it('should throw if entire takerTokenFillAmount not filled', async () => {
+        it('should throw if entire takerAssetFillAmount not filled', async () => {
             const signedOrder = orderFactory.newSignedOrder();
 
             await exWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount: signedOrder.takerTokenAmount.div(2),
+                takerAssetFillAmount: signedOrder.takerAssetAmount.div(2),
             });
 
             return expect(exWrapper.fillOrKillOrderAsync(signedOrder, takerAddress)).to.be.rejectedWith(
@@ -237,39 +237,39 @@ 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),
+                makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100), 18),
+                takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(200), 18),
             });
-            const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
+            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress, {
-                takerTokenFillAmount,
+                takerAssetFillAmount,
             });
 
             const newBalances = await dmyBalances.getAsync();
 
-            const makerTokenFilledAmount = takerTokenFillAmount
-                .times(signedOrder.makerTokenAmount)
-                .dividedToIntegerBy(signedOrder.takerTokenAmount);
+            const makerAssetFilledAmount = takerAssetFillAmount
+                .times(signedOrder.makerAssetAmount)
+                .dividedToIntegerBy(signedOrder.takerAssetAmount);
             const makerFee = signedOrder.makerFee
-                .times(makerTokenFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                .times(makerAssetFilledAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount);
             const takerFee = signedOrder.takerFee
-                .times(makerTokenFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                .times(makerAssetFilledAmount)
+                .dividedToIntegerBy(signedOrder.makerAssetAmount);
             expect(newBalances[makerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount),
+                balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount),
             );
             expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount),
+                balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount),
             );
             expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[makerAddress][zrx.address].minus(makerFee),
             );
             expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount),
+                balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount),
             );
             expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount),
+                balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount),
             );
             expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                 balances[takerAddress][zrx.address].minus(takerFee),
@@ -281,7 +281,7 @@ describe('Exchange', () => {
 
         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),
+                makerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18),
             });
 
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
@@ -291,7 +291,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),
+                takerAssetAmount: ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18),
             });
 
             await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress);
@@ -327,10 +327,10 @@ 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 makerAssetAddress is ZRX, makerAssetAmount + makerFee > maker balance', async () => {
             const makerZRXBalance = new BigNumber(balances[makerAddress][zrx.address]);
             const signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: makerZRXBalance,
+                makerAssetAmount: makerZRXBalance,
                 makerFee: new BigNumber(1),
                 makerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address),
             });
@@ -339,10 +339,10 @@ describe('Exchange', () => {
             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 makerAssetAddress is ZRX, makerAssetAmount + makerFee > maker allowance', async () => {
             const makerZRXAllowance = await zrx.allowance.callAsync(makerAddress, erc20Proxy.address);
             const signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(makerZRXAllowance),
+                makerAssetAmount: new BigNumber(makerZRXAllowance),
                 makerFee: new BigNumber(1),
                 makerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address),
             });
@@ -351,10 +351,10 @@ describe('Exchange', () => {
             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 takerAssetAddress is ZRX, takerAssetAmount + takerFee > taker balance', async () => {
             const takerZRXBalance = new BigNumber(balances[takerAddress][zrx.address]);
             const signedOrder = orderFactory.newSignedOrder({
-                takerTokenAmount: takerZRXBalance,
+                takerAssetAmount: takerZRXBalance,
                 takerFee: new BigNumber(1),
                 takerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address),
             });
@@ -363,10 +363,10 @@ describe('Exchange', () => {
             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 takerAssetAddress is ZRX, takerAssetAmount + takerFee > taker allowance', async () => {
             const takerZRXAllowance = await zrx.allowance.callAsync(takerAddress, erc20Proxy.address);
             const signedOrder = orderFactory.newSignedOrder({
-                takerTokenAmount: new BigNumber(takerZRXAllowance),
+                takerAssetAmount: new BigNumber(takerZRXAllowance),
                 takerFee: new BigNumber(1),
                 takerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address),
             });
@@ -377,26 +377,26 @@ describe('Exchange', () => {
 
         it('should successfully exchange ERC721 tokens', async () => {
             // Construct Exchange parameters
-            const makerTokenId = erc721MakerTokenId;
-            const takerTokenId = erc721TakerTokenId;
+            const makerAssetId = erc721MakerTokenId;
+            const takerAssetId = erc721TakerTokenId;
             const signedOrder = orderFactory.newSignedOrder({
-                makerTokenAmount: new BigNumber(1),
-                takerTokenAmount: new BigNumber(1),
-                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerTokenId),
-                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerTokenId),
+                makerAssetAmount: new BigNumber(1),
+                takerAssetAmount: new BigNumber(1),
+                makerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, makerAssetId),
+                takerAssetData: proxyUtils.encodeERC721ProxyData(erc721Token.address, takerAssetId),
             });
             // Verify pre-conditions
-            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const initialOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(initialOwnerMakerToken).to.be.bignumber.equal(makerAddress);
-            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
+            const initialOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId);
             expect(initialOwnerTakerToken).to.be.bignumber.equal(takerAddress);
             // Call Exchange
-            const takerTokenFillAmount = signedOrder.takerTokenAmount;
-            await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress, { takerTokenFillAmount });
+            const takerAssetFillAmount = signedOrder.takerAssetAmount;
+            await exWrapper.fillOrderNoThrowAsync(signedOrder, takerAddress, { takerAssetFillAmount });
             // Verify post-conditions
-            const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerTokenId);
+            const newOwnerMakerToken = await erc721Token.ownerOf.callAsync(makerAssetId);
             expect(newOwnerMakerToken).to.be.bignumber.equal(takerAddress);
-            const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerTokenId);
+            const newOwnerTakerToken = await erc721Token.ownerOf.callAsync(takerAssetId);
             expect(newOwnerTakerToken).to.be.bignumber.equal(makerAddress);
         });
     });
@@ -413,33 +413,33 @@ describe('Exchange', () => {
 
         describe('batchFillOrders', () => {
             it('should transfer the correct amounts', async () => {
-                const takerTokenFillAmounts: BigNumber[] = [];
-                const makerTokenAddress = rep.address;
-                const takerTokenAddress = dgd.address;
+                const takerAssetFillAmounts: BigNumber[] = [];
+                const makerAssetAddress = rep.address;
+                const takerAssetAddress = dgd.address;
                 _.forEach(signedOrders, signedOrder => {
-                    const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-                    const makerTokenFilledAmount = takerTokenFillAmount
-                        .times(signedOrder.makerTokenAmount)
-                        .dividedToIntegerBy(signedOrder.takerTokenAmount);
+                    const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+                    const makerAssetFilledAmount = takerAssetFillAmount
+                        .times(signedOrder.makerAssetAmount)
+                        .dividedToIntegerBy(signedOrder.takerAssetAmount);
                     const makerFee = signedOrder.makerFee
-                        .times(makerTokenFilledAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                        .times(makerAssetFilledAmount)
+                        .dividedToIntegerBy(signedOrder.makerAssetAmount);
                     const takerFee = signedOrder.takerFee
-                        .times(makerTokenFilledAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
-                    takerTokenFillAmounts.push(takerTokenFillAmount);
-                    balances[makerAddress][makerTokenAddress] = balances[makerAddress][makerTokenAddress].minus(
-                        makerTokenFilledAmount,
+                        .times(makerAssetFilledAmount)
+                        .dividedToIntegerBy(signedOrder.makerAssetAmount);
+                    takerAssetFillAmounts.push(takerAssetFillAmount);
+                    balances[makerAddress][makerAssetAddress] = balances[makerAddress][makerAssetAddress].minus(
+                        makerAssetFilledAmount,
                     );
-                    balances[makerAddress][takerTokenAddress] = balances[makerAddress][takerTokenAddress].add(
-                        takerTokenFillAmount,
+                    balances[makerAddress][takerAssetAddress] = balances[makerAddress][takerAssetAddress].add(
+                        takerAssetFillAmount,
                     );
                     balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFee);
-                    balances[takerAddress][makerTokenAddress] = balances[takerAddress][makerTokenAddress].add(
-                        makerTokenFilledAmount,
+                    balances[takerAddress][makerAssetAddress] = balances[takerAddress][makerAssetAddress].add(
+                        makerAssetFilledAmount,
                     );
-                    balances[takerAddress][takerTokenAddress] = balances[takerAddress][takerTokenAddress].minus(
-                        takerTokenFillAmount,
+                    balances[takerAddress][takerAssetAddress] = balances[takerAddress][takerAssetAddress].minus(
+                        takerAssetFillAmount,
                     );
                     balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFee);
                     balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add(
@@ -448,7 +448,7 @@ describe('Exchange', () => {
                 });
 
                 await exWrapper.batchFillOrdersAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmounts,
+                    takerAssetFillAmounts,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
@@ -458,33 +458,33 @@ describe('Exchange', () => {
 
         describe('batchFillOrKillOrders', () => {
             it('should transfer the correct amounts', async () => {
-                const takerTokenFillAmounts: BigNumber[] = [];
-                const makerTokenAddress = rep.address;
-                const takerTokenAddress = dgd.address;
+                const takerAssetFillAmounts: BigNumber[] = [];
+                const makerAssetAddress = rep.address;
+                const takerAssetAddress = dgd.address;
                 _.forEach(signedOrders, signedOrder => {
-                    const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-                    const makerTokenFilledAmount = takerTokenFillAmount
-                        .times(signedOrder.makerTokenAmount)
-                        .dividedToIntegerBy(signedOrder.takerTokenAmount);
+                    const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+                    const makerAssetFilledAmount = takerAssetFillAmount
+                        .times(signedOrder.makerAssetAmount)
+                        .dividedToIntegerBy(signedOrder.takerAssetAmount);
                     const makerFee = signedOrder.makerFee
-                        .times(makerTokenFilledAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                        .times(makerAssetFilledAmount)
+                        .dividedToIntegerBy(signedOrder.makerAssetAmount);
                     const takerFee = signedOrder.takerFee
-                        .times(makerTokenFilledAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
-                    takerTokenFillAmounts.push(takerTokenFillAmount);
-                    balances[makerAddress][makerTokenAddress] = balances[makerAddress][makerTokenAddress].minus(
-                        makerTokenFilledAmount,
+                        .times(makerAssetFilledAmount)
+                        .dividedToIntegerBy(signedOrder.makerAssetAmount);
+                    takerAssetFillAmounts.push(takerAssetFillAmount);
+                    balances[makerAddress][makerAssetAddress] = balances[makerAddress][makerAssetAddress].minus(
+                        makerAssetFilledAmount,
                     );
-                    balances[makerAddress][takerTokenAddress] = balances[makerAddress][takerTokenAddress].add(
-                        takerTokenFillAmount,
+                    balances[makerAddress][takerAssetAddress] = balances[makerAddress][takerAssetAddress].add(
+                        takerAssetFillAmount,
                     );
                     balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFee);
-                    balances[takerAddress][makerTokenAddress] = balances[takerAddress][makerTokenAddress].add(
-                        makerTokenFilledAmount,
+                    balances[takerAddress][makerAssetAddress] = balances[takerAddress][makerAssetAddress].add(
+                        makerAssetFilledAmount,
                     );
-                    balances[takerAddress][takerTokenAddress] = balances[takerAddress][takerTokenAddress].minus(
-                        takerTokenFillAmount,
+                    balances[takerAddress][takerAssetAddress] = balances[takerAddress][takerAssetAddress].minus(
+                        takerAssetFillAmount,
                     );
                     balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFee);
                     balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add(
@@ -493,7 +493,7 @@ describe('Exchange', () => {
                 });
 
                 await exWrapper.batchFillOrKillOrdersAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmounts,
+                    takerAssetFillAmounts,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
@@ -501,17 +501,17 @@ describe('Exchange', () => {
             });
 
             it('should throw if a single signedOrder does not fill the expected amount', async () => {
-                const takerTokenFillAmounts: BigNumber[] = [];
+                const takerAssetFillAmounts: BigNumber[] = [];
                 _.forEach(signedOrders, signedOrder => {
-                    const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-                    takerTokenFillAmounts.push(takerTokenFillAmount);
+                    const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+                    takerAssetFillAmounts.push(takerAssetFillAmount);
                 });
 
                 await exWrapper.fillOrKillOrderAsync(signedOrders[0], takerAddress);
 
                 return expect(
                     exWrapper.batchFillOrKillOrdersAsync(signedOrders, takerAddress, {
-                        takerTokenFillAmounts,
+                        takerAssetFillAmounts,
                     }),
                 ).to.be.rejectedWith(constants.REVERT);
             });
@@ -519,33 +519,33 @@ describe('Exchange', () => {
 
         describe('batchFillOrdersNoThrow', async () => {
             it('should transfer the correct amounts', async () => {
-                const takerTokenFillAmounts: BigNumber[] = [];
-                const makerTokenAddress = rep.address;
-                const takerTokenAddress = dgd.address;
+                const takerAssetFillAmounts: BigNumber[] = [];
+                const makerAssetAddress = rep.address;
+                const takerAssetAddress = dgd.address;
                 _.forEach(signedOrders, signedOrder => {
-                    const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-                    const makerTokenFilledAmount = takerTokenFillAmount
-                        .times(signedOrder.makerTokenAmount)
-                        .dividedToIntegerBy(signedOrder.takerTokenAmount);
+                    const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+                    const makerAssetFilledAmount = takerAssetFillAmount
+                        .times(signedOrder.makerAssetAmount)
+                        .dividedToIntegerBy(signedOrder.takerAssetAmount);
                     const makerFee = signedOrder.makerFee
-                        .times(makerTokenFilledAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                        .times(makerAssetFilledAmount)
+                        .dividedToIntegerBy(signedOrder.makerAssetAmount);
                     const takerFee = signedOrder.takerFee
-                        .times(makerTokenFilledAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
-                    takerTokenFillAmounts.push(takerTokenFillAmount);
-                    balances[makerAddress][makerTokenAddress] = balances[makerAddress][makerTokenAddress].minus(
-                        makerTokenFilledAmount,
+                        .times(makerAssetFilledAmount)
+                        .dividedToIntegerBy(signedOrder.makerAssetAmount);
+                    takerAssetFillAmounts.push(takerAssetFillAmount);
+                    balances[makerAddress][makerAssetAddress] = balances[makerAddress][makerAssetAddress].minus(
+                        makerAssetFilledAmount,
                     );
-                    balances[makerAddress][takerTokenAddress] = balances[makerAddress][takerTokenAddress].add(
-                        takerTokenFillAmount,
+                    balances[makerAddress][takerAssetAddress] = balances[makerAddress][takerAssetAddress].add(
+                        takerAssetFillAmount,
                     );
                     balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFee);
-                    balances[takerAddress][makerTokenAddress] = balances[takerAddress][makerTokenAddress].add(
-                        makerTokenFilledAmount,
+                    balances[takerAddress][makerAssetAddress] = balances[takerAddress][makerAssetAddress].add(
+                        makerAssetFilledAmount,
                     );
-                    balances[takerAddress][takerTokenAddress] = balances[takerAddress][takerTokenAddress].minus(
-                        takerTokenFillAmount,
+                    balances[takerAddress][takerAssetAddress] = balances[takerAddress][takerAssetAddress].minus(
+                        takerAssetFillAmount,
                     );
                     balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFee);
                     balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add(
@@ -554,7 +554,7 @@ describe('Exchange', () => {
                 });
 
                 await exWrapper.batchFillOrdersNoThrowAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmounts,
+                    takerAssetFillAmounts,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
@@ -562,9 +562,9 @@ describe('Exchange', () => {
             });
 
             it('should not throw if an order is invalid and fill the remaining orders', async () => {
-                const takerTokenFillAmounts: BigNumber[] = [];
-                const makerTokenAddress = rep.address;
-                const takerTokenAddress = dgd.address;
+                const takerAssetFillAmounts: BigNumber[] = [];
+                const makerAssetAddress = rep.address;
+                const takerAssetAddress = dgd.address;
 
                 const invalidOrder = {
                     ...signedOrders[0],
@@ -572,31 +572,31 @@ describe('Exchange', () => {
                 };
                 const validOrders = signedOrders.slice(1);
 
-                takerTokenFillAmounts.push(invalidOrder.takerTokenAmount.div(2));
+                takerAssetFillAmounts.push(invalidOrder.takerAssetAmount.div(2));
                 _.forEach(validOrders, signedOrder => {
-                    const takerTokenFillAmount = signedOrder.takerTokenAmount.div(2);
-                    const makerTokenFilledAmount = takerTokenFillAmount
-                        .times(signedOrder.makerTokenAmount)
-                        .dividedToIntegerBy(signedOrder.takerTokenAmount);
+                    const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
+                    const makerAssetFilledAmount = takerAssetFillAmount
+                        .times(signedOrder.makerAssetAmount)
+                        .dividedToIntegerBy(signedOrder.takerAssetAmount);
                     const makerFee = signedOrder.makerFee
-                        .times(makerTokenFilledAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
+                        .times(makerAssetFilledAmount)
+                        .dividedToIntegerBy(signedOrder.makerAssetAmount);
                     const takerFee = signedOrder.takerFee
-                        .times(makerTokenFilledAmount)
-                        .dividedToIntegerBy(signedOrder.makerTokenAmount);
-                    takerTokenFillAmounts.push(takerTokenFillAmount);
-                    balances[makerAddress][makerTokenAddress] = balances[makerAddress][makerTokenAddress].minus(
-                        makerTokenFilledAmount,
+                        .times(makerAssetFilledAmount)
+                        .dividedToIntegerBy(signedOrder.makerAssetAmount);
+                    takerAssetFillAmounts.push(takerAssetFillAmount);
+                    balances[makerAddress][makerAssetAddress] = balances[makerAddress][makerAssetAddress].minus(
+                        makerAssetFilledAmount,
                     );
-                    balances[makerAddress][takerTokenAddress] = balances[makerAddress][takerTokenAddress].add(
-                        takerTokenFillAmount,
+                    balances[makerAddress][takerAssetAddress] = balances[makerAddress][takerAssetAddress].add(
+                        takerAssetFillAmount,
                     );
                     balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(makerFee);
-                    balances[takerAddress][makerTokenAddress] = balances[takerAddress][makerTokenAddress].add(
-                        makerTokenFilledAmount,
+                    balances[takerAddress][makerAssetAddress] = balances[takerAddress][makerAssetAddress].add(
+                        makerAssetFilledAmount,
                     );
-                    balances[takerAddress][takerTokenAddress] = balances[takerAddress][takerTokenAddress].minus(
-                        takerTokenFillAmount,
+                    balances[takerAddress][takerAssetAddress] = balances[takerAddress][takerAssetAddress].minus(
+                        takerAssetFillAmount,
                     );
                     balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(takerFee);
                     balances[feeRecipientAddress][zrx.address] = balances[feeRecipientAddress][zrx.address].add(
@@ -606,7 +606,7 @@ describe('Exchange', () => {
 
                 const newOrders = [invalidOrder, ...validOrders];
                 await exWrapper.batchFillOrdersNoThrowAsync(newOrders, takerAddress, {
-                    takerTokenFillAmounts,
+                    takerAssetFillAmounts,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
@@ -615,35 +615,35 @@ describe('Exchange', () => {
         });
 
         describe('marketSellOrders', () => {
-            it('should stop when the entire takerTokenFillAmount is filled', async () => {
-                const takerTokenFillAmount = signedOrders[0].takerTokenAmount.plus(
-                    signedOrders[1].takerTokenAmount.div(2),
+            it('should stop when the entire takerAssetFillAmount is filled', async () => {
+                const takerAssetFillAmount = signedOrders[0].takerAssetAmount.plus(
+                    signedOrders[1].takerAssetAmount.div(2),
                 );
                 await exWrapper.marketSellOrdersAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmount,
+                    takerAssetFillAmount,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
 
-                const makerTokenFilledAmount = signedOrders[0].makerTokenAmount.add(
-                    signedOrders[1].makerTokenAmount.dividedToIntegerBy(2),
+                const makerAssetFilledAmount = signedOrders[0].makerAssetAmount.add(
+                    signedOrders[1].makerAssetAmount.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][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                    balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount),
+                    balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount),
                 );
                 expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                    balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount),
+                    balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount),
                 );
                 expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                     balances[makerAddress][zrx.address].minus(makerFee),
                 );
                 expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                    balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount),
+                    balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount),
                 );
                 expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                    balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount),
+                    balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount),
                 );
                 expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                     balances[takerAddress][zrx.address].minus(takerFee),
@@ -653,24 +653,24 @@ 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 takerAssetFillAmount', async () => {
+                const takerAssetFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18);
                 _.forEach(signedOrders, signedOrder => {
                     balances[makerAddress][defaultMakerTokenAddress] = balances[makerAddress][
                         defaultMakerTokenAddress
-                    ].minus(signedOrder.makerTokenAmount);
+                    ].minus(signedOrder.makerAssetAmount);
                     balances[makerAddress][defaultTakerTokenAddress] = balances[makerAddress][
                         defaultTakerTokenAddress
-                    ].add(signedOrder.takerTokenAmount);
+                    ].add(signedOrder.takerAssetAmount);
                     balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(
                         signedOrder.makerFee,
                     );
                     balances[takerAddress][defaultMakerTokenAddress] = balances[takerAddress][
                         defaultMakerTokenAddress
-                    ].add(signedOrder.makerTokenAmount);
+                    ].add(signedOrder.makerAssetAmount);
                     balances[takerAddress][defaultTakerTokenAddress] = balances[takerAddress][
                         defaultTakerTokenAddress
-                    ].minus(signedOrder.takerTokenAmount);
+                    ].minus(signedOrder.takerAssetAmount);
                     balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(
                         signedOrder.takerFee,
                     );
@@ -679,14 +679,14 @@ describe('Exchange', () => {
                     );
                 });
                 await exWrapper.marketSellOrdersAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmount,
+                    takerAssetFillAmount,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
                 expect(newBalances).to.be.deep.equal(balances);
             });
 
-            it('should throw when an signedOrder does not use the same takerTokenAddress', async () => {
+            it('should throw when an signedOrder does not use the same takerAssetAddress', async () => {
                 signedOrders = [
                     orderFactory.newSignedOrder(),
                     orderFactory.newSignedOrder({ takerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address) }),
@@ -695,42 +695,42 @@ describe('Exchange', () => {
 
                 return expect(
                     exWrapper.marketSellOrdersAsync(signedOrders, takerAddress, {
-                        takerTokenFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18),
+                        takerAssetFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18),
                     }),
                 ).to.be.rejectedWith(constants.REVERT);
             });
         });
 
         describe('marketSellOrdersNoThrow', () => {
-            it('should stop when the entire takerTokenFillAmount is filled', async () => {
-                const takerTokenFillAmount = signedOrders[0].takerTokenAmount.plus(
-                    signedOrders[1].takerTokenAmount.div(2),
+            it('should stop when the entire takerAssetFillAmount is filled', async () => {
+                const takerAssetFillAmount = signedOrders[0].takerAssetAmount.plus(
+                    signedOrders[1].takerAssetAmount.div(2),
                 );
                 await exWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmount,
+                    takerAssetFillAmount,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
 
-                const makerTokenFilledAmount = signedOrders[0].makerTokenAmount.add(
-                    signedOrders[1].makerTokenAmount.dividedToIntegerBy(2),
+                const makerAssetFilledAmount = signedOrders[0].makerAssetAmount.add(
+                    signedOrders[1].makerAssetAmount.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][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                    balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFilledAmount),
+                    balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFilledAmount),
                 );
                 expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                    balances[makerAddress][defaultTakerTokenAddress].add(takerTokenFillAmount),
+                    balances[makerAddress][defaultTakerTokenAddress].add(takerAssetFillAmount),
                 );
                 expect(newBalances[makerAddress][zrx.address]).to.be.bignumber.equal(
                     balances[makerAddress][zrx.address].minus(makerFee),
                 );
                 expect(newBalances[takerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
-                    balances[takerAddress][defaultTakerTokenAddress].minus(takerTokenFillAmount),
+                    balances[takerAddress][defaultTakerTokenAddress].minus(takerAssetFillAmount),
                 );
                 expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                    balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFilledAmount),
+                    balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFilledAmount),
                 );
                 expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                     balances[takerAddress][zrx.address].minus(takerFee),
@@ -740,24 +740,24 @@ 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 takerAssetFillAmount', async () => {
+                const takerAssetFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18);
                 _.forEach(signedOrders, signedOrder => {
                     balances[makerAddress][defaultMakerTokenAddress] = balances[makerAddress][
                         defaultMakerTokenAddress
-                    ].minus(signedOrder.makerTokenAmount);
+                    ].minus(signedOrder.makerAssetAmount);
                     balances[makerAddress][defaultTakerTokenAddress] = balances[makerAddress][
                         defaultTakerTokenAddress
-                    ].add(signedOrder.takerTokenAmount);
+                    ].add(signedOrder.takerAssetAmount);
                     balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(
                         signedOrder.makerFee,
                     );
                     balances[takerAddress][defaultMakerTokenAddress] = balances[takerAddress][
                         defaultMakerTokenAddress
-                    ].add(signedOrder.makerTokenAmount);
+                    ].add(signedOrder.makerAssetAmount);
                     balances[takerAddress][defaultTakerTokenAddress] = balances[takerAddress][
                         defaultTakerTokenAddress
-                    ].minus(signedOrder.takerTokenAmount);
+                    ].minus(signedOrder.takerAssetAmount);
                     balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(
                         signedOrder.takerFee,
                     );
@@ -766,14 +766,14 @@ describe('Exchange', () => {
                     );
                 });
                 await exWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmount,
+                    takerAssetFillAmount,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
                 expect(newBalances).to.be.deep.equal(balances);
             });
 
-            it('should throw when a signedOrder does not use the same takerTokenAddress', async () => {
+            it('should throw when a signedOrder does not use the same takerAssetAddress', async () => {
                 signedOrders = [
                     orderFactory.newSignedOrder(),
                     orderFactory.newSignedOrder({ takerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address) }),
@@ -782,30 +782,30 @@ describe('Exchange', () => {
 
                 return expect(
                     exWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, {
-                        takerTokenFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18),
+                        takerAssetFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18),
                     }),
                 ).to.be.rejectedWith(constants.REVERT);
             });
         });
 
         describe('marketBuyOrders', () => {
-            it('should stop when the entire makerTokenFillAmount is filled', async () => {
-                const makerTokenFillAmount = signedOrders[0].makerTokenAmount.plus(
-                    signedOrders[1].makerTokenAmount.div(2),
+            it('should stop when the entire makerAssetFillAmount is filled', async () => {
+                const makerAssetFillAmount = signedOrders[0].makerAssetAmount.plus(
+                    signedOrders[1].makerAssetAmount.div(2),
                 );
                 await exWrapper.marketBuyOrdersAsync(signedOrders, takerAddress, {
-                    makerTokenFillAmount,
+                    makerAssetFillAmount,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
 
-                const makerAmountBought = signedOrders[0].takerTokenAmount.add(
-                    signedOrders[1].takerTokenAmount.dividedToIntegerBy(2),
+                const makerAmountBought = signedOrders[0].takerAssetAmount.add(
+                    signedOrders[1].takerAssetAmount.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][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                    balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFillAmount),
+                    balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFillAmount),
                 );
                 expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
                     balances[makerAddress][defaultTakerTokenAddress].add(makerAmountBought),
@@ -817,7 +817,7 @@ describe('Exchange', () => {
                     balances[takerAddress][defaultTakerTokenAddress].minus(makerAmountBought),
                 );
                 expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                    balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFillAmount),
+                    balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFillAmount),
                 );
                 expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                     balances[takerAddress][zrx.address].minus(takerFee),
@@ -827,24 +827,24 @@ describe('Exchange', () => {
                 );
             });
 
-            it('should fill all signedOrders if cannot fill entire makerTokenFillAmount', async () => {
-                const makerTokenFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18);
+            it('should fill all signedOrders if cannot fill entire makerAssetFillAmount', async () => {
+                const makerAssetFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18);
                 _.forEach(signedOrders, signedOrder => {
                     balances[makerAddress][defaultMakerTokenAddress] = balances[makerAddress][
                         defaultMakerTokenAddress
-                    ].minus(signedOrder.makerTokenAmount);
+                    ].minus(signedOrder.makerAssetAmount);
                     balances[makerAddress][defaultTakerTokenAddress] = balances[makerAddress][
                         defaultTakerTokenAddress
-                    ].add(signedOrder.takerTokenAmount);
+                    ].add(signedOrder.takerAssetAmount);
                     balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(
                         signedOrder.makerFee,
                     );
                     balances[takerAddress][defaultMakerTokenAddress] = balances[takerAddress][
                         defaultMakerTokenAddress
-                    ].add(signedOrder.makerTokenAmount);
+                    ].add(signedOrder.makerAssetAmount);
                     balances[takerAddress][defaultTakerTokenAddress] = balances[takerAddress][
                         defaultTakerTokenAddress
-                    ].minus(signedOrder.takerTokenAmount);
+                    ].minus(signedOrder.takerAssetAmount);
                     balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(
                         signedOrder.takerFee,
                     );
@@ -853,14 +853,14 @@ describe('Exchange', () => {
                     );
                 });
                 await exWrapper.marketBuyOrdersAsync(signedOrders, takerAddress, {
-                    makerTokenFillAmount,
+                    makerAssetFillAmount,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
                 expect(newBalances).to.be.deep.equal(balances);
             });
 
-            it('should throw when an signedOrder does not use the same makerTokenAddress', async () => {
+            it('should throw when an signedOrder does not use the same makerAssetAddress', async () => {
                 signedOrders = [
                     orderFactory.newSignedOrder(),
                     orderFactory.newSignedOrder({ makerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address) }),
@@ -869,30 +869,30 @@ describe('Exchange', () => {
 
                 return expect(
                     exWrapper.marketBuyOrdersAsync(signedOrders, takerAddress, {
-                        makerTokenFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18),
+                        makerAssetFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18),
                     }),
                 ).to.be.rejectedWith(constants.REVERT);
             });
         });
 
         describe('marketBuyOrdersNoThrow', () => {
-            it('should stop when the entire makerTokenFillAmount is filled', async () => {
-                const makerTokenFillAmount = signedOrders[0].makerTokenAmount.plus(
-                    signedOrders[1].makerTokenAmount.div(2),
+            it('should stop when the entire makerAssetFillAmount is filled', async () => {
+                const makerAssetFillAmount = signedOrders[0].makerAssetAmount.plus(
+                    signedOrders[1].makerAssetAmount.div(2),
                 );
                 await exWrapper.marketBuyOrdersNoThrowAsync(signedOrders, takerAddress, {
-                    makerTokenFillAmount,
+                    makerAssetFillAmount,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
 
-                const makerAmountBought = signedOrders[0].takerTokenAmount.add(
-                    signedOrders[1].takerTokenAmount.dividedToIntegerBy(2),
+                const makerAmountBought = signedOrders[0].takerAssetAmount.add(
+                    signedOrders[1].takerAssetAmount.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][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                    balances[makerAddress][defaultMakerTokenAddress].minus(makerTokenFillAmount),
+                    balances[makerAddress][defaultMakerTokenAddress].minus(makerAssetFillAmount),
                 );
                 expect(newBalances[makerAddress][defaultTakerTokenAddress]).to.be.bignumber.equal(
                     balances[makerAddress][defaultTakerTokenAddress].add(makerAmountBought),
@@ -904,7 +904,7 @@ describe('Exchange', () => {
                     balances[takerAddress][defaultTakerTokenAddress].minus(makerAmountBought),
                 );
                 expect(newBalances[takerAddress][defaultMakerTokenAddress]).to.be.bignumber.equal(
-                    balances[takerAddress][defaultMakerTokenAddress].add(makerTokenFillAmount),
+                    balances[takerAddress][defaultMakerTokenAddress].add(makerAssetFillAmount),
                 );
                 expect(newBalances[takerAddress][zrx.address]).to.be.bignumber.equal(
                     balances[takerAddress][zrx.address].minus(takerFee),
@@ -914,24 +914,24 @@ 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 takerAssetFillAmount', async () => {
+                const takerAssetFillAmount = ZeroEx.toBaseUnitAmount(new BigNumber(100000), 18);
                 _.forEach(signedOrders, signedOrder => {
                     balances[makerAddress][defaultMakerTokenAddress] = balances[makerAddress][
                         defaultMakerTokenAddress
-                    ].minus(signedOrder.makerTokenAmount);
+                    ].minus(signedOrder.makerAssetAmount);
                     balances[makerAddress][defaultTakerTokenAddress] = balances[makerAddress][
                         defaultTakerTokenAddress
-                    ].add(signedOrder.takerTokenAmount);
+                    ].add(signedOrder.takerAssetAmount);
                     balances[makerAddress][zrx.address] = balances[makerAddress][zrx.address].minus(
                         signedOrder.makerFee,
                     );
                     balances[takerAddress][defaultMakerTokenAddress] = balances[takerAddress][
                         defaultMakerTokenAddress
-                    ].add(signedOrder.makerTokenAmount);
+                    ].add(signedOrder.makerAssetAmount);
                     balances[takerAddress][defaultTakerTokenAddress] = balances[takerAddress][
                         defaultTakerTokenAddress
-                    ].minus(signedOrder.takerTokenAmount);
+                    ].minus(signedOrder.takerAssetAmount);
                     balances[takerAddress][zrx.address] = balances[takerAddress][zrx.address].minus(
                         signedOrder.takerFee,
                     );
@@ -940,14 +940,14 @@ describe('Exchange', () => {
                     );
                 });
                 await exWrapper.marketSellOrdersNoThrowAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmount,
+                    takerAssetFillAmount,
                 });
 
                 const newBalances = await dmyBalances.getAsync();
                 expect(newBalances).to.be.deep.equal(balances);
             });
 
-            it('should throw when a signedOrder does not use the same makerTokenAddress', async () => {
+            it('should throw when a signedOrder does not use the same makerAssetAddress', async () => {
                 signedOrders = [
                     orderFactory.newSignedOrder(),
                     orderFactory.newSignedOrder({ makerAssetData: proxyUtils.encodeERC20ProxyData(zrx.address) }),
@@ -956,7 +956,7 @@ describe('Exchange', () => {
 
                 return expect(
                     exWrapper.marketBuyOrdersNoThrowAsync(signedOrders, takerAddress, {
-                        makerTokenFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18),
+                        makerAssetFillAmount: ZeroEx.toBaseUnitAmount(new BigNumber(1000), 18),
                     }),
                 ).to.be.rejectedWith(constants.REVERT);
             });
@@ -964,11 +964,11 @@ describe('Exchange', () => {
 
         describe('batchCancelOrders', () => {
             it('should be able to cancel multiple signedOrders', async () => {
-                const takerTokenCancelAmounts = _.map(signedOrders, signedOrder => signedOrder.takerTokenAmount);
+                const takerAssetCancelAmounts = _.map(signedOrders, signedOrder => signedOrder.takerAssetAmount);
                 await exWrapper.batchCancelOrdersAsync(signedOrders, makerAddress);
 
                 await exWrapper.batchFillOrdersAsync(signedOrders, takerAddress, {
-                    takerTokenFillAmounts: takerTokenCancelAmounts,
+                    takerAssetFillAmounts: takerAssetCancelAmounts,
                 });
                 const newBalances = await dmyBalances.getAsync();
                 expect(balances).to.be.deep.equal(newBalances);