Merge pull request #547 from 0xProject/refactor/contracts/cleanup

Cleanup contracts

28 files changed, 355 insertions, 531 deletions

diff --git a/packages/contracts/src/contracts/current/protocol/AssetProxyDispatcher/AssetProxyDispatcher.sol b/packages/contracts/src/contracts/current/protocol/AssetProxyDispatcher/AssetProxyDispatcher.sol
index 2c689496f..43fd7596e 100644
--- a/packages/contracts/src/contracts/current/protocol/AssetProxyDispatcher/AssetProxyDispatcher.sol
+++ b/packages/contracts/src/contracts/current/protocol/AssetProxyDispatcher/AssetProxyDispatcher.sol
@@ -57,21 +57,21 @@ contract AssetProxyDispatcher is
     ///      An id can only be assigned to a single proxy at a given time,
     ///      however, an asset proxy may be registered to multiple ids.
     /// @param assetProxyId Id to register`newAssetProxy` under.
-    /// @param newAssetProxy asset proxy to register, or 0x0 to unset assetProxyId.
-    /// @param currentAssetProxy Existing asset proxy to overwrite, or 0x0 if assetProxyId is currently unused.
+    /// @param newAssetProxy Address of new asset proxy to register, or 0x0 to unset assetProxyId.
+    /// @param oldAssetProxy Existing asset proxy to overwrite, or 0x0 if assetProxyId is currently unused.
     function registerAssetProxy(
         uint8 assetProxyId,
-        IAssetProxy newAssetProxy,
-        IAssetProxy currentAssetProxy)
+        address newAssetProxy,
+        address oldAssetProxy)
         external
         onlyOwner
     {
         // Ensure the existing asset proxy is not unintentionally overwritten
-        require(currentAssetProxy == assetProxies[assetProxyId]);
+        require(oldAssetProxy == address(assetProxies[assetProxyId]));
 
         // Add asset proxy and log registration
-        assetProxies[assetProxyId] = newAssetProxy;
-        emit AssetProxySet(assetProxyId, newAssetProxy, currentAssetProxy);
+        assetProxies[assetProxyId] = IAssetProxy(newAssetProxy);
+        emit AssetProxySet(assetProxyId, newAssetProxy, oldAssetProxy);
     }
 
     /// @dev Gets an asset proxy.
@@ -79,9 +79,9 @@ contract AssetProxyDispatcher is
     /// @return The asset proxy registered to assetProxyId. Returns 0x0 if no proxy is registered.
     function getAssetProxy(uint8 assetProxyId)
         external view
-        returns (IAssetProxy)
+        returns (address)
     {
         IAssetProxy assetProxy = assetProxies[assetProxyId];
-        return assetProxy;
+        return address(assetProxy);
     }
 }
diff --git a/packages/contracts/src/contracts/current/protocol/AssetProxyDispatcher/IAssetProxyDispatcher.sol b/packages/contracts/src/contracts/current/protocol/AssetProxyDispatcher/IAssetProxyDispatcher.sol
index 044983823..88bc0d353 100644
--- a/packages/contracts/src/contracts/current/protocol/AssetProxyDispatcher/IAssetProxyDispatcher.sol
+++ b/packages/contracts/src/contracts/current/protocol/AssetProxyDispatcher/IAssetProxyDispatcher.sol
@@ -31,20 +31,20 @@ contract IAssetProxyDispatcher is
     // Logs registration of new asset proxy
     event AssetProxySet(
         uint8 id,
-        IAssetProxy newAssetClassAddress,
-        IAssetProxy oldAssetClassAddress
+        address newAssetProxy,
+        address oldAssetProxy
     );
 
     /// @dev Registers an asset proxy to an asset proxy id.
     ///      An id can only be assigned to a single proxy at a given time,
     ///      however, an asset proxy may be registered to multiple ids.
     /// @param assetProxyId Id to register`newAssetProxy` under.
-    /// @param newAssetProxy asset proxy to register, or 0x0 to unset assetProxyId.
-    /// @param currentAssetProxy Existing asset proxy to overwrite, or 0x0 if assetProxyId is currently unused.
+    /// @param newAssetProxy Address of new asset proxy to register, or 0x0 to unset assetProxyId.
+    /// @param oldAssetProxy Existing asset proxy to overwrite, or 0x0 if assetProxyId is currently unused.
     function registerAssetProxy(
         uint8 assetProxyId,
-        IAssetProxy newAssetProxy,
-        IAssetProxy currentAssetProxy)
+        address newAssetProxy,
+        address oldAssetProxy)
         external;
 
     /// @dev Gets an asset proxy.
@@ -52,5 +52,5 @@ contract IAssetProxyDispatcher is
     /// @return The asset proxy registered to assetProxyId. Returns 0x0 if no proxy is registered.
     function getAssetProxy(uint8 assetProxyId)
         external view
-        returns (IAssetProxy);
+        returns (address);
 }
diff --git a/packages/contracts/src/contracts/current/protocol/AssetProxyDispatcher/proxies/ERC20Proxy.sol b/packages/contracts/src/contracts/current/protocol/AssetProxyDispatcher/proxies/ERC20Proxy.sol
index e785bd26d..eef3a39db 100644
--- a/packages/contracts/src/contracts/current/protocol/AssetProxyDispatcher/proxies/ERC20Proxy.sol
+++ b/packages/contracts/src/contracts/current/protocol/AssetProxyDispatcher/proxies/ERC20Proxy.sol
@@ -21,7 +21,7 @@ pragma solidity ^0.4.21;
 import "../IAssetProxy.sol";
 import "../../../utils/LibBytes/LibBytes.sol";
 import "../../../utils/Authorizable/Authorizable.sol";
-import { Token_v1 as ERC20Token } from "../../../../previous/Token/Token_v1.sol";
+import "../../../tokens/ERC20Token/IERC20Token.sol";
 
 contract ERC20Proxy is
     LibBytes,
@@ -44,7 +44,7 @@ contract ERC20Proxy is
     {
         require(assetMetadata.length == 21);
         address token = readAddress(assetMetadata, 1);
-        bool success = ERC20Token(token).transferFrom(from, to, amount);
+        bool success = IERC20Token(token).transferFrom(from, to, amount);
         require(success == true);
     }
 }
diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/Exchange.sol b/packages/contracts/src/contracts/current/protocol/Exchange/Exchange.sol
index 91136b29f..995cbcf76 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/Exchange.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/Exchange.sol
@@ -23,7 +23,6 @@ import "./MixinExchangeCore.sol";
 import "./MixinSignatureValidator.sol";
 import "./MixinSettlementProxy.sol";
 import "./MixinWrapperFunctions.sol";
-import "../AssetProxyDispatcher/IAssetProxyDispatcher.sol";
 
 contract Exchange is
     MixinExchangeCore,
@@ -34,13 +33,12 @@ contract Exchange is
     string constant public VERSION = "2.0.1-alpha";
 
     function Exchange(
-        IToken _zrxToken,
-        bytes _zrxProxyData,
-        IAssetProxy _assetProxyDispatcher)
+        address _assetProxyDispatcher,
+        bytes memory _zrxProxyData)
         public
         MixinExchangeCore()
         MixinSignatureValidator()
-        MixinSettlementProxy(_assetProxyDispatcher, _zrxToken, _zrxProxyData)
+        MixinSettlementProxy(_assetProxyDispatcher, _zrxProxyData)
         MixinWrapperFunctions()
     {}
 }
diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/IExchange.sol b/packages/contracts/src/contracts/current/protocol/Exchange/IExchange.sol
index 3af51e915..ef2fb2a96 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
     );
 
@@ -77,9 +77,9 @@ contract IExchange {
     /// @dev Calculates the sum of values already filled and cancelled for a given order.
     /// @param orderHash The Keccak-256 hash of the given order.
     /// @return Sum of values already filled and cancelled.
-    function getUnavailableTakerTokenAmount(bytes32 orderHash)
+    function getUnavailableTakerAssetAmount(bytes32 orderHash)
         public view
-        returns (uint256 unavailableTakerTokenAmount);
+        returns (uint256 unavailableTakerAssetAmount);
 
     /// @dev Calculates partial value given a numerator and denominator.
     /// @param numerator Numerator.
@@ -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,62 +228,62 @@ 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);
+        returns (uint256 totalTakerAssetFilledAmount);
 
-    /// @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)
         external
-        returns (uint256 totalTakerTokenFilledAmount);
+        returns (uint256 totalTakerAssetFilledAmount);
 
     /// @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..710315515 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
@@ -53,21 +53,21 @@ contract MixinExchangeCore is
         address indexed makerAddress,
         address takerAddress,
         address indexed feeRecipientAddress,
-        bytes makerAssetData,
-        bytes takerAssetData,
-        uint256 makerTokenFilledAmount,
-        uint256 takerTokenFilledAmount,
+        uint256 makerAssetFilledAmount,
+        uint256 takerAssetFilledAmount,
         uint256 makerFeePaid,
         uint256 takerFeePaid,
-        bytes32 indexed orderHash
+        bytes32 indexed orderHash,
+        bytes makerAssetData,
+        bytes takerAssetData
     );
 
     event Cancel(
         address indexed makerAddress,
         address indexed feeRecipientAddress,
+        bytes32 indexed orderHash,
         bytes makerAssetData,
-        bytes takerAssetData,
-        bytes32 indexed orderHash
+        bytes takerAssetData
     );
 
     event CancelUpTo(
@@ -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,39 +127,39 @@ contract MixinExchangeCore is
         }
 
         // Validate order availability
-        uint256 remainingTakerTokenFillAmount = safeSub(order.takerTokenAmount, filled[orderHash]);
-        if (remainingTakerTokenFillAmount == 0) {
+        uint256 remainingTakerAssetFillAmount = safeSub(order.takerAssetAmount, filled[orderHash]);
+        if (remainingTakerAssetFillAmount == 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, remainingTakerAssetFillAmount);
+        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(
             order.makerAddress,
             msg.sender,
             order.feeRecipientAddress,
-            order.makerAssetData,
-            order.takerAssetData,
-            fillResults.makerTokenFilledAmount,
-            fillResults.takerTokenFilledAmount,
+            fillResults.makerAssetFilledAmount,
+            fillResults.takerAssetFilledAmount,
             fillResults.makerFeePaid,
             fillResults.takerFeePaid,
-            orderHash
+            orderHash,
+            order.makerAssetData,
+            order.takerAssetData
         );
         return fillResults;
     }
@@ -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) {
@@ -195,9 +195,9 @@ contract MixinExchangeCore is
         emit Cancel(
             order.makerAddress,
             order.feeRecipientAddress,
+            orderHash,
             order.makerAssetData,
-            order.takerAssetData,
-            orderHash
+            order.takerAssetData
         );
         return true;
     }
diff --git a/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol b/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol
index e8a7a148f..5fff2cd60 100644
--- a/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol
+++ b/packages/contracts/src/contracts/current/protocol/Exchange/MixinSettlementProxy.sol
@@ -20,7 +20,6 @@ pragma solidity ^0.4.21;
 pragma experimental ABIEncoderV2;
 
 import "./mixins/MSettlement.sol";
-import "../../tokens/Token/IToken.sol";
 import "./LibPartialAmount.sol";
 import "../AssetProxyDispatcher/IAssetProxy.sol";
 
@@ -29,70 +28,60 @@ contract MixinSettlementProxy is
     MSettlement,
     LibPartialAmount
 {
-    IAssetProxy TRANSFER_PROXY;
+    IAssetProxy ASSET_PROXY_DISPATCHER;
     bytes ZRX_PROXY_DATA;
-    IToken ZRX_TOKEN;
 
-    function transferProxy()
+    function assetProxyDispatcher()
         public view
-        returns (IAssetProxy)
+        returns (address)
     {
-        return TRANSFER_PROXY;
-    }
-
-    function zrxToken()
-        external view
-        returns (IToken)
-    {
-        return ZRX_TOKEN;
+        return address(ASSET_PROXY_DISPATCHER);
     }
 
     function zrxProxyData()
         external view
-        returns (bytes)
+        returns (bytes memory)
     {
         return ZRX_PROXY_DATA;
     }
 
     function MixinSettlementProxy(
-        IAssetProxy assetProxyDispatcherContract,
-        IToken zrxToken,
-        bytes zrxProxyData)
+        address _assetProxyDispatcher,
+        bytes memory _zrxProxyData)
         public
     {
-        ZRX_TOKEN = zrxToken;
-        TRANSFER_PROXY = assetProxyDispatcherContract;
-        ZRX_PROXY_DATA = zrxProxyData;
+        ASSET_PROXY_DISPATCHER = IAssetProxy(_assetProxyDispatcher);
+        ZRX_PROXY_DATA = _zrxProxyData;
     }
 
     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);
-        TRANSFER_PROXY.transferFrom(
+        makerAssetFilledAmount = getPartialAmount(takerAssetFilledAmount, order.takerAssetAmount, order.makerAssetAmount);
+        ASSET_PROXY_DISPATCHER.transferFrom(
             order.makerAssetData,
             order.makerAddress,
             takerAddress,
-            makerTokenFilledAmount
+            makerAssetFilledAmount
         );
-        TRANSFER_PROXY.transferFrom(
+        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);
-                TRANSFER_PROXY.transferFrom(
+                makerFeePaid = getPartialAmount(takerAssetFilledAmount, order.takerAssetAmount, order.makerFee);
+                ASSET_PROXY_DISPATCHER.transferFrom(
                     ZRX_PROXY_DATA,
                     order.makerAddress,
                     order.feeRecipientAddress,
@@ -100,8 +89,8 @@ contract MixinSettlementProxy is
                 );
             }
             if (order.takerFee > 0) {
-                takerFeePaid = getPartialAmount(takerTokenFilledAmount, order.takerTokenAmount, order.takerFee);
-                TRANSFER_PROXY.transferFrom(
+                takerFeePaid = getPartialAmount(takerAssetFilledAmount, order.takerAssetAmount, order.takerFee);
+                ASSET_PROXY_DISPATCHER.transferFrom(
                     ZRX_PROXY_DATA,
                     takerAddress,
                     order.feeRecipientAddress,
@@ -109,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..2c0fd0751 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,36 +325,36 @@ 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 remainingTakerAssetFillAmount = 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,
+                remainingTakerAssetFillAmount,
                 signatures[i]
             );
 
             // 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,35 +364,35 @@ 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 remainingTakerAssetFillAmount = 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,
+                remainingTakerAssetFillAmount,
                 signatures[i]
             );
 
             // 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,29 +402,29 @@ 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 remainingMakerAssetFillAmount = 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
-            uint256 remainingTakerTokenFillAmount = getPartialAmount(
-                orders[i].takerTokenAmount,
-                orders[i].makerTokenAmount,
-                remainingMakerTokenFillAmount
+            // 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 remainingTakerAssetFillAmount = getPartialAmount(
+                orders[i].takerAssetAmount,
+                orders[i].makerAssetAmount,
+                remainingMakerAssetFillAmount
             );
 
-            // Attempt to sell the remaining amount of takerToken
+            // Attempt to sell the remaining amount of takerAsset
             FillResults memory singleFillResults = fillOrder(
                 orders[i],
-                remainingTakerTokenFillAmount,
+                remainingTakerAssetFillAmount,
                 signatures[i]
             );
 
             // 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,29 +449,29 @@ 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 remainingMakerAssetFillAmount = 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
-            uint256 remainingTakerTokenFillAmount = getPartialAmount(
-                orders[i].takerTokenAmount,
-                orders[i].makerTokenAmount,
-                remainingMakerTokenFillAmount
+            // 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 remainingTakerAssetFillAmount = getPartialAmount(
+                orders[i].takerAssetAmount,
+                orders[i].makerAssetAmount,
+                remainingMakerAssetFillAmount
             );
 
-            // Attempt to sell the remaining amount of takerToken
+            // Attempt to sell the remaining amount of takerAsset
             FillResults memory singleFillResults = fillOrderNoThrow(
                 orders[i],
-                remainingTakerTokenFillAmount,
+                remainingTakerAssetFillAmount,
                 signatures[i]
             );
 
             // 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/contracts/current/test/DummyToken/DummyToken.sol b/packages/contracts/src/contracts/current/test/DummyERC20Token/DummyERC20Token.sol
index 8b29da919..2626399c2 100644
--- a/packages/contracts/src/contracts/current/test/DummyToken/DummyToken.sol
+++ b/packages/contracts/src/contracts/current/test/DummyERC20Token/DummyERC20Token.sol
@@ -21,16 +21,16 @@ pragma solidity ^0.4.21;
 import "../Mintable/Mintable.sol";
 import "../../utils/Ownable/Ownable.sol";
 
-contract DummyToken is Mintable, Ownable {
+contract DummyERC20Token is Mintable, Ownable {
     string public name;
     string public symbol;
-    uint public decimals;
+    uint256 public decimals;
 
-    function DummyToken(
+    function DummyERC20Token(
         string _name,
         string _symbol,
-        uint _decimals,
-        uint _totalSupply)
+        uint256 _decimals,
+        uint256 _totalSupply)
         public
     {
         name = _name;
@@ -40,11 +40,11 @@ contract DummyToken is Mintable, Ownable {
         balances[msg.sender] = _totalSupply;
     }
 
-    function setBalance(address _target, uint _value)
+    function setBalance(address _target, uint256 _value)
         public
         onlyOwner
     {
-        uint currBalance = balanceOf(_target);
+        uint256 currBalance = balanceOf(_target);
         if (_value < currBalance) {
             totalSupply = safeSub(totalSupply, safeSub(currBalance, _value));
         } else {
diff --git a/packages/contracts/src/contracts/current/test/MaliciousToken/MaliciousToken.sol b/packages/contracts/src/contracts/current/test/MaliciousToken/MaliciousToken.sol
deleted file mode 100644
index 3a0092276..000000000
--- a/packages/contracts/src/contracts/current/test/MaliciousToken/MaliciousToken.sol
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-
-  Copyright 2018 ZeroEx Intl.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-*/
-
-pragma solidity ^0.4.21;
-
-import "../../tokens/ERC20Token/ERC20Token.sol";
-
-contract MaliciousToken is ERC20Token {
-    uint8 stateToUpdate = 1;  // Not null so that change only requires 5000 gas
-
-    function updateState()
-        internal
-    {
-        stateToUpdate++;
-    }
-
-    function balanceOf(address _owner)
-        public
-        constant
-        returns (uint)
-    {
-        updateState();
-        return balances[_owner];
-    }
-
-    function allowance(address _owner, address _spender)
-        public
-        constant
-        returns (uint)
-    {
-        updateState();
-        return allowed[_owner][_spender];
-    }
-}
diff --git a/packages/contracts/src/contracts/current/test/Mintable/Mintable.sol b/packages/contracts/src/contracts/current/test/Mintable/Mintable.sol
index 81cbd39dd..305737b72 100644
--- a/packages/contracts/src/contracts/current/test/Mintable/Mintable.sol
+++ b/packages/contracts/src/contracts/current/test/Mintable/Mintable.sol
@@ -26,7 +26,7 @@ import "../../utils/SafeMath/SafeMath.sol";
  * Base contract that creates a mintable UnlimitedAllowanceToken
  */
 contract Mintable is UnlimitedAllowanceToken, SafeMath {
-    function mint(uint _value)
+    function mint(uint256 _value)
         public
     {
         require(_value <= 100000000000000000000);
diff --git a/packages/contracts/src/contracts/current/tokens/ERC20Token/ERC20Token.sol b/packages/contracts/src/contracts/current/tokens/ERC20Token/ERC20Token.sol
index ad6cb28b4..13ceeb2c6 100644
--- a/packages/contracts/src/contracts/current/tokens/ERC20Token/ERC20Token.sol
+++ b/packages/contracts/src/contracts/current/tokens/ERC20Token/ERC20Token.sol
@@ -18,22 +18,22 @@
 
 pragma solidity ^0.4.18;
 
-import "../Token/Token.sol";
+import "./IERC20Token.sol";
 
-contract ERC20Token is Token {
+contract ERC20Token is IERC20Token {
 
-    function transfer(address _to, uint _value)
+    function transfer(address _to, uint256 _value)
         public
         returns (bool)
     {
         require(balances[msg.sender] >= _value && balances[_to] + _value >= balances[_to]);
         balances[msg.sender] -= _value;
         balances[_to] += _value;
-        Transfer(msg.sender, _to, _value);
+        emit Transfer(msg.sender, _to, _value);
         return true;
     }
 
-    function transferFrom(address _from, address _to, uint _value)
+    function transferFrom(address _from, address _to, uint256 _value)
         public
         returns (bool)
     {
@@ -41,23 +41,22 @@ contract ERC20Token is Token {
         balances[_to] += _value;
         balances[_from] -= _value;
         allowed[_from][msg.sender] -= _value;
-        Transfer(_from, _to, _value);
+        emit Transfer(_from, _to, _value);
         return true;
     }
 
-    function approve(address _spender, uint _value)
+    function approve(address _spender, uint256 _value)
         public
         returns (bool)
     {
         allowed[msg.sender][_spender] = _value;
-        Approval(msg.sender, _spender, _value);
+        emit Approval(msg.sender, _spender, _value);
         return true;
     }
 
     function balanceOf(address _owner)
-        public
-        view
-        returns (uint)
+        public view
+        returns (uint256)
     {
         return balances[_owner];
     }
@@ -65,12 +64,12 @@ contract ERC20Token is Token {
     function allowance(address _owner, address _spender)
         public
         view
-        returns (uint)
+        returns (uint256)
     {
         return allowed[_owner][_spender];
     }
 
-    mapping (address => uint) balances;
-    mapping (address => mapping (address => uint)) allowed;
-    uint public totalSupply;
+    mapping (address => uint256) balances;
+    mapping (address => mapping (address => uint256)) allowed;
+    uint256 public totalSupply;
 }
diff --git a/packages/contracts/src/contracts/current/tokens/Token/Token.sol b/packages/contracts/src/contracts/current/tokens/ERC20Token/IERC20Token.sol
index d683c3113..0159b31e8 100644
--- a/packages/contracts/src/contracts/current/tokens/Token/Token.sol
+++ b/packages/contracts/src/contracts/current/tokens/ERC20Token/IERC20Token.sol
@@ -18,36 +18,53 @@
 
 pragma solidity ^0.4.18;
 
-contract Token {
+contract IERC20Token {
 
     /// @notice send `_value` token to `_to` from `msg.sender`
     /// @param _to The address of the recipient
     /// @param _value The amount of token to be transferred
     /// @return Whether the transfer was successful or not
-    function transfer(address _to, uint _value) public returns (bool) {}
+    function transfer(address _to, uint256 _value)
+        public
+        returns (bool);
 
     /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
     /// @param _from The address of the sender
     /// @param _to The address of the recipient
     /// @param _value The amount of token to be transferred
     /// @return Whether the transfer was successful or not
-    function transferFrom(address _from, address _to, uint _value) public returns (bool) {}
-
-    /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
+    function transferFrom(address _from, address _to, uint256 _value)
+        public
+        returns (bool);
+    
+    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
     /// @param _spender The address of the account able to transfer the tokens
     /// @param _value The amount of wei to be approved for transfer
     /// @return Whether the approval was successful or not
-    function approve(address _spender, uint _value) public returns (bool) {}
+    function approve(address _spender, uint256 _value)
+        public
+        returns (bool);
 
     /// @param _owner The address from which the balance will be retrieved
     /// @return The balance
-    function balanceOf(address _owner) public view returns (uint) {}
+    function balanceOf(address _owner)
+        public view
+        returns (uint256);
 
     /// @param _owner The address of the account owning tokens
     /// @param _spender The address of the account able to transfer the tokens
     /// @return Amount of remaining tokens allowed to spent
-    function allowance(address _owner, address _spender) public view returns (uint) {}
+    function allowance(address _owner, address _spender)
+        public view
+        returns (uint256);
 
-    event Transfer(address indexed _from, address indexed _to, uint _value);
-    event Approval(address indexed _owner, address indexed _spender, uint _value);
+    event Transfer(
+        address indexed _from,
+        address indexed _to,
+        uint256 _value);
+    
+    event Approval(
+        address indexed _owner,
+        address indexed _spender,
+        uint256 _value);
 }
diff --git a/packages/contracts/src/contracts/current/tokens/Token/IToken.sol b/packages/contracts/src/contracts/current/tokens/Token/IToken.sol
deleted file mode 100644
index cafbd436b..000000000
--- a/packages/contracts/src/contracts/current/tokens/Token/IToken.sol
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-
-  Copyright 2018 ZeroEx Intl.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-*/
-
-pragma solidity ^0.4.18;
-
-contract IToken {
-
-    /// @notice send `value` token to `to` from `msg.sender`
-    /// @param to The address of the recipient
-    /// @param value The amount of token to be transferred
-    /// @return Whether the transfer was successful or not
-    function transfer(address to, uint value)
-        public
-        returns (bool);
-
-    /// @notice send `value` token to `to` from `from` on the condition it is approved by `from`
-    /// @param from The address of the sender
-    /// @param to The address of the recipient
-    /// @param value The amount of token to be transferred
-    /// @return Whether the transfer was successful or not
-    function transferFrom(address from, address to, uint value)
-        public
-        returns (bool);
-    
-    /// @notice `msg.sender` approves `addr` to spend `value` tokens
-    /// @param spender The address of the account able to transfer the tokens
-    /// @param value The amount of wei to be approved for transfer
-    /// @return Whether the approval was successful or not
-    function approve(address spender, uint value)
-        public
-        returns (bool);
-
-    /// @param owner The address from which the balance will be retrieved
-    /// @return The balance
-    function balanceOf(address owner)
-        public view
-        returns (uint);
-
-    /// @param owner The address of the account owning tokens
-    /// @param spender The address of the account able to transfer the tokens
-    /// @return Amount of remaining tokens allowed to spent
-    function allowance(address owner, address spender)
-        public view
-        returns (uint);
-
-    event Transfer(
-        address indexed from,
-        address indexed to,
-        uint value);
-    
-    event Approval(
-        address indexed owner,
-        address indexed spender,
-        uint value);
-}
diff --git a/packages/contracts/src/contracts/current/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol b/packages/contracts/src/contracts/current/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol
index 97c18afb7..be774e374 100644
--- a/packages/contracts/src/contracts/current/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol
+++ b/packages/contracts/src/contracts/current/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol
@@ -22,25 +22,25 @@ import { ERC20Token } from "../ERC20Token/ERC20Token.sol";
 
 contract UnlimitedAllowanceToken is ERC20Token {
 
-    uint constant MAX_UINT = 2**256 - 1;
+    uint256 constant MAX_UINT = 2**256 - 1;
 
     /// @dev ERC20 transferFrom, modified such that an allowance of MAX_UINT represents an unlimited allowance. See https://github.com/ethereum/EIPs/issues/717
     /// @param _from Address to transfer from.
     /// @param _to Address to transfer to.
     /// @param _value Amount to transfer.
     /// @return Success of transfer.
-    function transferFrom(address _from, address _to, uint _value)
+    function transferFrom(address _from, address _to, uint256 _value)
         public
         returns (bool)
     {
-        uint allowance = allowed[_from][msg.sender];
+        uint256 allowance = allowed[_from][msg.sender];
         require(balances[_from] >= _value && allowance >= _value && balances[_to] + _value >= balances[_to]);
         balances[_to] += _value;
         balances[_from] -= _value;
         if (allowance < MAX_UINT) {
             allowed[_from][msg.sender] -= _value;
         }
-        Transfer(_from, _to, _value);
+        emit Transfer(_from, _to, _value);
         return true;
     }
 }
diff --git a/packages/contracts/src/contracts/current/utils/Authorizable/Authorizable.sol b/packages/contracts/src/contracts/current/utils/Authorizable/Authorizable.sol
index 3e2e0782f..f6032f889 100644
--- a/packages/contracts/src/contracts/current/utils/Authorizable/Authorizable.sol
+++ b/packages/contracts/src/contracts/current/utils/Authorizable/Authorizable.sol
@@ -100,9 +100,8 @@ contract Authorizable is
     /// @dev Gets all authorized addresses.
     /// @return Array of authorized addresses.
     function getAuthorizedAddresses()
-        public
-        constant
-        returns (address[])
+        public view
+        returns (address[] memory)
     {
         return authorities;
     }
diff --git a/packages/contracts/src/contracts/current/utils/LibBytes/LibBytes.sol b/packages/contracts/src/contracts/current/utils/LibBytes/LibBytes.sol
index f78d9baec..ce107f306 100644
--- a/packages/contracts/src/contracts/current/utils/LibBytes/LibBytes.sol
+++ b/packages/contracts/src/contracts/current/utils/LibBytes/LibBytes.sol
@@ -25,7 +25,7 @@ contract LibBytes {
     /// @param rhs Second byte array to compare.
     /// @return True if arrays are the same. False otherwise.
     function areBytesEqual(bytes memory lhs, bytes memory rhs)
-        public
+        public pure
         returns (bool equal)
     {
         assembly {
diff --git a/packages/contracts/src/contracts/previous/Token/IToken_v1.sol b/packages/contracts/src/contracts/previous/Token/IToken_v1.sol
deleted file mode 100644
index db4286964..000000000
--- a/packages/contracts/src/contracts/previous/Token/IToken_v1.sol
+++ /dev/null
@@ -1,52 +0,0 @@
-pragma solidity ^0.4.18;
-
-contract IToken_v1 {
-
-    /// @notice send `value` token to `to` from `msg.sender`
-    /// @param to The address of the recipient
-    /// @param value The amount of token to be transferred
-    /// @return Whether the transfer was successful or not
-    function transfer(address to, uint value)
-        public
-        returns (bool);
-
-    /// @notice send `value` token to `to` from `from` on the condition it is approved by `from`
-    /// @param from The address of the sender
-    /// @param to The address of the recipient
-    /// @param value The amount of token to be transferred
-    /// @return Whether the transfer was successful or not
-    function transferFrom(address from, address to, uint value)
-        public
-        returns (bool);
-    
-    /// @notice `msg.sender` approves `addr` to spend `value` tokens
-    /// @param spender The address of the account able to transfer the tokens
-    /// @param value The amount of wei to be approved for transfer
-    /// @return Whether the approval was successful or not
-    function approve(address spender, uint value)
-        public
-        returns (bool);
-
-    /// @param owner The address from which the balance will be retrieved
-    /// @return The balance
-    function balanceOf(address owner)
-        public view
-        returns (uint);
-
-    /// @param owner The address of the account owning tokens
-    /// @param spender The address of the account able to transfer the tokens
-    /// @return Amount of remaining tokens allowed to spent
-    function allowance(address owner, address spender)
-        public view
-        returns (uint);
-
-    event Transfer(
-        address indexed from,
-        address indexed to,
-        uint value);
-    
-    event Approval(
-        address indexed owner,
-        address indexed spender,
-        uint value);
-}
diff --git a/packages/contracts/src/utils/artifacts.ts b/packages/contracts/src/utils/artifacts.ts
index 87cc73cff..78ba1c142 100644
--- a/packages/contracts/src/utils/artifacts.ts
+++ b/packages/contracts/src/utils/artifacts.ts
@@ -1,9 +1,7 @@
-import * as DummyTokenArtifact from '../artifacts/DummyToken.json';
+import * as DummyERC20TokenArtifact from '../artifacts/DummyERC20Token.json';
 import * as ExchangeArtifact from '../artifacts/Exchange.json';
-import * as MaliciousTokenArtifact from '../artifacts/MaliciousToken.json';
 import * as MultiSigWalletWithTimeLockArtifact from '../artifacts/MultiSigWalletWithTimeLock.json';
 import * as MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressArtifact from '../artifacts/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.json';
-import * as TokenArtifact from '../artifacts/Token.json';
 import * as TokenRegistryArtifact from '../artifacts/TokenRegistry.json';
 import * as EtherTokenArtifact from '../artifacts/WETH9.json';
 import * as ZRXArtifact from '../artifacts/ZRXToken.json';
@@ -12,12 +10,10 @@ import { Artifact } from './types';
 
 export const artifacts = {
     ZRXArtifact: (ZRXArtifact as any) as Artifact,
-    DummyTokenArtifact: (DummyTokenArtifact as any) as Artifact,
-    TokenArtifact: (TokenArtifact as any) as Artifact,
+    DummyERC20TokenArtifact: (DummyERC20TokenArtifact as any) as Artifact,
     ExchangeArtifact: (ExchangeArtifact as any) as Artifact,
     EtherTokenArtifact: (EtherTokenArtifact as any) as Artifact,
     TokenRegistryArtifact: (TokenRegistryArtifact as any) as Artifact,
-    MaliciousTokenArtifact: (MaliciousTokenArtifact as any) as Artifact,
     MultiSigWalletWithTimeLockArtifact: (MultiSigWalletWithTimeLockArtifact as any) as Artifact,
     MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressArtifact: (MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressArtifact as any) as Artifact,
 };
diff --git a/packages/contracts/src/utils/asset_proxy_utils.ts b/packages/contracts/src/utils/asset_proxy_utils.ts
index da610cbcc..1a7a312dd 100644
--- a/packages/contracts/src/utils/asset_proxy_utils.ts
+++ b/packages/contracts/src/utils/asset_proxy_utils.ts
@@ -4,37 +4,35 @@ import ethUtil = require('ethereumjs-util');
 
 import { AssetProxyId } from './types';
 
-export function encodeAssetProxyId(assetProxyId: AssetProxyId): Buffer {
-    return ethUtil.toBuffer(assetProxyId);
-}
-
-export function encodeAddress(address: string): Buffer {
-    if (!ethUtil.isValidAddress(address)) {
-        throw new Error(`Invalid Address: ${address}`);
-    }
-    const encodedAddress = ethUtil.toBuffer(address);
-    return encodedAddress;
-}
-
-export function encodeUint256(value: BigNumber): Buffer {
-    const formattedValue = new BN(value.toString(10));
-    const encodedValue = ethUtil.toBuffer(formattedValue);
-    return encodedValue;
-}
-
-export function encodeERC20ProxyData(tokenAddress: string): string {
-    const encodedAssetProxyId = encodeAssetProxyId(AssetProxyId.ERC20);
-    const encodedAddress = encodeAddress(tokenAddress);
-    const encodedMetadata = Buffer.concat([encodedAssetProxyId, encodedAddress]);
-    const encodedMetadataHex = ethUtil.bufferToHex(encodedMetadata);
-    return encodedMetadataHex;
-}
-
-export function encodeERC721ProxyData(tokenAddress: string, tokenId: BigNumber): string {
-    const encodedAssetProxyId = encodeAssetProxyId(AssetProxyId.ERC721);
-    const encodedAddress = encodeAddress(tokenAddress);
-    const encodedTokenId = encodeUint256(tokenId);
-    const encodedMetadata = Buffer.concat([encodedAssetProxyId, encodedAddress, encodedTokenId]);
-    const encodedMetadataHex = ethUtil.bufferToHex(encodedMetadata);
-    return encodedMetadataHex;
-}
+export const assetProxyUtils = {
+    encodeAssetProxyId(assetProxyId: AssetProxyId): Buffer {
+        return ethUtil.toBuffer(assetProxyId);
+    },
+    encodeAddress(address: string): Buffer {
+        if (!ethUtil.isValidAddress(address)) {
+            throw new Error(`Invalid Address: ${address}`);
+        }
+        const encodedAddress = ethUtil.toBuffer(address);
+        return encodedAddress;
+    },
+    encodeUint256(value: BigNumber): Buffer {
+        const formattedValue = new BN(value.toString(10));
+        const encodedValue = ethUtil.toBuffer(formattedValue);
+        return encodedValue;
+    },
+    encodeERC20ProxyData(tokenAddress: string): string {
+        const encodedAssetProxyId = assetProxyUtils.encodeAssetProxyId(AssetProxyId.ERC20);
+        const encodedAddress = assetProxyUtils.encodeAddress(tokenAddress);
+        const encodedMetadata = Buffer.concat([encodedAssetProxyId, encodedAddress]);
+        const encodedMetadataHex = ethUtil.bufferToHex(encodedMetadata);
+        return encodedMetadataHex;
+    },
+    encodeERC721ProxyData(tokenAddress: string, tokenId: BigNumber): string {
+        const encodedAssetProxyId = assetProxyUtils.encodeAssetProxyId(AssetProxyId.ERC721);
+        const encodedAddress = assetProxyUtils.encodeAddress(tokenAddress);
+        const encodedTokenId = assetProxyUtils.encodeUint256(tokenId);
+        const encodedMetadata = Buffer.concat([encodedAssetProxyId, encodedAddress, encodedTokenId]);
+        const encodedMetadataHex = ethUtil.bufferToHex(encodedMetadata);
+        return encodedMetadataHex;
+    },
+};
diff --git a/packages/contracts/src/utils/balances.ts b/packages/contracts/src/utils/balances.ts
index 2ebc10313..40a59e815 100644
--- a/packages/contracts/src/utils/balances.ts
+++ b/packages/contracts/src/utils/balances.ts
@@ -2,14 +2,14 @@ import { BigNumber } from '@0xproject/utils';
 import * as _ from 'lodash';
 import * as Web3 from 'web3';
 
-import { DummyTokenContract } from '../contract_wrappers/generated/dummy_token';
+import { DummyERC20TokenContract } from '../contract_wrappers/generated/dummy_e_r_c20_token';
 
 import { BalancesByOwner } from './types';
 
 export class Balances {
-    private _tokenContractInstances: DummyTokenContract[];
+    private _tokenContractInstances: DummyERC20TokenContract[];
     private _ownerAddresses: string[];
-    constructor(tokenContractInstances: DummyTokenContract[], ownerAddresses: string[]) {
+    constructor(tokenContractInstances: DummyERC20TokenContract[], ownerAddresses: string[]) {
         this._tokenContractInstances = tokenContractInstances;
         this._ownerAddresses = ownerAddresses;
     }
diff --git a/packages/contracts/src/utils/exchange_wrapper.ts b/packages/contracts/src/utils/exchange_wrapper.ts
index cda012aa9..26ce8b04e 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 },
         );
@@ -221,7 +221,7 @@ export class ExchangeWrapper {
         );
         return partialAmount;
     }
-    public async getTakerTokenFilledAmount(orderHashHex: string): Promise<BigNumber> {
+    public async getTakerAssetFilledAmountAsync(orderHashHex: string): Promise<BigNumber> {
         const filledAmount = new BigNumber(await this._exchange.filled.callAsync(orderHashHex));
         return filledAmount;
     }
diff --git a/packages/contracts/src/utils/formatters.ts b/packages/contracts/src/utils/formatters.ts
index 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 7de167f27..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;
@@ -100,10 +100,9 @@ export enum ContractName {
     MultiSigWalletWithTimeLock = 'MultiSigWalletWithTimeLock',
     Exchange = 'Exchange',
     ZRXToken = 'ZRXToken',
-    DummyToken = 'DummyToken',
+    DummyERC20Token = 'DummyERC20Token',
     EtherToken = 'WETH9',
     MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress = 'MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress',
-    MaliciousToken = 'MaliciousToken',
     AccountLevels = 'AccountLevels',
     EtherDelta = 'EtherDelta',
     Arbitrage = 'Arbitrage',
@@ -138,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;