Merge development branch

47 files changed, 2197 insertions, 688 deletions

diff --git a/packages/contracts/compiler.json b/packages/contracts/compiler.json
index ad35fc5b3..16524231c 100644
--- a/packages/contracts/compiler.json
+++ b/packages/contracts/compiler.json
@@ -1,6 +1,6 @@
 {
     "artifactsDir": "../migrations/artifacts/2.0.0",
-    "contractsDir": "src/contracts",
+    "contractsDir": "src/",
     "compilerSettings": {
         "optimizer": {
             "enabled": true,
@@ -23,6 +23,7 @@
         "DummyERC20Token",
         "DummyERC721Receiver",
         "DummyERC721Token",
+        "DummyNoReturnERC20Token",
         "ERC20Proxy",
         "ERC20Token",
         "ERC721Token",
@@ -32,11 +33,13 @@
         "Forwarder",
         "IAssetData",
         "IAssetProxy",
+        "InvalidERC721Receiver",
         "IValidator",
         "IWallet",
         "MixinAuthorizable",
         "MultiSigWallet",
         "MultiSigWalletWithTimeLock",
+        "OrderValidator",
         "TestAssetProxyOwner",
         "TestAssetProxyDispatcher",
         "TestConstants",
diff --git a/packages/contracts/package.json b/packages/contracts/package.json
index 3c3ce6792..8421c3104 100644
--- a/packages/contracts/package.json
+++ b/packages/contracts/package.json
@@ -20,11 +20,14 @@
         "test:coverage": "SOLIDITY_COVERAGE=true run-s build run_mocha coverage:report:text coverage:report:lcov",
         "test:profiler": "SOLIDITY_PROFILER=true run-s build run_mocha profiler:report:html",
         "test:trace": "SOLIDITY_REVERT_TRACE=true run-s build run_mocha",
-        "run_mocha": "mocha --require source-map-support/register --require make-promises-safe 'lib/test/**/*.js' --timeout 100000 --bail --exit",
+        "run_mocha":
+            "mocha --require source-map-support/register --require make-promises-safe 'lib/test/**/*.js' --timeout 100000 --bail --exit",
         "compile": "sol-compiler --contracts-dir src",
         "clean": "shx rm -rf lib generated_contract_wrappers",
-        "generate_contract_wrappers": "abi-gen --abis  ${npm_package_config_abis} --template ../contract_templates/contract.handlebars --partials '../contract_templates/partials/**/*.handlebars' --output generated_contract_wrappers --backend ethers",
-        "lint": "tslint --project . --exclude **/src/generated_contract_wrappers/**/* --exclude **/lib/**/* && yarn lint-contracts",
+        "generate_contract_wrappers":
+            "abi-gen --abis  ${npm_package_config_abis} --template ../contract_templates/contract.handlebars --partials '../contract_templates/partials/**/*.handlebars' --output generated_contract_wrappers --backend ethers",
+        "lint":
+            "tslint --project . --exclude **/src/generated_contract_wrappers/**/* --exclude **/lib/**/* && yarn lint-contracts",
         "coverage:report:text": "istanbul report text",
         "coverage:report:html": "istanbul report html && open coverage/index.html",
         "profiler:report:html": "istanbul report html && open coverage/index.html",
@@ -33,7 +36,8 @@
         "lint-contracts": "solhint src/2.0.0/**/**/**/**/*.sol"
     },
     "config": {
-        "abis": "../migrations/artifacts/2.0.0/@(AssetProxyOwner|DummyERC20Token|DummyERC721Receiver|DummyERC721Token|ERC20Proxy|ERC721Proxy|Forwarder|Exchange|ExchangeWrapper|IAssetData|IAssetProxy|MixinAuthorizable|MultiSigWallet|MultiSigWalletWithTimeLock|TestAssetProxyOwner|TestAssetProxyDispatcher|TestConstants|TestExchangeInternals|TestLibBytes|TestLibs|TestSignatureValidator|Validator|Wallet|TokenRegistry|Whitelist|WETH9|ZRXToken).json"
+        "abis":
+            "../migrations/artifacts/2.0.0/@(AssetProxyOwner|DummyERC20Token|DummyERC721Receiver|DummyERC721Token|DummyNoReturnERC20Token|ERC20Proxy|ERC721Proxy|Forwarder|Exchange|ExchangeWrapper|IAssetData|IAssetProxy|InvalidERC721Receiver|MixinAuthorizable|MultiSigWallet|MultiSigWalletWithTimeLock|OrderValidator|TestAssetProxyOwner|TestAssetProxyDispatcher|TestConstants|TestExchangeInternals|TestLibBytes|TestLibs|TestSignatureValidator|Validator|Wallet|TokenRegistry|Whitelist|WETH9|ZRXToken).json"
     },
     "repository": {
         "type": "git",
diff --git a/packages/contracts/src/2.0.0/forwarder/Forwarder.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/Forwarder.sol
index 5b88b05b1..6b17bb29b 100644
--- a/packages/contracts/src/2.0.0/forwarder/Forwarder.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/Forwarder.sol
@@ -37,16 +37,12 @@ contract Forwarder is
 
     constructor (
         address _exchange,
-        address _etherToken,
-        address _zrxToken,
         bytes memory _zrxAssetData,
         bytes memory _wethAssetData
     )
         public
         LibConstants(
             _exchange,
-            _etherToken,
-            _zrxToken,
             _zrxAssetData,
             _wethAssetData
         )
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinAssets.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/MixinAssets.sol
index e06f9a8e3..d6a38aa6e 100644
--- a/packages/contracts/src/2.0.0/forwarder/MixinAssets.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/MixinAssets.sol
@@ -18,10 +18,10 @@
 
 pragma solidity 0.4.24;
 
-import "../utils/LibBytes/LibBytes.sol";
-import "../utils/Ownable/Ownable.sol";
-import "../tokens/ERC20Token/IERC20Token.sol";
-import "../tokens/ERC721Token/IERC721Token.sol";
+import "../../utils/LibBytes/LibBytes.sol";
+import "../../utils/Ownable/Ownable.sol";
+import "../../tokens/ERC20Token/IERC20Token.sol";
+import "../../tokens/ERC721Token/IERC721Token.sol";
 import "./libs/LibConstants.sol";
 import "./mixins/MAssets.sol";
 
@@ -67,7 +67,7 @@ contract MixinAssets is
         } else if (proxyId == ERC721_DATA_ID) {
             transferERC721Token(assetData, amount);
         } else {
-            revert("UNSUPPORTED_TOKEN_PROXY");
+            revert("UNSUPPORTED_ASSET_PROXY");
         }
     }
 
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinExchangeWrapper.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/MixinExchangeWrapper.sol
index 4584bb840..218713d3c 100644
--- a/packages/contracts/src/2.0.0/forwarder/MixinExchangeWrapper.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/MixinExchangeWrapper.sol
@@ -21,10 +21,10 @@ pragma experimental ABIEncoderV2;
 
 import "./libs/LibConstants.sol";
 import "./mixins/MExchangeWrapper.sol";
-import "../protocol/Exchange/libs/LibAbiEncoder.sol";
-import "../protocol/Exchange/libs/LibOrder.sol";
-import "../protocol/Exchange/libs/LibFillResults.sol";
-import "../protocol/Exchange/libs/LibMath.sol";
+import "../../protocol/Exchange/libs/LibAbiEncoder.sol";
+import "../../protocol/Exchange/libs/LibOrder.sol";
+import "../../protocol/Exchange/libs/LibFillResults.sol";
+import "../../protocol/Exchange/libs/LibMath.sol";
 
 
 contract MixinExchangeWrapper is
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinForwarderCore.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/MixinForwarderCore.sol
index 93cbf79be..42cec4d36 100644
--- a/packages/contracts/src/2.0.0/forwarder/MixinForwarderCore.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/MixinForwarderCore.sol
@@ -24,10 +24,10 @@ import "./mixins/MWeth.sol";
 import "./mixins/MAssets.sol";
 import "./mixins/MExchangeWrapper.sol";
 import "./interfaces/IForwarderCore.sol";
-import "../utils/LibBytes/LibBytes.sol";
-import "../protocol/Exchange/libs/LibOrder.sol";
-import "../protocol/Exchange/libs/LibFillResults.sol";
-import "../protocol/Exchange/libs/LibMath.sol";
+import "../../utils/LibBytes/LibBytes.sol";
+import "../../protocol/Exchange/libs/LibOrder.sol";
+import "../../protocol/Exchange/libs/LibFillResults.sol";
+import "../../protocol/Exchange/libs/LibMath.sol";
 
 
 contract MixinForwarderCore is
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinWeth.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/MixinWeth.sol
index e07940776..93e85e599 100644
--- a/packages/contracts/src/2.0.0/forwarder/MixinWeth.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/MixinWeth.sol
@@ -18,7 +18,7 @@
 
 pragma solidity 0.4.24;
 
-import "../protocol/Exchange/libs/LibMath.sol";
+import "../../protocol/Exchange/libs/LibMath.sol";
 import "./libs/LibConstants.sol";
 import "./mixins/MWeth.sol";
 
diff --git a/packages/contracts/src/2.0.0/forwarder/interfaces/IAssets.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/interfaces/IAssets.sol
index 1e034c003..1e034c003 100644
--- a/packages/contracts/src/2.0.0/forwarder/interfaces/IAssets.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/interfaces/IAssets.sol
diff --git a/packages/contracts/src/2.0.0/forwarder/interfaces/IForwarder.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/interfaces/IForwarder.sol
index f5a26e2ba..f5a26e2ba 100644
--- a/packages/contracts/src/2.0.0/forwarder/interfaces/IForwarder.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/interfaces/IForwarder.sol
diff --git a/packages/contracts/src/2.0.0/forwarder/interfaces/IForwarderCore.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/interfaces/IForwarderCore.sol
index 3ecbb133b..74c7da01d 100644
--- a/packages/contracts/src/2.0.0/forwarder/interfaces/IForwarderCore.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/interfaces/IForwarderCore.sol
@@ -19,8 +19,8 @@
 pragma solidity 0.4.24;
 pragma experimental ABIEncoderV2;
 
-import "../../protocol/Exchange/libs/LibOrder.sol";
-import "../../protocol/Exchange/libs/LibFillResults.sol";
+import "../../../protocol/Exchange/libs/LibOrder.sol";
+import "../../../protocol/Exchange/libs/LibFillResults.sol";
 
 
 contract IForwarderCore {
diff --git a/packages/contracts/src/2.0.0/forwarder/libs/LibConstants.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/libs/LibConstants.sol
index c26d7902c..704e42ce3 100644
--- a/packages/contracts/src/2.0.0/forwarder/libs/LibConstants.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/libs/LibConstants.sol
@@ -18,13 +18,16 @@
 
 pragma solidity 0.4.24;
 
-import "../../protocol/Exchange/interfaces/IExchange.sol";
-import "../../tokens/EtherToken/IEtherToken.sol";
-import "../../tokens/ERC20Token/IERC20Token.sol";
+import "../../../utils/LibBytes/LibBytes.sol";
+import "../../../protocol/Exchange/interfaces/IExchange.sol";
+import "../../../tokens/EtherToken/IEtherToken.sol";
+import "../../../tokens/ERC20Token/IERC20Token.sol";
 
 
 contract LibConstants {
 
+    using LibBytes for bytes;
+
     bytes4 constant internal ERC20_DATA_ID = bytes4(keccak256("ERC20Token(address)"));
     bytes4 constant internal ERC721_DATA_ID = bytes4(keccak256("ERC721Token(address,uint256)"));
     uint256 constant internal MAX_UINT = 2**256 - 1;
@@ -42,17 +45,18 @@ contract LibConstants {
 
     constructor (
         address _exchange,
-        address _etherToken,
-        address _zrxToken,
         bytes memory _zrxAssetData,
         bytes memory _wethAssetData
     )
         public
     {
         EXCHANGE = IExchange(_exchange);
-        ETHER_TOKEN = IEtherToken(_etherToken);
-        ZRX_TOKEN = IERC20Token(_zrxToken);
         ZRX_ASSET_DATA = _zrxAssetData;
         WETH_ASSET_DATA = _wethAssetData;
+
+        address etherToken = _wethAssetData.readAddress(16);
+        address zrxToken = _zrxAssetData.readAddress(16);
+        ETHER_TOKEN = IEtherToken(etherToken);
+        ZRX_TOKEN = IERC20Token(zrxToken);
     }
 }
diff --git a/packages/contracts/src/2.0.0/forwarder/libs/LibForwarderErrors.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/libs/LibForwarderErrors.sol
index cdfb77a0b..fb3ade1db 100644
--- a/packages/contracts/src/2.0.0/forwarder/libs/LibForwarderErrors.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/libs/LibForwarderErrors.sol
@@ -27,7 +27,7 @@ contract LibForwarderErrors {
     string constant OVERSOLD_WETH = "OVERSOLD_WETH";                                              // More WETH sold than provided with current message call.
     string constant COMPLETE_FILL_FAILED = "COMPLETE_FILL_FAILED";                                // Desired purchase amount not completely filled (required for ZRX fees only).
     string constant TRANSFER_FAILED = "TRANSFER_FAILED";                                          // Asset transfer failed.
-    string constant UNSUPPORTED_TOKEN_PROXY = "UNSUPPORTED_TOKEN_PROXY";                          // Proxy in assetData not supported.
+    string constant UNSUPPORTED_ASSET_PROXY = "UNSUPPORTED_ASSET_PROXY";                          // Proxy in assetData not supported.
     string constant DEFAULT_FUNCTION_WETH_CONTRACT_ONLY = "DEFAULT_FUNCTION_WETH_CONTRACT_ONLY";  // Fallback function may only be used for WETH withdrawals.
     string constant INVALID_MSG_VALUE = "INVALID_MSG_VALUE";                                      // msg.value must be greater than 0.
     string constant INVALID_AMOUNT = "INVALID_AMOUNT";                                            // Amount must equal 1.
diff --git a/packages/contracts/src/2.0.0/forwarder/mixins/MAssets.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/mixins/MAssets.sol
index 83636432a..83636432a 100644
--- a/packages/contracts/src/2.0.0/forwarder/mixins/MAssets.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/mixins/MAssets.sol
diff --git a/packages/contracts/src/2.0.0/forwarder/mixins/MExchangeWrapper.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/mixins/MExchangeWrapper.sol
index 360dea0e4..13c26b03a 100644
--- a/packages/contracts/src/2.0.0/forwarder/mixins/MExchangeWrapper.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/mixins/MExchangeWrapper.sol
@@ -19,8 +19,8 @@
 pragma solidity 0.4.24;
 pragma experimental ABIEncoderV2;
 
-import "../../protocol/Exchange/libs/LibOrder.sol";
-import "../../protocol/Exchange/libs/LibFillResults.sol";
+import "../../../protocol/Exchange/libs/LibOrder.sol";
+import "../../../protocol/Exchange/libs/LibFillResults.sol";
 
 
 contract MExchangeWrapper {
diff --git a/packages/contracts/src/2.0.0/forwarder/mixins/MWeth.sol b/packages/contracts/src/2.0.0/extensions/Forwarder/mixins/MWeth.sol
index 88e77be4e..88e77be4e 100644
--- a/packages/contracts/src/2.0.0/forwarder/mixins/MWeth.sol
+++ b/packages/contracts/src/2.0.0/extensions/Forwarder/mixins/MWeth.sol
diff --git a/packages/contracts/src/2.0.0/extensions/OrderValidator/OrderValidator.sol b/packages/contracts/src/2.0.0/extensions/OrderValidator/OrderValidator.sol
new file mode 100644
index 000000000..a18345245
--- /dev/null
+++ b/packages/contracts/src/2.0.0/extensions/OrderValidator/OrderValidator.sol
@@ -0,0 +1,218 @@
+/*
+
+  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.24;
+pragma experimental ABIEncoderV2;
+
+import "../../protocol/Exchange/interfaces/IExchange.sol";
+import "../../protocol/Exchange/libs/LibOrder.sol";
+import "../../tokens/ERC20Token/IERC20Token.sol";
+import "../../tokens/ERC721Token/IERC721Token.sol";
+import "../../utils/LibBytes/LibBytes.sol";
+
+
+contract OrderValidator {
+
+    bytes4 constant internal ERC20_DATA_ID = bytes4(keccak256("ERC20Token(address)"));
+    bytes4 constant internal ERC721_DATA_ID = bytes4(keccak256("ERC721Token(address,uint256)"));
+
+    using LibBytes for bytes;
+
+    struct TraderInfo {
+        uint256 makerBalance;       // Maker's balance of makerAsset
+        uint256 makerAllowance;     // Maker's allowance to corresponding AssetProxy
+        uint256 takerBalance;       // Taker's balance of takerAsset
+        uint256 takerAllowance;     // Taker's allowance to corresponding AssetProxy
+        uint256 makerZrxBalance;    // Maker's balance of ZRX
+        uint256 makerZrxAllowance;  // Maker's allowance of ZRX to ERC20Proxy
+        uint256 takerZrxBalance;    // Taker's balance of ZRX
+        uint256 takerZrxAllowance;  // Taker's allowance of ZRX to ERC20Proxy
+    }
+
+    // solhint-disable var-name-mixedcase
+    IExchange internal EXCHANGE;
+    bytes internal ZRX_ASSET_DATA;
+    // solhint-enable var-name-mixedcase
+
+    constructor (address _exchange, bytes memory _zrxAssetData)
+        public
+    {
+        EXCHANGE = IExchange(_exchange);
+        ZRX_ASSET_DATA = _zrxAssetData;
+    }
+
+    /// @dev Fetches information for order and maker/taker of order.
+    /// @param order The order structure.
+    /// @param takerAddress Address that will be filling the order.
+    /// @return OrderInfo and TraderInfo instances for given order.
+    function getOrderAndTraderInfo(LibOrder.Order memory order, address takerAddress)
+        public
+        view
+        returns (LibOrder.OrderInfo memory orderInfo, TraderInfo memory traderInfo)
+    {
+        orderInfo = EXCHANGE.getOrderInfo(order);
+        traderInfo = getTraderInfo(order, takerAddress);
+        return (orderInfo, traderInfo);
+    }
+
+    /// @dev Fetches information for all passed in orders and the makers/takers of each order.
+    /// @param orders Array of order specifications.
+    /// @param takerAddresses Array of taker addresses corresponding to each order.
+    /// @return Arrays of OrderInfo and TraderInfo instances that correspond to each order.
+    function getOrdersAndTradersInfo(LibOrder.Order[] memory orders, address[] memory takerAddresses)
+        public
+        view
+        returns (LibOrder.OrderInfo[] memory ordersInfo, TraderInfo[] memory tradersInfo)
+    {
+        ordersInfo = EXCHANGE.getOrdersInfo(orders);
+        tradersInfo = getTradersInfo(orders, takerAddresses);
+        return (ordersInfo, tradersInfo);
+    }
+
+    /// @dev Fetches balance and allowances for maker and taker of order.
+    /// @param order The order structure.
+    /// @param takerAddress Address that will be filling the order.
+    /// @return Balances and allowances of maker and taker of order.
+    function getTraderInfo(LibOrder.Order memory order, address takerAddress)
+        public
+        view
+        returns (TraderInfo memory traderInfo)
+    {
+        (traderInfo.makerBalance, traderInfo.makerAllowance) = getBalanceAndAllowance(order.makerAddress, order.makerAssetData);
+        (traderInfo.takerBalance, traderInfo.takerAllowance) = getBalanceAndAllowance(takerAddress, order.takerAssetData);
+        bytes memory zrxAssetData = ZRX_ASSET_DATA;
+        (traderInfo.makerZrxBalance, traderInfo.makerZrxAllowance) = getBalanceAndAllowance(order.makerAddress, zrxAssetData);
+        (traderInfo.takerZrxBalance, traderInfo.takerZrxAllowance) = getBalanceAndAllowance(takerAddress, zrxAssetData);
+        return traderInfo;
+    }
+
+    /// @dev Fetches balances and allowances of maker and taker for each provided order.
+    /// @param orders Array of order specifications.
+    /// @param takerAddresses Array of taker addresses corresponding to each order.
+    /// @return Array of balances and allowances for maker and taker of each order.
+    function getTradersInfo(LibOrder.Order[] memory orders, address[] memory takerAddresses)
+        public
+        view
+        returns (TraderInfo[] memory)
+    {
+        uint256 ordersLength = orders.length;
+        TraderInfo[] memory tradersInfo = new TraderInfo[](ordersLength);
+        for (uint256 i = 0; i != ordersLength; i++) {
+            tradersInfo[i] = getTraderInfo(orders[i], takerAddresses[i]);
+        }
+        return tradersInfo;
+    }
+
+    /// @dev Fetches token balances and allowances of an address to given assetProxy. Supports ERC20 and ERC721.
+    /// @param target Address to fetch balances and allowances of.
+    /// @param assetData Encoded data that can be decoded by a specified proxy contract when transferring asset.
+    /// @return Balance of asset and allowance set to given proxy of asset.
+    ///         For ERC721 tokens, these values will always be 1 or 0.
+    function getBalanceAndAllowance(address target, bytes memory assetData)
+        public
+        view
+        returns (uint256 balance, uint256 allowance)
+    {
+        bytes4 assetProxyId = assetData.readBytes4(0);
+        address token = assetData.readAddress(16);
+        address assetProxy = EXCHANGE.getAssetProxy(assetProxyId);
+
+        if (assetProxyId == ERC20_DATA_ID) {
+            // Query balance
+            balance = IERC20Token(token).balanceOf(target);
+
+            // Query allowance
+            allowance = IERC20Token(token).allowance(target, assetProxy);
+        } else if (assetProxyId == ERC721_DATA_ID) {
+            uint256 tokenId = assetData.readUint256(36);
+
+            // Query owner of tokenId
+            address owner = getERC721TokenOwner(token, tokenId);
+
+            // Set balance to 1 if tokenId is owned by target
+            balance = target == owner ? 1 : 0;
+
+            // Check if ERC721Proxy is approved to spend tokenId
+            bool isApproved = IERC721Token(token).isApprovedForAll(target, assetProxy) || IERC721Token(token).getApproved(tokenId) == assetProxy;
+            
+            // Set alowance to 1 if ERC721Proxy is approved to spend tokenId
+            allowance = isApproved ? 1 : 0;
+        } else {
+            revert("UNSUPPORTED_ASSET_PROXY");
+        }
+        return (balance, allowance);
+    }
+
+    /// @dev Fetches token balances and allowances of an address for each given assetProxy. Supports ERC20 and ERC721.
+    /// @param target Address to fetch balances and allowances of.
+    /// @param assetData Array of encoded byte arrays that can be decoded by a specified proxy contract when transferring asset.
+    /// @return Balances and allowances of assets.
+    ///         For ERC721 tokens, these values will always be 1 or 0.
+    function getBalancesAndAllowances(address target, bytes[] memory assetData)
+        public
+        view
+        returns (uint256[] memory, uint256[] memory)
+    {
+        uint256 length = assetData.length;
+        uint256[] memory balances = new uint256[](length);
+        uint256[] memory allowances = new uint256[](length);
+        for (uint256 i = 0; i != length; i++) {
+            (balances[i], allowances[i]) = getBalanceAndAllowance(target, assetData[i]);
+        }
+        return (balances, allowances);
+    }
+
+    /// @dev Calls `token.ownerOf(tokenId)`, but returns a null owner instead of reverting on an unowned token.
+    /// @param token Address of ERC721 token.
+    /// @param tokenId The identifier for the specific NFT.
+    /// @return Owner of tokenId or null address if unowned.
+    function getERC721TokenOwner(address token, uint256 tokenId)
+        public
+        view
+        returns (address owner)
+    {
+        assembly {
+            // load free memory pointer
+            let cdStart := mload(64)
+
+            // bytes4(keccak256(ownerOf(uint256))) = 0x6352211e
+            mstore(cdStart, 0x6352211e00000000000000000000000000000000000000000000000000000000)
+            mstore(add(cdStart, 4), tokenId)
+
+            // staticcall `ownerOf(tokenId)`
+            // `ownerOf` will revert if tokenId is not owned
+            let success := staticcall(
+                gas,      // forward all gas
+                token,    // call token contract
+                cdStart,  // start of calldata
+                36,       // length of input is 36 bytes
+                cdStart,  // write output over input
+                32        // size of output is 32 bytes
+            )
+
+            // Success implies that tokenId is owned
+            // Copy owner from return data if successful
+            if success {
+                owner := mload(cdStart)
+            }    
+        }
+
+        // Owner initialized to address(0), no need to modify if call is unsuccessful
+        return owner;
+    }
+}
diff --git a/packages/contracts/src/2.0.0/test/DummyERC20Token/DummyERC20Token.sol b/packages/contracts/src/2.0.0/test/DummyERC20Token/DummyERC20Token.sol
index 9272b18a8..412c5d1ad 100644
--- a/packages/contracts/src/2.0.0/test/DummyERC20Token/DummyERC20Token.sol
+++ b/packages/contracts/src/2.0.0/test/DummyERC20Token/DummyERC20Token.sol
@@ -18,17 +18,18 @@
 
 pragma solidity 0.4.24;
 
-import "../Mintable/Mintable.sol";
 import "../../utils/Ownable/Ownable.sol";
+import "../../tokens/ERC20Token/MintableERC20Token.sol";
 
 
 contract DummyERC20Token is 
-    Mintable,
-    Ownable
+    Ownable,
+    MintableERC20Token
 {
     string public name;
     string public symbol;
     uint256 public decimals;
+    uint256 public constant MAX_MINT_AMOUNT = 10000000000000000000000;
 
     constructor (
         string _name,
@@ -41,20 +42,36 @@ contract DummyERC20Token is
         name = _name;
         symbol = _symbol;
         decimals = _decimals;
-        totalSupply = _totalSupply;
+        _totalSupply = _totalSupply;
         balances[msg.sender] = _totalSupply;
     }
 
+    /// @dev Sets the balance of target address
+    /// @param _target Address or which balance will be updated
+    /// @param _value New balance of target address
     function setBalance(address _target, uint256 _value)
-        public
+        external
         onlyOwner
     {
-        uint256 currBalance = balanceOf(_target);
+        uint256 currBalance = balances[_target];
         if (_value < currBalance) {
-            totalSupply = safeSub(totalSupply, safeSub(currBalance, _value));
+            _totalSupply = safeSub(_totalSupply, safeSub(currBalance, _value));
         } else {
-            totalSupply = safeAdd(totalSupply, safeSub(_value, currBalance));
+            _totalSupply = safeAdd(_totalSupply, safeSub(_value, currBalance));
         }
         balances[_target] = _value;
     }
+
+    /// @dev Mints new tokens for sender
+    /// @param _value Amount of tokens to mint
+    function mint(uint256 _value)
+        external
+    {
+        require(
+            _value <= MAX_MINT_AMOUNT,
+            "VALUE_TOO_LARGE"
+        );
+
+        _mint(msg.sender, _value);
+    }
 }
diff --git a/packages/contracts/src/2.0.0/test/DummyERC20Token/DummyNoReturnERC20Token.sol b/packages/contracts/src/2.0.0/test/DummyERC20Token/DummyNoReturnERC20Token.sol
new file mode 100644
index 000000000..79156d3dd
--- /dev/null
+++ b/packages/contracts/src/2.0.0/test/DummyERC20Token/DummyNoReturnERC20Token.sol
@@ -0,0 +1,116 @@
+/*
+
+  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.24;
+
+import "./DummyERC20Token.sol";
+
+
+// solhint-disable no-empty-blocks
+contract DummyNoReturnERC20Token is
+    DummyERC20Token
+{
+
+    constructor (
+        string _name,
+        string _symbol,
+        uint256 _decimals,
+        uint256 _totalSupply
+    )
+        public
+        DummyERC20Token(
+            _name,
+            _symbol,
+            _decimals,
+            _totalSupply
+        )
+    {}
+
+    /// @dev send `value` token to `to` from `msg.sender`
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    function transfer(address _to, uint256 _value)
+        external
+        returns (bool)
+    {
+        require(
+            balances[msg.sender] >= _value,
+            "ERC20_INSUFFICIENT_BALANCE"
+        );
+        require(
+            balances[_to] + _value >= balances[_to],
+            "UINT256_OVERFLOW"
+        );
+
+        balances[msg.sender] -= _value;
+        balances[_to] += _value;
+
+        emit Transfer(
+            msg.sender,
+            _to,
+            _value
+        );
+
+        // HACK: This contract will not compile if we remove `returns (bool)`, so we manually return no data
+        assembly {
+            return(0, 0)
+        }
+    }
+
+    /// @dev 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
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _value
+    )
+        external
+        returns (bool)
+    {
+        require(
+            balances[_from] >= _value,
+            "ERC20_INSUFFICIENT_BALANCE"
+        );
+        require(
+            allowed[_from][msg.sender] >= _value,
+            "ERC20_INSUFFICIENT_ALLOWANCE"
+        );
+        require(
+            balances[_to] + _value >= balances[_to],
+            "UINT256_OVERFLOW"
+        );
+
+        balances[_to] += _value;
+        balances[_from] -= _value;
+        allowed[_from][msg.sender] -= _value;
+    
+        emit Transfer(
+            _from,
+            _to,
+            _value
+        );
+
+        // HACK: This contract will not compile if we remove `returns (bool)`, so we manually return no data
+        assembly {
+            return(0, 0)
+        }
+    }
+}
+
diff --git a/packages/contracts/src/2.0.0/test/DummyERC721Receiver/DummyERC721Receiver.sol b/packages/contracts/src/2.0.0/test/DummyERC721Receiver/DummyERC721Receiver.sol
index 5dce74a14..ac95e47bd 100644
--- a/packages/contracts/src/2.0.0/test/DummyERC721Receiver/DummyERC721Receiver.sol
+++ b/packages/contracts/src/2.0.0/test/DummyERC721Receiver/DummyERC721Receiver.sol
@@ -1,26 +1,19 @@
 /*
-The MIT License (MIT)
 
-Copyright (c) 2016 Smart Contract Solutions, Inc.
+  Copyright 2018 ZeroEx Intl.
 
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
+  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
 
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
+    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.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 pragma solidity 0.4.24;
@@ -32,33 +25,44 @@ contract DummyERC721Receiver is
     IERC721Receiver
 {
 
+    // Function selector for ERC721Receiver.onERC721Received
+    // 0x150b7a02
+    bytes4 constant internal ERC721_RECEIVED = bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"));
+
     event TokenReceived(
+        address operator,
         address from,
         uint256 tokenId,
         bytes data
     );
 
-    /**
-    * @notice Handle the receipt of an NFT
-    * @dev The ERC721 smart contract calls this function on the recipient
-    *  after a `safetransfer`. This function MAY throw to revert and reject the
-    *  transfer. This function MUST use 50,000 gas or less. Return of other
-    *  than the magic value MUST result in the transaction being reverted.
-    *  Note: the contract address is always the message sender.
-    * @param _from The sending address
-    * @param _tokenId The NFT identifier which is being transfered
-    * @param _data Additional data with no specified format
-    * @return `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
-    */
+    /// @notice Handle the receipt of an NFT
+    /// @dev The ERC721 smart contract calls this function on the recipient
+    ///      after a `transfer`. This function MAY throw to revert and reject the
+    ///      transfer. Return of other than the magic value MUST result in the
+    ///      transaction being reverted.
+    ///      Note: the contract address is always the message sender.
+    /// @param _operator The address which called `safeTransferFrom` function
+    /// @param _from The address which previously owned the token
+    /// @param _tokenId The NFT identifier which is being transferred
+    /// @param _data Additional data with no specified format
+    /// @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
+    ///         unless throwing
     function onERC721Received(
+        address _operator,
         address _from,
         uint256 _tokenId,
         bytes _data
     )
-        public
+        external
         returns (bytes4)
     {
-        emit TokenReceived(_from, _tokenId, _data);
+        emit TokenReceived(
+            _operator,
+            _from,
+            _tokenId,
+            _data
+        );
         return ERC721_RECEIVED;
     }
 }
diff --git a/packages/contracts/src/2.0.0/test/DummyERC721Receiver/InvalidERC721Receiver.sol b/packages/contracts/src/2.0.0/test/DummyERC721Receiver/InvalidERC721Receiver.sol
new file mode 100644
index 000000000..309633bf5
--- /dev/null
+++ b/packages/contracts/src/2.0.0/test/DummyERC721Receiver/InvalidERC721Receiver.sol
@@ -0,0 +1,66 @@
+/*
+
+  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.24;
+
+import "../../tokens/ERC721Token/IERC721Receiver.sol";
+
+
+contract InvalidERC721Receiver is
+    IERC721Receiver
+{
+    // Actual function signature is `onERC721Received(address,address,uint256,bytes)`
+    bytes4 constant internal INVALID_ERC721_RECEIVED = bytes4(keccak256("onERC721Received(address,uint256,bytes)"));
+
+    event TokenReceived(
+        address operator,
+        address from,
+        uint256 tokenId,
+        bytes data
+    );
+
+    /// @notice Handle the receipt of an NFT
+    /// @dev The ERC721 smart contract calls this function on the recipient
+    ///      after a `transfer`. This function MAY throw to revert and reject the
+    ///      transfer. Return of other than the magic value MUST result in the
+    ///      transaction being reverted.
+    ///      Note: the contract address is always the message sender.
+    /// @param _operator The address which called `safeTransferFrom` function
+    /// @param _from The address which previously owned the token
+    /// @param _tokenId The NFT identifier which is being transferred
+    /// @param _data Additional data with no specified format
+    /// @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
+    ///         unless throwing
+    function onERC721Received(
+        address _operator,
+        address _from,
+        uint256 _tokenId,
+        bytes _data
+    )
+        external
+        returns (bytes4)
+    {
+        emit TokenReceived(
+            _operator,
+            _from,
+            _tokenId,
+            _data
+        );
+        return INVALID_ERC721_RECEIVED;
+    }
+}
diff --git a/packages/contracts/src/2.0.0/test/DummyERC721Token/DummyERC721Token.sol b/packages/contracts/src/2.0.0/test/DummyERC721Token/DummyERC721Token.sol
index 627746a52..ac9068d1d 100644
--- a/packages/contracts/src/2.0.0/test/DummyERC721Token/DummyERC721Token.sol
+++ b/packages/contracts/src/2.0.0/test/DummyERC721Token/DummyERC721Token.sol
@@ -18,59 +18,46 @@
 
 pragma solidity 0.4.24;
 
-import "../../tokens/ERC721Token/ERC721Token.sol";
+import "../../tokens/ERC721Token/MintableERC721Token.sol";
 import "../../utils/Ownable/Ownable.sol";
 
 
 // solhint-disable no-empty-blocks
 contract DummyERC721Token is
     Ownable,
-    ERC721Token
+    MintableERC721Token
 {
+    string public name;
+    string public symbol;
 
-    /**
-    * @dev Constructor passes its arguments to the base ERC721Token constructor
-    * @param name of token
-    * @param symbol of token
-    */
     constructor (
-        string name,
-        string symbol
+        string _name,
+        string _symbol
     )
         public
-        ERC721Token(name, symbol)
-    {}
+    {
+        name = _name;
+        symbol = _symbol;
+    }
 
-    /**
-    * @dev Function to mint a new token
-    * @dev Reverts if the given token ID already exists
-    * @param to address the beneficiary that will own the minted token
-    * @param tokenId uint256 ID of the token to be minted by the msg.sender
-    */
-    function mint(address to, uint256 tokenId)
-        public
-        onlyOwner
+    /// @dev Function to mint a new token
+    ///      Reverts if the given token ID already exists
+    /// @param _to Address of the beneficiary that will own the minted token
+    /// @param _tokenId ID of the token to be minted by the msg.sender    
+    function mint(address _to, uint256 _tokenId)
+        external
     {
-        require(
-            !exists(tokenId),
-            "Token with tokenId already exists."
-        );
-        _mint(to, tokenId);
+        _mint(_to, _tokenId);
     }
 
-    /**
-    * @dev Function to burn a token
-    * @dev Reverts if the given token ID doesn't exist
-    * @param tokenId uint256 ID of the token to be minted by the msg.sender
-    */
-    function burn(address owner, uint256 tokenId)
-        public
+    /// @dev Function to burn a token
+    ///      Reverts if the given token ID doesn't exist or not called by contract owner
+    /// @param _owner Owner of token with given token ID
+    /// @param _tokenId ID of the token to be burned by the msg.sender
+    function burn(address _owner, uint256 _tokenId)
+        external
         onlyOwner
     {
-        require(
-            exists(tokenId),
-            "Token with tokenId does not exist."
-        );
-        _burn(owner, tokenId);
+        _burn(_owner, _tokenId);
     }
 }
diff --git a/packages/contracts/src/2.0.0/test/Mintable/Mintable.sol b/packages/contracts/src/2.0.0/test/Mintable/Mintable.sol
deleted file mode 100644
index 767cc8d25..000000000
--- a/packages/contracts/src/2.0.0/test/Mintable/Mintable.sol
+++ /dev/null
@@ -1,43 +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.24;
-
-import "../../tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol";
-import "../../utils/SafeMath/SafeMath.sol";
-
-
-/*
- * Mintable
- * Base contract that creates a mintable UnlimitedAllowanceToken
- */
-contract Mintable is 
-    UnlimitedAllowanceToken,
-    SafeMath
-{
-    function mint(uint256 _value)
-        public
-    {
-        require(
-            _value <= 100000000000000000000,
-            "Minting more than 100000000000000000000 is not allowed."
-        );
-        balances[msg.sender] = safeAdd(_value, balances[msg.sender]);
-        totalSupply = safeAdd(totalSupply, _value);
-    }
-}
diff --git a/packages/contracts/src/2.0.0/tokens/ERC20Token/ERC20Token.sol b/packages/contracts/src/2.0.0/tokens/ERC20Token/ERC20Token.sol
index d9950145d..5ef5ee7ce 100644
--- a/packages/contracts/src/2.0.0/tokens/ERC20Token/ERC20Token.sol
+++ b/packages/contracts/src/2.0.0/tokens/ERC20Token/ERC20Token.sol
@@ -21,15 +21,21 @@ pragma solidity 0.4.24;
 import "./IERC20Token.sol";
 
 
-contract ERC20Token is IERC20Token {
+contract ERC20Token is
+    IERC20Token
+{
 
     mapping (address => uint256) internal balances;
     mapping (address => mapping (address => uint256)) internal allowed;
 
-    uint256 public totalSupply;
+    uint256 internal _totalSupply;
 
+    /// @dev 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 True if transfer was successful
     function transfer(address _to, uint256 _value)
-        public
+        external
         returns (bool)
     {
         require(
@@ -38,16 +44,32 @@ contract ERC20Token is IERC20Token {
         );
         require(
             balances[_to] + _value >= balances[_to],
-            "OVERFLOW"
+            "UINT256_OVERFLOW"
         );
+
         balances[msg.sender] -= _value;
         balances[_to] += _value;
-        emit Transfer(msg.sender, _to, _value);
+
+        emit Transfer(
+            msg.sender,
+            _to,
+            _value
+        );
+
         return true;
     }
 
-    function transferFrom(address _from, address _to, uint256 _value)
-        public
+    /// @dev 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 True if transfer was successful
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _value
+    )
+        external
         returns (bool)
     {
         require(
@@ -60,34 +82,65 @@ contract ERC20Token is IERC20Token {
         );
         require(
             balances[_to] + _value >= balances[_to],
-            "OVERFLOW"
+            "UINT256_OVERFLOW"
         );
+
         balances[_to] += _value;
         balances[_from] -= _value;
         allowed[_from][msg.sender] -= _value;
-        emit Transfer(_from, _to, _value);
+    
+        emit Transfer(
+            _from,
+            _to,
+            _value
+        );
+    
         return true;
     }
 
+    /// @dev `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 Always true if the call has enough gas to complete execution
     function approve(address _spender, uint256 _value)
-        public
+        external
         returns (bool)
     {
         allowed[msg.sender][_spender] = _value;
-        emit Approval(msg.sender, _spender, _value);
+        emit Approval(
+            msg.sender,
+            _spender,
+            _value
+        );
         return true;
     }
 
+    /// @dev Query total supply of token
+    /// @return Total supply of token
+    function totalSupply()
+        external
+        view
+        returns (uint256)
+    {
+        return _totalSupply;
+    }
+
+    /// @dev Query the balance of owner
+    /// @param _owner The address from which the balance will be retrieved
+    /// @return Balance of owner
     function balanceOf(address _owner)
-        public
+        external
         view
         returns (uint256)
     {
         return balances[_owner];
     }
 
+    /// @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
+        external
         view
         returns (uint256)
     {
diff --git a/packages/contracts/src/2.0.0/tokens/ERC20Token/IERC20Token.sol b/packages/contracts/src/2.0.0/tokens/ERC20Token/IERC20Token.sol
index 5ee5e1011..258d47393 100644
--- a/packages/contracts/src/2.0.0/tokens/ERC20Token/IERC20Token.sol
+++ b/packages/contracts/src/2.0.0/tokens/ERC20Token/IERC20Token.sol
@@ -21,54 +21,67 @@ pragma solidity 0.4.24;
 
 contract IERC20Token {
 
-    /// @notice send `value` token to `to` from `msg.sender`
+    // solhint-disable no-simple-event-func-name
+    event Transfer(
+        address indexed _from,
+        address indexed _to,
+        uint256 _value
+    );
+
+    event Approval(
+        address indexed _owner,
+        address indexed _spender,
+        uint256 _value
+    );
+
+    /// @dev 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
+    /// @return True if transfer was successful
     function transfer(address _to, uint256 _value)
-        public
+        external
         returns (bool);
 
-    /// @notice send `value` token to `to` from `from` on the condition it is approved by `from`
+    /// @dev 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, uint256 _value)
-        public
+    /// @return True if transfer was successful
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _value
+    )
+        external
         returns (bool);
     
-    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
+    /// @dev `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
+    /// @return Always true if the call has enough gas to complete execution
     function approve(address _spender, uint256 _value)
-        public
+        external
         returns (bool);
 
+    /// @dev Query total supply of token
+    /// @return Total supply of token
+    function totalSupply()
+        external
+        view
+        returns (uint256);
+    
     /// @param _owner The address from which the balance will be retrieved
-    /// @return The balance
+    /// @return Balance of owner
     function balanceOf(address _owner)
-        public view
+        external
+        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
+        external
+        view
         returns (uint256);
-
-    // solhint-disable-next-line no-simple-event-func-name
-    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/2.0.0/tokens/ERC20Token/MintableERC20Token.sol b/packages/contracts/src/2.0.0/tokens/ERC20Token/MintableERC20Token.sol
new file mode 100644
index 000000000..cd1c7b4bb
--- /dev/null
+++ b/packages/contracts/src/2.0.0/tokens/ERC20Token/MintableERC20Token.sol
@@ -0,0 +1,61 @@
+/*
+
+  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.24;
+
+import "../../utils/SafeMath/SafeMath.sol";
+import "./UnlimitedAllowanceERC20Token.sol";
+
+
+contract MintableERC20Token is 
+    SafeMath,
+    UnlimitedAllowanceERC20Token
+{
+
+    /// @dev Mints new tokens
+    /// @param _to Address of the beneficiary that will own the minted token
+    /// @param _value Amount of tokens to mint
+    function _mint(address _to, uint256 _value)
+        internal
+    {
+        balances[_to] = safeAdd(_value, balances[_to]);
+        _totalSupply = safeAdd(_totalSupply, _value);
+
+        emit Transfer(
+            address(0),
+            _to,
+            _value
+        );
+    }
+
+    /// @dev Mints new tokens
+    /// @param _owner Owner of tokens that will be burned
+    /// @param _value Amount of tokens to burn
+    function _burn(address _owner, uint256 _value)
+        internal
+    {
+        balances[_owner] = safeSub(balances[_owner], _value);
+        _totalSupply = safeSub(_totalSupply, _value);
+
+        emit Transfer(
+            _owner,
+            address(0),
+            _value
+        );
+    }
+}
diff --git a/packages/contracts/src/2.0.0/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol b/packages/contracts/src/2.0.0/tokens/ERC20Token/UnlimitedAllowanceERC20Token.sol
index 9feb5c914..e6f7c063e 100644
--- a/packages/contracts/src/2.0.0/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol
+++ b/packages/contracts/src/2.0.0/tokens/ERC20Token/UnlimitedAllowanceERC20Token.sol
@@ -21,7 +21,9 @@ pragma solidity 0.4.24;
 import "../ERC20Token/ERC20Token.sol";
 
 
-contract UnlimitedAllowanceToken is ERC20Token {
+contract UnlimitedAllowanceERC20Token is
+    ERC20Token
+{
 
     uint256 constant internal MAX_UINT = 2**256 - 1;
 
@@ -30,8 +32,12 @@ contract UnlimitedAllowanceToken is ERC20Token {
     /// @param _to Address to transfer to.
     /// @param _value Amount to transfer.
     /// @return Success of transfer.
-    function transferFrom(address _from, address _to, uint256 _value)
-        public
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _value
+    )
+        external
         returns (bool)
     {
         uint256 allowance = allowed[_from][msg.sender];
@@ -45,14 +51,21 @@ contract UnlimitedAllowanceToken is ERC20Token {
         );
         require(
             balances[_to] + _value >= balances[_to],
-            "OVERFLOW"
+            "UINT256_OVERFLOW"
         );
+
         balances[_to] += _value;
         balances[_from] -= _value;
         if (allowance < MAX_UINT) {
             allowed[_from][msg.sender] -= _value;
         }
-        emit Transfer(_from, _to, _value);
+
+        emit Transfer(
+            _from,
+            _to,
+            _value
+        );
+
         return true;
     }
 }
diff --git a/packages/contracts/src/2.0.0/tokens/ERC721Token/ERC721Token.sol b/packages/contracts/src/2.0.0/tokens/ERC721Token/ERC721Token.sol
index 60603aa19..530f080c0 100644
--- a/packages/contracts/src/2.0.0/tokens/ERC721Token/ERC721Token.sol
+++ b/packages/contracts/src/2.0.0/tokens/ERC721Token/ERC721Token.sol
@@ -1,26 +1,19 @@
 /*
-The MIT License (MIT)
 
-Copyright (c) 2016 Smart Contract Solutions, Inc.
+  Copyright 2018 ZeroEx Intl.
 
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
+  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
 
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
+    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.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 pragma solidity 0.4.24;
@@ -30,179 +23,250 @@ import "./IERC721Receiver.sol";
 import "../../utils/SafeMath/SafeMath.sol";
 
 
-/**
- * @title ERC721 Non-Fungible Token Standard basic implementation
- * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
- * Modified from https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/ERC721/ERC721BasicToken.sol
- */
 contract ERC721Token is
     IERC721Token,
     SafeMath
 {
-    // Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
-    // which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
-    bytes4 constant internal ERC721_RECEIVED = 0xf0b9e5ba;
+    // Function selector for ERC721Receiver.onERC721Received
+    // 0x150b7a02
+    bytes4 constant internal ERC721_RECEIVED = bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"));
 
-    // Mapping from token ID to owner
-    mapping (uint256 => address) internal tokenOwner;
+    // Mapping of tokenId => owner
+    mapping (uint256 => address) internal owners;
 
-    // Mapping from token ID to approved address
-    mapping (uint256 => address) internal tokenApprovals;
+    // Mapping of tokenId => approved address
+    mapping (uint256 => address) internal approvals;
 
-    // Mapping from owner to number of owned token
-    mapping (address => uint256) internal ownedTokensCount;
+    // Mapping of owner => number of tokens owned
+    mapping (address => uint256) internal balances;
 
-    // Mapping from owner to operator approvals
+    // Mapping of owner => operator => approved
     mapping (address => mapping (address => bool)) internal operatorApprovals;
 
-    /**
-    * @dev Guarantees msg.sender is owner of the given token
-    * @param _tokenId uint256 ID of the token to validate its ownership belongs to msg.sender
-    */
-    modifier onlyOwnerOf(uint256 _tokenId) {
-        require(ownerOf(_tokenId) == msg.sender);
-        _;
-    }
-
-    /**
-    * @dev Checks msg.sender can transfer a token, by being owner, approved, or operator
-    * @param _tokenId uint256 ID of the token to validate
-    */
-    modifier canTransfer(uint256 _tokenId) {
-        require(isApprovedOrOwner(msg.sender, _tokenId));
-        _;
+    /// @notice Transfers the ownership of an NFT from one address to another address
+    /// @dev Throws unless `msg.sender` is the current owner, an authorized
+    ///      operator, or the approved address for this NFT. Throws if `_from` is
+    ///      not the current owner. Throws if `_to` is the zero address. Throws if
+    ///      `_tokenId` is not a valid NFT. When transfer is complete, this function
+    ///      checks if `_to` is a smart contract (code size > 0). If so, it calls
+    ///      `onERC721Received` on `_to` and throws if the return value is not
+    ///      `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
+    /// @param _from The current owner of the NFT
+    /// @param _to The new owner
+    /// @param _tokenId The NFT to transfer
+    /// @param _data Additional data with no specified format, sent in call to `_to`
+    function safeTransferFrom(
+        address _from,
+        address _to,
+        uint256 _tokenId,
+        bytes _data
+    )
+        external
+    {
+        transferFrom(
+            _from,
+            _to,
+            _tokenId
+        );
+
+        uint256 receiverCodeSize;
+        assembly {
+            receiverCodeSize := extcodesize(_to)
+        }
+        if (receiverCodeSize > 0) {
+            bytes4 selector = IERC721Receiver(_to).onERC721Received(
+                msg.sender,
+                _from,
+                _tokenId,
+                _data
+            );
+            require(
+                selector == ERC721_RECEIVED,
+                "ERC721_INVALID_SELECTOR"
+            );
+        }
     }
 
-    constructor (
-        string _name,
-        string _symbol)
-        public
+    /// @notice Transfers the ownership of an NFT from one address to another address
+    /// @dev This works identically to the other function with an extra data parameter,
+    ///      except this function just sets data to "".
+    /// @param _from The current owner of the NFT
+    /// @param _to The new owner
+    /// @param _tokenId The NFT to transfer
+    function safeTransferFrom(
+        address _from,
+        address _to,
+        uint256 _tokenId
+    )
+        external
     {
-        name_ = _name;
-        symbol_ = _symbol;
+        transferFrom(
+            _from,
+            _to,
+            _tokenId
+        );
+
+        uint256 receiverCodeSize;
+        assembly {
+            receiverCodeSize := extcodesize(_to)
+        }
+        if (receiverCodeSize > 0) {
+            bytes4 selector = IERC721Receiver(_to).onERC721Received(
+                msg.sender,
+                _from,
+                _tokenId,
+                ""
+            );
+            require(
+                selector == ERC721_RECEIVED,
+                "ERC721_INVALID_SELECTOR"
+            );
+        }
     }
 
-    /**
-    * @dev Gets the token name
-    * @return string representing the token name
-    */
-    function name()
-        public
-        view
-        returns (string)
+    /// @notice Change or reaffirm the approved address for an NFT
+    /// @dev The zero address indicates there is no approved address.
+    ///      Throws unless `msg.sender` is the current NFT owner, or an authorized
+    ///      operator of the current owner.
+    /// @param _approved The new approved NFT controller
+    /// @param _tokenId The NFT to approve
+    function approve(address _approved, uint256 _tokenId)
+        external
     {
-        return name_;
+        address owner = ownerOf(_tokenId);
+        require(
+            msg.sender == owner || isApprovedForAll(owner, msg.sender),
+            "ERC721_INVALID_SENDER"
+        );
+
+        approvals[_tokenId] = _approved;
+        emit Approval(
+            owner,
+            _approved,
+            _tokenId
+        );
     }
 
-    /**
-    * @dev Gets the token symbol
-    * @return string representing the token symbol
-    */
-    function symbol()
-        public
-        view
-        returns (string)
+    /// @notice Enable or disable approval for a third party ("operator") to manage
+    ///         all of `msg.sender`'s assets
+    /// @dev Emits the ApprovalForAll event. The contract MUST allow
+    ///      multiple operators per owner.
+    /// @param _operator Address to add to the set of authorized operators
+    /// @param _approved True if the operator is approved, false to revoke approval
+    function setApprovalForAll(address _operator, bool _approved)
+        external
     {
-        return symbol_;
+        operatorApprovals[msg.sender][_operator] = _approved;
+        emit ApprovalForAll(
+            msg.sender,
+            _operator,
+            _approved
+        );
     }
-
-    /**
-    * @dev Gets the balance of the specified address
-    * @param _owner address to query the balance of
-    * @return uint256 representing the amount owned by the passed address
-    */
+    
+    /// @notice Count all NFTs assigned to an owner
+    /// @dev NFTs assigned to the zero address are considered invalid, and this
+    ///      function throws for queries about the zero address.
+    /// @param _owner An address for whom to query the balance
+    /// @return The number of NFTs owned by `_owner`, possibly zero
     function balanceOf(address _owner)
-        public
+        external
         view
         returns (uint256)
     {
-        require(_owner != address(0));
-        return ownedTokensCount[_owner];
+        require(
+            _owner != address(0),
+            "ERC721_ZERO_OWNER"
+        );
+        return balances[_owner];
     }
 
-    /**
-    * @dev Gets the owner of the specified token ID
-    * @param _tokenId uint256 ID of the token to query the owner of
-    * @return owner address currently marked as the owner of the given token ID
-    */
-    function ownerOf(uint256 _tokenId)
-        public
-        view
-        returns (address)
-    {
-        address owner = tokenOwner[_tokenId];
-        require(owner != address(0));
-        return owner;
-    }
-
-    /**
-    * @dev Returns whether the specified token exists
-    * @param _tokenId uint256 ID of the token to query the existance of
-    * @return whether the token exists
-    */
-    function exists(uint256 _tokenId)
+    /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
+    ///         TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE
+    ///         THEY MAY BE PERMANENTLY LOST
+    /// @dev Throws unless `msg.sender` is the current owner, an authorized
+    ///      operator, or the approved address for this NFT. Throws if `_from` is
+    ///      not the current owner. Throws if `_to` is the zero address. Throws if
+    ///      `_tokenId` is not a valid NFT.
+    /// @param _from The current owner of the NFT
+    /// @param _to The new owner
+    /// @param _tokenId The NFT to transfer
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _tokenId
+    )
         public
-        view
-        returns (bool)
     {
-        address owner = tokenOwner[_tokenId];
-        return owner != address(0);
-    }
+        require(
+            _to != address(0),
+            "ERC721_ZERO_TO_ADDRESS"
+        );
 
-    /**
-    * @dev Approves another address to transfer the given token ID
-    * @dev The zero address indicates there is no approved address.
-    * @dev There can only be one approved address per token at a given time.
-    * @dev Can only be called by the token owner or an approved operator.
-    * @param _to address to be approved for the given token ID
-    * @param _tokenId uint256 ID of the token to be approved
-    */
-    function approve(address _to, uint256 _tokenId)
-        public
-    {
         address owner = ownerOf(_tokenId);
-        require(_to != owner);
-        require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
-
-        if (getApproved(_tokenId) != address(0) || _to != address(0)) {
-            tokenApprovals[_tokenId] = _to;
-            emit Approval(owner, _to, _tokenId);
+        require(
+            _from == owner,
+            "ERC721_OWNER_MISMATCH"
+        );
+
+        address spender = msg.sender;
+        address approvedAddress = getApproved(_tokenId);
+        require(
+            spender == owner ||
+            isApprovedForAll(owner, spender) ||
+            approvedAddress == spender,
+            "ERC721_INVALID_SPENDER"
+        );
+
+        if (approvedAddress != address(0)) {
+            approvals[_tokenId] = address(0);
         }
+
+        owners[_tokenId] = _to;
+        balances[_from] = safeSub(balances[_from], 1);
+        balances[_to] = safeAdd(balances[_to], 1);
+    
+        emit Transfer(
+            _from,
+            _to,
+            _tokenId
+        );
     }
 
-    /**
-    * @dev Gets the approved address for a token ID, or zero if no address set
-    * @param _tokenId uint256 ID of the token to query the approval of
-    * @return address currently approved for a the given token ID
-    */
-    function getApproved(uint256 _tokenId)
+    /// @notice Find the owner of an NFT
+    /// @dev NFTs assigned to zero address are considered invalid, and queries
+    ///      about them do throw.
+    /// @param _tokenId The identifier for an NFT
+    /// @return The address of the owner of the NFT
+    function ownerOf(uint256 _tokenId)
         public
         view
         returns (address)
     {
-        return tokenApprovals[_tokenId];
+        address owner = owners[_tokenId];
+        require(
+            owner != address(0),
+            "ERC721_ZERO_OWNER"
+        );
+        return owner;
     }
 
-    /**
-    * @dev Sets or unsets the approval of a given operator
-    * @dev An operator is allowed to transfer all tokens of the sender on their behalf
-    * @param _to operator address to set the approval
-    * @param _approved representing the status of the approval to be set
-    */
-    function setApprovalForAll(address _to, bool _approved)
+    /// @notice Get the approved address for a single NFT
+    /// @dev Throws if `_tokenId` is not a valid NFT.
+    /// @param _tokenId The NFT to find the approved address for
+    /// @return The approved address for this NFT, or the zero address if there is none
+    function getApproved(uint256 _tokenId)
         public
+        view
+        returns (address)
     {
-        require(_to != msg.sender);
-        operatorApprovals[msg.sender][_to] = _approved;
-        emit ApprovalForAll(msg.sender, _to, _approved);
+        return approvals[_tokenId];
     }
 
-    /**
-    * @dev Tells whether an operator is approved by a given owner
-    * @param _owner owner address which you want to query the approval of
-    * @param _operator operator address which you want to query the approval of
-    * @return bool whether the given operator is approved by the given owner
-    */
+    /// @notice Query if an address is an authorized operator for another address
+    /// @param _owner The address that owns the NFTs
+    /// @param _operator The address that acts on behalf of the owner
+    /// @return True if `_operator` is an approved operator for `_owner`, false otherwise
     function isApprovedForAll(address _owner, address _operator)
         public
         view
@@ -210,198 +274,4 @@ contract ERC721Token is
     {
         return operatorApprovals[_owner][_operator];
     }
-
-    /**
-    * @dev Transfers the ownership of a given token ID to another address
-    * @dev Usage of this method is discouraged, use `safeTransferFrom` whenever possible
-    * @dev Requires the msg sender to be the owner, approved, or operator
-    * @param _from current owner of the token
-    * @param _to address to receive the ownership of the given token ID
-    * @param _tokenId uint256 ID of the token to be transferred
-    */
-    function transferFrom(address _from, address _to, uint256 _tokenId)
-        public
-        canTransfer(_tokenId)
-    {
-        require(_from != address(0));
-        require(_to != address(0));
-
-        clearApproval(_from, _tokenId);
-        removeTokenFrom(_from, _tokenId);
-        addTokenTo(_to, _tokenId);
-
-        emit Transfer(_from, _to, _tokenId);
-    }
-
-    /**
-    * @dev Safely transfers the ownership of a given token ID to another address
-    * @dev If the target address is a contract, it must implement `onERC721Received`,
-    *  which is called upon a safe transfer, and return the magic value
-    *  `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
-    *  the transfer is reverted.
-    * @dev Requires the msg sender to be the owner, approved, or operator
-    * @param _from current owner of the token
-    * @param _to address to receive the ownership of the given token ID
-    * @param _tokenId uint256 ID of the token to be transferred
-    */
-    function safeTransferFrom(
-        address _from,
-        address _to,
-        uint256 _tokenId)
-        public
-        canTransfer(_tokenId)
-    {
-        // solium-disable-next-line arg-overflow
-        safeTransferFrom(_from, _to, _tokenId, "");
-    }
-
-    /**
-    * @dev Safely transfers the ownership of a given token ID to another address
-    * @dev If the target address is a contract, it must implement `onERC721Received`,
-    *  which is called upon a safe transfer, and return the magic value
-    *  `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
-    *  the transfer is reverted.
-    * @dev Requires the msg sender to be the owner, approved, or operator
-    * @param _from current owner of the token
-    * @param _to address to receive the ownership of the given token ID
-    * @param _tokenId uint256 ID of the token to be transferred
-    * @param _data bytes data to send along with a safe transfer check
-    */
-    function safeTransferFrom(
-        address _from,
-        address _to,
-        uint256 _tokenId,
-        bytes _data)
-        public
-        canTransfer(_tokenId)
-    {
-        transferFrom(_from, _to, _tokenId);
-        // solium-disable-next-line arg-overflow
-        require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
-    }
-
-    /**
-    * @dev Returns whether the given spender can transfer a given token ID
-    * @param _spender address of the spender to query
-    * @param _tokenId uint256 ID of the token to be transferred
-    * @return bool whether the msg.sender is approved for the given token ID,
-    *  is an operator of the owner, or is the owner of the token
-    */
-    function isApprovedOrOwner(address _spender, uint256 _tokenId)
-        internal
-        view
-        returns (bool)
-    {
-        address owner = ownerOf(_tokenId);
-        return _spender == owner || getApproved(_tokenId) == _spender || isApprovedForAll(owner, _spender);
-    }
-
-    /**
-    * @dev Internal function to mint a new token
-    * @dev Reverts if the given token ID already exists
-    * @param _to The address that will own the minted token
-    * @param _tokenId uint256 ID of the token to be minted by the msg.sender
-    */
-    function _mint(address _to, uint256 _tokenId)
-        internal
-    {
-        require(_to != address(0));
-        addTokenTo(_to, _tokenId);
-        emit Transfer(address(0), _to, _tokenId);
-    }
-
-    /**
-    * @dev Internal function to burn a specific token
-    * @dev Reverts if the token does not exist
-    * @param _tokenId uint256 ID of the token being burned by the msg.sender
-    */
-    function _burn(address _owner, uint256 _tokenId)
-        internal
-    {
-        clearApproval(_owner, _tokenId);
-        removeTokenFrom(_owner, _tokenId);
-        emit Transfer(_owner, address(0), _tokenId);
-    }
-
-    /**
-    * @dev Internal function to clear current approval of a given token ID
-    * @dev Reverts if the given address is not indeed the owner of the token
-    * @param _owner owner of the token
-    * @param _tokenId uint256 ID of the token to be transferred
-    */
-    function clearApproval(address _owner, uint256 _tokenId)
-        internal
-    {
-        require(ownerOf(_tokenId) == _owner);
-        if (tokenApprovals[_tokenId] != address(0)) {
-            tokenApprovals[_tokenId] = address(0);
-            emit Approval(_owner, address(0), _tokenId);
-        }
-    }
-
-    /**
-    * @dev Internal function to add a token ID to the list of a given address
-    * @param _to address representing the new owner of the given token ID
-    * @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
-    */
-    function addTokenTo(address _to, uint256 _tokenId)
-        internal
-    {
-        require(tokenOwner[_tokenId] == address(0));
-        tokenOwner[_tokenId] = _to;
-        ownedTokensCount[_to] = safeAdd(ownedTokensCount[_to], 1);
-    }
-
-    /**
-    * @dev Internal function to remove a token ID from the list of a given address
-    * @param _from address representing the previous owner of the given token ID
-    * @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
-    */
-    function removeTokenFrom(address _from, uint256 _tokenId)
-        internal
-    {
-        require(ownerOf(_tokenId) == _from);
-        ownedTokensCount[_from] = safeSub(ownedTokensCount[_from], 1);
-        tokenOwner[_tokenId] = address(0);
-    }
-
-    /**
-    * @dev Internal function to invoke `onERC721Received` on a target address
-    * @dev The call is not executed if the target address is not a contract
-    * @param _from address representing the previous owner of the given token ID
-    * @param _to target address that will receive the tokens
-    * @param _tokenId uint256 ID of the token to be transferred
-    * @param _data bytes optional data to send along with the call
-    * @return whether the call correctly returned the expected magic value
-    */
-    function checkAndCallSafeTransfer(
-        address _from,
-        address _to,
-        uint256 _tokenId,
-        bytes _data)
-        internal
-        returns (bool)
-    {
-        if (!isContract(_to)) {
-            return true;
-        }
-        bytes4 retval = IERC721Receiver(_to).onERC721Received(_from, _tokenId, _data);
-        return (retval == ERC721_RECEIVED);
-    }
-
-    function isContract(address addr)
-        internal
-        view
-        returns (bool)
-    {
-        uint256 size;
-        // XXX Currently there is no better way to check if there is a contract in an address
-        // than to check the size of the code at that address.
-        // See https://ethereum.stackexchange.com/a/14016/36603
-        // for more details about how this works.
-        // TODO Check this again before the Serenity release, because all addresses will be
-        // contracts then.
-        assembly { size := extcodesize(addr) }  // solium-disable-line security/no-inline-assembly
-        return size > 0;
-    }
 }
diff --git a/packages/contracts/src/2.0.0/tokens/ERC721Token/IERC721Receiver.sol b/packages/contracts/src/2.0.0/tokens/ERC721Token/IERC721Receiver.sol
index f2e8f3c88..8e0e32ab2 100644
--- a/packages/contracts/src/2.0.0/tokens/ERC721Token/IERC721Receiver.sol
+++ b/packages/contracts/src/2.0.0/tokens/ERC721Token/IERC721Receiver.sol
@@ -1,61 +1,44 @@
 /*
-The MIT License (MIT)
-
-Copyright (c) 2016 Smart Contract Solutions, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+  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.24;
 
 
-/**
- * @title ERC721 token receiver interface
- * @dev Interface for any contract that wants to support safeTransfers
- *      rom ERC721 asset contracts.
- * Modified from https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/ERC721/ERC721Receiver.sol
- */
 contract IERC721Receiver {
-    /**
-    * @dev Magic value to be returned upon successful reception of an NFT
-    *  Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`,
-    *  which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
-    */
-    bytes4 constant internal ERC721_RECEIVED = 0xf0b9e5ba;
-
-    /**
-    * @notice Handle the receipt of an NFT
-    * @dev The ERC721 smart contract calls this function on the recipient
-    *  after a `safetransfer`. This function MAY throw to revert and reject the
-    *  transfer. This function MUST use 50,000 gas or less. Return of other
-    *  than the magic value MUST result in the transaction being reverted.
-    *  Note: the contract address is always the message sender.
-    * @param _from The sending address
-    * @param _tokenId The NFT identifier which is being transfered
-    * @param _data Additional data with no specified format
-    * @return `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
-    */
+
+    /// @notice Handle the receipt of an NFT
+    /// @dev The ERC721 smart contract calls this function on the recipient
+    ///  after a `transfer`. This function MAY throw to revert and reject the
+    ///  transfer. Return of other than the magic value MUST result in the
+    ///  transaction being reverted.
+    ///  Note: the contract address is always the message sender.
+    /// @param _operator The address which called `safeTransferFrom` function
+    /// @param _from The address which previously owned the token
+    /// @param _tokenId The NFT identifier which is being transferred
+    /// @param _data Additional data with no specified format
+    /// @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
+    ///  unless throwing
     function onERC721Received(
+        address _operator,
         address _from,
         uint256 _tokenId,
-        bytes _data)
-        public
+        bytes _data
+    )
+        external
         returns (bytes4);
 }
diff --git a/packages/contracts/src/2.0.0/tokens/ERC721Token/IERC721Token.sol b/packages/contracts/src/2.0.0/tokens/ERC721Token/IERC721Token.sol
index 4d57ece38..ac992c80d 100644
--- a/packages/contracts/src/2.0.0/tokens/ERC721Token/IERC721Token.sol
+++ b/packages/contracts/src/2.0.0/tokens/ERC721Token/IERC721Token.sol
@@ -1,118 +1,158 @@
 /*
-The MIT License (MIT)
-
-Copyright (c) 2016 Smart Contract Solutions, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+  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.24;
 
 
-/**
- * @title ERC721 Non-Fungible Token Standard basic interface
- * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
- * Modified from https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/ERC721/ERC721Basic.sol
- */
 contract IERC721Token {
-    string internal name_;
-    string internal symbol_;
 
+    /// @dev This emits when ownership of any NFT changes by any mechanism.
+    ///      This event emits when NFTs are created (`from` == 0) and destroyed
+    ///      (`to` == 0). Exception: during contract creation, any number of NFTs
+    ///      may be created and assigned without emitting Transfer. At the time of
+    ///      any transfer, the approved address for that NFT (if any) is reset to none.
     event Transfer(
         address indexed _from,
         address indexed _to,
-        uint256 _tokenId
+        uint256 indexed _tokenId
     );
 
+    /// @dev This emits when the approved address for an NFT is changed or
+    ///      reaffirmed. The zero address indicates there is no approved address.
+    ///      When a Transfer event emits, this also indicates that the approved
+    ///      address for that NFT (if any) is reset to none.
     event Approval(
         address indexed _owner,
         address indexed _approved,
-        uint256 _tokenId
+        uint256 indexed _tokenId
     );
 
+    /// @dev This emits when an operator is enabled or disabled for an owner.
+    ///      The operator can manage all NFTs of the owner.
     event ApprovalForAll(
         address indexed _owner,
         address indexed _operator,
         bool _approved
     );
 
-    function name()
-        public
-        view
-        returns (string);
-
-    function symbol()
-        public
-        view
-        returns (string);
+    /// @notice Transfers the ownership of an NFT from one address to another address
+    /// @dev Throws unless `msg.sender` is the current owner, an authorized
+    ///      perator, or the approved address for this NFT. Throws if `_from` is
+    ///      not the current owner. Throws if `_to` is the zero address. Throws if
+    ///      `_tokenId` is not a valid NFT. When transfer is complete, this function
+    ///      checks if `_to` is a smart contract (code size > 0). If so, it calls
+    ///      `onERC721Received` on `_to` and throws if the return value is not
+    ///      `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
+    /// @param _from The current owner of the NFT
+    /// @param _to The new owner
+    /// @param _tokenId The NFT to transfer
+    /// @param _data Additional data with no specified format, sent in call to `_to`
+    function safeTransferFrom(
+        address _from,
+        address _to,
+        uint256 _tokenId,
+        bytes _data
+    )
+        external;
+
+    /// @notice Transfers the ownership of an NFT from one address to another address
+    /// @dev This works identically to the other function with an extra data parameter,
+    ///      except this function just sets data to "".
+    /// @param _from The current owner of the NFT
+    /// @param _to The new owner
+    /// @param _tokenId The NFT to transfer
+    function safeTransferFrom(
+        address _from,
+        address _to,
+        uint256 _tokenId
+    )
+        external;
+
+    /// @notice Change or reaffirm the approved address for an NFT
+    /// @dev The zero address indicates there is no approved address.
+    ///      Throws unless `msg.sender` is the current NFT owner, or an authorized
+    ///      operator of the current owner.
+    /// @param _approved The new approved NFT controller
+    /// @param _tokenId The NFT to approve
+    function approve(address _approved, uint256 _tokenId)
+        external;
+
+    /// @notice Enable or disable approval for a third party ("operator") to manage
+    ///         all of `msg.sender`'s assets
+    /// @dev Emits the ApprovalForAll event. The contract MUST allow
+    ///      multiple operators per owner.
+    /// @param _operator Address to add to the set of authorized operators
+    /// @param _approved True if the operator is approved, false to revoke approval
+    function setApprovalForAll(address _operator, bool _approved)
+        external;
 
+    /// @notice Count all NFTs assigned to an owner
+    /// @dev NFTs assigned to the zero address are considered invalid, and this
+    ///      function throws for queries about the zero address.
+    /// @param _owner An address for whom to query the balance
+    /// @return The number of NFTs owned by `_owner`, possibly zero
     function balanceOf(address _owner)
-        public
+        external
         view
-        returns (uint256 _balance);
+        returns (uint256);
+
+    /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
+    ///         TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE
+    ///         THEY MAY BE PERMANENTLY LOST
+    /// @dev Throws unless `msg.sender` is the current owner, an authorized
+    ///      operator, or the approved address for this NFT. Throws if `_from` is
+    ///      not the current owner. Throws if `_to` is the zero address. Throws if
+    ///      `_tokenId` is not a valid NFT.
+    /// @param _from The current owner of the NFT
+    /// @param _to The new owner
+    /// @param _tokenId The NFT to transfer
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _tokenId
+    )
+        public;
 
+    /// @notice Find the owner of an NFT
+    /// @dev NFTs assigned to zero address are considered invalid, and queries
+    ///      about them do throw.
+    /// @param _tokenId The identifier for an NFT
+    /// @return The address of the owner of the NFT
     function ownerOf(uint256 _tokenId)
         public
         view
-        returns (address _owner);
+        returns (address);
 
-    function exists(uint256 _tokenId)
+    /// @notice Get the approved address for a single NFT
+    /// @dev Throws if `_tokenId` is not a valid NFT.
+    /// @param _tokenId The NFT to find the approved address for
+    /// @return The approved address for this NFT, or the zero address if there is none
+    function getApproved(uint256 _tokenId) 
         public
         view
-        returns (bool _exists);
-
-    function approve(address _to, uint256 _tokenId)
-        public;
-
-    function getApproved(uint256 _tokenId)
-        public
-        view
-        returns (address _operator);
-
-    function setApprovalForAll(address _operator, bool _approved)
-        public;
-
+        returns (address);
+    
+    /// @notice Query if an address is an authorized operator for another address
+    /// @param _owner The address that owns the NFTs
+    /// @param _operator The address that acts on behalf of the owner
+    /// @return True if `_operator` is an approved operator for `_owner`, false otherwise
     function isApprovedForAll(address _owner, address _operator)
         public
         view
         returns (bool);
-
-    function transferFrom(
-        address _from,
-        address _to,
-        uint256 _tokenId
-    )
-        public;
-
-    function safeTransferFrom(
-        address _from,
-        address _to,
-        uint256 _tokenId
-    )
-        public;
-
-    function safeTransferFrom(
-        address _from,
-        address _to,
-        uint256 _tokenId,
-        bytes _data
-    )
-        public;
 }
diff --git a/packages/contracts/src/2.0.0/tokens/ERC721Token/MintableERC721Token.sol b/packages/contracts/src/2.0.0/tokens/ERC721Token/MintableERC721Token.sol
new file mode 100644
index 000000000..85d192779
--- /dev/null
+++ b/packages/contracts/src/2.0.0/tokens/ERC721Token/MintableERC721Token.sol
@@ -0,0 +1,83 @@
+/*
+
+  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.24;
+
+import "./ERC721Token.sol";
+
+
+contract MintableERC721Token is
+    ERC721Token
+{
+
+    /// @dev Function to mint a new token
+    ///      Reverts if the given token ID already exists
+    /// @param _to Address of the beneficiary that will own the minted token
+    /// @param _tokenId ID of the token to be minted by the msg.sender    
+    function _mint(address _to, uint256 _tokenId)
+        internal
+    {
+        require(
+            _to != address(0),
+            "ERC721_ZERO_TO_ADDRESS"
+        );
+
+        address owner = owners[_tokenId];
+        require(
+            owner == address(0),
+            "ERC721_OWNER_ALREADY_EXISTS"
+        );
+
+        owners[_tokenId] = _to;
+        balances[_to] = safeAdd(balances[_to], 1);
+
+        emit Transfer(
+            address(0),
+            _to,
+            _tokenId
+        );
+    }
+
+    /// @dev Function to burn a token
+    ///      Reverts if the given token ID doesn't exist
+    /// @param _owner Owner of token with given token ID
+    /// @param _tokenId ID of the token to be burned by the msg.sender
+    function _burn(address _owner, uint256 _tokenId)
+        internal
+    {
+        require(
+            _owner != address(0),
+            "ERC721_ZERO_OWNER_ADDRESS"
+        );
+
+        address owner = owners[_tokenId];
+        require(
+            owner == _owner,
+            "ERC721_OWNER_MISMATCH"
+        );
+
+        owners[_tokenId] = address(0);
+        balances[_owner] = safeSub(balances[_owner], 1);
+
+        emit Transfer(
+            _owner,
+            address(0),
+            _tokenId
+        );
+    }
+}
diff --git a/packages/contracts/test/asset_proxy/proxies.ts b/packages/contracts/test/asset_proxy/proxies.ts
index 62215f08d..76a020222 100644
--- a/packages/contracts/test/asset_proxy/proxies.ts
+++ b/packages/contracts/test/asset_proxy/proxies.ts
@@ -261,7 +261,7 @@ describe('Asset Transfer Proxies', () => {
                     erc721Receiver.address,
                     amount,
                 );
-                const logDecoder = new LogDecoder(web3Wrapper, erc721Receiver.address);
+                const logDecoder = new LogDecoder(web3Wrapper);
                 const tx = await logDecoder.getTxWithDecodedLogsAsync(
                     await web3Wrapper.sendTransactionAsync({
                         to: erc721Proxy.address,
@@ -271,7 +271,7 @@ describe('Asset Transfer Proxies', () => {
                     }),
                 );
                 // Verify that no log was emitted by erc721 receiver
-                expect(tx.logs.length).to.be.equal(0);
+                expect(tx.logs.length).to.be.equal(1);
                 // Verify transfer was successful
                 const newOwnerMakerAsset = await erc721Token.ownerOf.callAsync(erc721MakerTokenId);
                 expect(newOwnerMakerAsset).to.be.bignumber.equal(erc721Receiver.address);
diff --git a/packages/contracts/test/exchange/core.ts b/packages/contracts/test/exchange/core.ts
index b324988cc..bc2bad749 100644
--- a/packages/contracts/test/exchange/core.ts
+++ b/packages/contracts/test/exchange/core.ts
@@ -10,6 +10,7 @@ import * as _ from 'lodash';
 
 import { DummyERC20TokenContract } from '../../generated_contract_wrappers/dummy_erc20_token';
 import { DummyERC721TokenContract } from '../../generated_contract_wrappers/dummy_erc721_token';
+import { DummyNoReturnERC20TokenContract } from '../../generated_contract_wrappers/dummy_no_return_erc20_token';
 import { ERC20ProxyContract } from '../../generated_contract_wrappers/erc20_proxy';
 import { ERC721ProxyContract } from '../../generated_contract_wrappers/erc721_proxy';
 import { ExchangeCancelEventArgs, ExchangeContract } from '../../generated_contract_wrappers/exchange';
@@ -39,6 +40,7 @@ describe('Exchange core', () => {
     let erc20TokenB: DummyERC20TokenContract;
     let zrxToken: DummyERC20TokenContract;
     let erc721Token: DummyERC721TokenContract;
+    let noReturnErc20Token: DummyNoReturnERC20TokenContract;
     let exchange: ExchangeContract;
     let erc20Proxy: ERC20ProxyContract;
     let erc721Proxy: ERC721ProxyContract;
@@ -161,6 +163,137 @@ describe('Exchange core', () => {
         });
     });
 
+    describe('Testing exchange of ERC20 tokens with no return values', () => {
+        before(async () => {
+            noReturnErc20Token = await DummyNoReturnERC20TokenContract.deployFrom0xArtifactAsync(
+                artifacts.DummyNoReturnERC20Token,
+                provider,
+                txDefaults,
+                constants.DUMMY_TOKEN_NAME,
+                constants.DUMMY_TOKEN_SYMBOL,
+                constants.DUMMY_TOKEN_DECIMALS,
+                constants.DUMMY_TOKEN_TOTAL_SUPPLY,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await noReturnErc20Token.setBalance.sendTransactionAsync(makerAddress, constants.INITIAL_ERC20_BALANCE),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await noReturnErc20Token.approve.sendTransactionAsync(
+                    erc20Proxy.address,
+                    constants.INITIAL_ERC20_ALLOWANCE,
+                    { from: makerAddress },
+                ),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+        });
+        it('should transfer the correct amounts when makerAssetAmount === takerAssetAmount', async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync({
+                makerAssetData: assetDataUtils.encodeERC20AssetData(noReturnErc20Token.address),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
+            });
+
+            const initialMakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+            const initialMakerBalanceB = await erc20TokenB.balanceOf.callAsync(makerAddress);
+            const initialMakerZrxBalance = await zrxToken.balanceOf.callAsync(makerAddress);
+            const initialTakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+            const initialTakerBalanceB = await erc20TokenB.balanceOf.callAsync(takerAddress);
+            const initialTakerZrxBalance = await zrxToken.balanceOf.callAsync(takerAddress);
+            const initialFeeRecipientZrxBalance = await zrxToken.balanceOf.callAsync(feeRecipientAddress);
+
+            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress);
+
+            const finalMakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+            const finalMakerBalanceB = await erc20TokenB.balanceOf.callAsync(makerAddress);
+            const finalMakerZrxBalance = await zrxToken.balanceOf.callAsync(makerAddress);
+            const finalTakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+            const finalTakerBalanceB = await erc20TokenB.balanceOf.callAsync(takerAddress);
+            const finalTakerZrxBalance = await zrxToken.balanceOf.callAsync(takerAddress);
+            const finalFeeRecipientZrxBalance = await zrxToken.balanceOf.callAsync(feeRecipientAddress);
+
+            expect(finalMakerBalanceA).to.be.bignumber.equal(initialMakerBalanceA.minus(signedOrder.makerAssetAmount));
+            expect(finalMakerBalanceB).to.be.bignumber.equal(initialMakerBalanceB.plus(signedOrder.takerAssetAmount));
+            expect(finalTakerBalanceA).to.be.bignumber.equal(initialTakerBalanceA.plus(signedOrder.makerAssetAmount));
+            expect(finalTakerBalanceB).to.be.bignumber.equal(initialTakerBalanceB.minus(signedOrder.takerAssetAmount));
+            expect(finalMakerZrxBalance).to.be.bignumber.equal(initialMakerZrxBalance.minus(signedOrder.makerFee));
+            expect(finalTakerZrxBalance).to.be.bignumber.equal(initialTakerZrxBalance.minus(signedOrder.takerFee));
+            expect(finalFeeRecipientZrxBalance).to.be.bignumber.equal(
+                initialFeeRecipientZrxBalance.plus(signedOrder.makerFee.plus(signedOrder.takerFee)),
+            );
+        });
+        it('should transfer the correct amounts when makerAssetAmount > takerAssetAmount', async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync({
+                makerAssetData: assetDataUtils.encodeERC20AssetData(noReturnErc20Token.address),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
+            });
+
+            const initialMakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+            const initialMakerBalanceB = await erc20TokenB.balanceOf.callAsync(makerAddress);
+            const initialMakerZrxBalance = await zrxToken.balanceOf.callAsync(makerAddress);
+            const initialTakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+            const initialTakerBalanceB = await erc20TokenB.balanceOf.callAsync(takerAddress);
+            const initialTakerZrxBalance = await zrxToken.balanceOf.callAsync(takerAddress);
+            const initialFeeRecipientZrxBalance = await zrxToken.balanceOf.callAsync(feeRecipientAddress);
+
+            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress);
+
+            const finalMakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+            const finalMakerBalanceB = await erc20TokenB.balanceOf.callAsync(makerAddress);
+            const finalMakerZrxBalance = await zrxToken.balanceOf.callAsync(makerAddress);
+            const finalTakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+            const finalTakerBalanceB = await erc20TokenB.balanceOf.callAsync(takerAddress);
+            const finalTakerZrxBalance = await zrxToken.balanceOf.callAsync(takerAddress);
+            const finalFeeRecipientZrxBalance = await zrxToken.balanceOf.callAsync(feeRecipientAddress);
+
+            expect(finalMakerBalanceA).to.be.bignumber.equal(initialMakerBalanceA.minus(signedOrder.makerAssetAmount));
+            expect(finalMakerBalanceB).to.be.bignumber.equal(initialMakerBalanceB.plus(signedOrder.takerAssetAmount));
+            expect(finalTakerBalanceA).to.be.bignumber.equal(initialTakerBalanceA.plus(signedOrder.makerAssetAmount));
+            expect(finalTakerBalanceB).to.be.bignumber.equal(initialTakerBalanceB.minus(signedOrder.takerAssetAmount));
+            expect(finalMakerZrxBalance).to.be.bignumber.equal(initialMakerZrxBalance.minus(signedOrder.makerFee));
+            expect(finalTakerZrxBalance).to.be.bignumber.equal(initialTakerZrxBalance.minus(signedOrder.takerFee));
+            expect(finalFeeRecipientZrxBalance).to.be.bignumber.equal(
+                initialFeeRecipientZrxBalance.plus(signedOrder.makerFee.plus(signedOrder.takerFee)),
+            );
+        });
+        it('should transfer the correct amounts when makerAssetAmount < takerAssetAmount', async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync({
+                makerAssetData: assetDataUtils.encodeERC20AssetData(noReturnErc20Token.address),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18),
+            });
+
+            const initialMakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+            const initialMakerBalanceB = await erc20TokenB.balanceOf.callAsync(makerAddress);
+            const initialMakerZrxBalance = await zrxToken.balanceOf.callAsync(makerAddress);
+            const initialTakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+            const initialTakerBalanceB = await erc20TokenB.balanceOf.callAsync(takerAddress);
+            const initialTakerZrxBalance = await zrxToken.balanceOf.callAsync(takerAddress);
+            const initialFeeRecipientZrxBalance = await zrxToken.balanceOf.callAsync(feeRecipientAddress);
+
+            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress);
+
+            const finalMakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(makerAddress);
+            const finalMakerBalanceB = await erc20TokenB.balanceOf.callAsync(makerAddress);
+            const finalMakerZrxBalance = await zrxToken.balanceOf.callAsync(makerAddress);
+            const finalTakerBalanceA = await noReturnErc20Token.balanceOf.callAsync(takerAddress);
+            const finalTakerBalanceB = await erc20TokenB.balanceOf.callAsync(takerAddress);
+            const finalTakerZrxBalance = await zrxToken.balanceOf.callAsync(takerAddress);
+            const finalFeeRecipientZrxBalance = await zrxToken.balanceOf.callAsync(feeRecipientAddress);
+
+            expect(finalMakerBalanceA).to.be.bignumber.equal(initialMakerBalanceA.minus(signedOrder.makerAssetAmount));
+            expect(finalMakerBalanceB).to.be.bignumber.equal(initialMakerBalanceB.plus(signedOrder.takerAssetAmount));
+            expect(finalTakerBalanceA).to.be.bignumber.equal(initialTakerBalanceA.plus(signedOrder.makerAssetAmount));
+            expect(finalTakerBalanceB).to.be.bignumber.equal(initialTakerBalanceB.minus(signedOrder.takerAssetAmount));
+            expect(finalMakerZrxBalance).to.be.bignumber.equal(initialMakerZrxBalance.minus(signedOrder.makerFee));
+            expect(finalTakerZrxBalance).to.be.bignumber.equal(initialTakerZrxBalance.minus(signedOrder.takerFee));
+            expect(finalFeeRecipientZrxBalance).to.be.bignumber.equal(
+                initialFeeRecipientZrxBalance.plus(signedOrder.makerFee.plus(signedOrder.takerFee)),
+            );
+        });
+    });
+
     describe('cancelOrder', () => {
         beforeEach(async () => {
             erc20Balances = await erc20Wrapper.getBalancesAsync();
diff --git a/packages/contracts/test/exchange/dispatcher.ts b/packages/contracts/test/exchange/dispatcher.ts
index 81d142ca4..81871a680 100644
--- a/packages/contracts/test/exchange/dispatcher.ts
+++ b/packages/contracts/test/exchange/dispatcher.ts
@@ -145,7 +145,7 @@ describe('AssetProxyDispatcher', () => {
         });
 
         it('should log an event with correct arguments when an asset proxy is registered', async () => {
-            const logDecoder = new LogDecoder(web3Wrapper, assetProxyDispatcher.address);
+            const logDecoder = new LogDecoder(web3Wrapper);
             const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
                 await assetProxyDispatcher.registerAssetProxy.sendTransactionAsync(erc20Proxy.address, { from: owner }),
             );
diff --git a/packages/contracts/test/exchange/fill_order.ts b/packages/contracts/test/exchange/fill_order.ts
index e79e2239e..b1e08324f 100644
--- a/packages/contracts/test/exchange/fill_order.ts
+++ b/packages/contracts/test/exchange/fill_order.ts
@@ -231,7 +231,7 @@ describe('FillOrder Tests', () => {
         });
     });
 
-    describe('Testing Exchange of ERC721 Tokens', () => {
+    describe('Testing exchange of ERC721 Tokens', () => {
         it('should successfully exchange a single token between the maker and taker (via fillOrder)', async () => {
             const fillScenario = {
                 ...defaultFillScenario,
diff --git a/packages/contracts/test/exchange/signature_validator.ts b/packages/contracts/test/exchange/signature_validator.ts
index 7bac2bdef..e95b70b62 100644
--- a/packages/contracts/test/exchange/signature_validator.ts
+++ b/packages/contracts/test/exchange/signature_validator.ts
@@ -65,7 +65,7 @@ describe('MixinSignatureValidator', () => {
             txDefaults,
             signerAddress,
         );
-        signatureValidatorLogDecoder = new LogDecoder(web3Wrapper, signatureValidator.address);
+        signatureValidatorLogDecoder = new LogDecoder(web3Wrapper);
         await web3Wrapper.awaitTransactionSuccessAsync(
             await signatureValidator.setSignatureValidatorApproval.sendTransactionAsync(testValidator.address, true, {
                 from: signerAddress,
diff --git a/packages/contracts/test/forwarder/forwarder.ts b/packages/contracts/test/extensions/forwarder.ts
index 28ffdeabe..18101d684 100644
--- a/packages/contracts/test/forwarder/forwarder.ts
+++ b/packages/contracts/test/extensions/forwarder.ts
@@ -131,8 +131,6 @@ describe(ContractName.Forwarder, () => {
             provider,
             txDefaults,
             exchangeInstance.address,
-            wethContract.address,
-            zrxToken.address,
             zrxAssetData,
             wethAssetData,
         );
diff --git a/packages/contracts/test/extensions/order_validator.ts b/packages/contracts/test/extensions/order_validator.ts
new file mode 100644
index 000000000..3a57cfc37
--- /dev/null
+++ b/packages/contracts/test/extensions/order_validator.ts
@@ -0,0 +1,600 @@
+import { BlockchainLifecycle } from '@0xproject/dev-utils';
+import { assetDataUtils, orderHashUtils } from '@0xproject/order-utils';
+import { SignedOrder } from '@0xproject/types';
+import { BigNumber } from '@0xproject/utils';
+import * as chai from 'chai';
+import * as _ from 'lodash';
+
+import { DummyERC20TokenContract } from '../../generated_contract_wrappers/dummy_erc20_token';
+import { DummyERC721TokenContract } from '../../generated_contract_wrappers/dummy_erc721_token';
+import { ERC20ProxyContract } from '../../generated_contract_wrappers/erc20_proxy';
+import { ERC721ProxyContract } from '../../generated_contract_wrappers/erc721_proxy';
+import { ExchangeContract } from '../../generated_contract_wrappers/exchange';
+import { OrderValidatorContract } from '../../generated_contract_wrappers/order_validator';
+import { artifacts } from '../utils/artifacts';
+import { chaiSetup } from '../utils/chai_setup';
+import { constants } from '../utils/constants';
+import { ERC20Wrapper } from '../utils/erc20_wrapper';
+import { ERC721Wrapper } from '../utils/erc721_wrapper';
+import { ExchangeWrapper } from '../utils/exchange_wrapper';
+import { OrderFactory } from '../utils/order_factory';
+import { OrderStatus } from '../utils/types';
+import { provider, txDefaults, web3Wrapper } from '../utils/web3_wrapper';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+describe('OrderValidator', () => {
+    let makerAddress: string;
+    let owner: string;
+    let takerAddress: string;
+    let erc20AssetData: string;
+    let erc721AssetData: string;
+
+    let erc20Token: DummyERC20TokenContract;
+    let zrxToken: DummyERC20TokenContract;
+    let erc721Token: DummyERC721TokenContract;
+    let exchange: ExchangeContract;
+    let orderValidator: OrderValidatorContract;
+    let erc20Proxy: ERC20ProxyContract;
+    let erc721Proxy: ERC721ProxyContract;
+
+    let signedOrder: SignedOrder;
+    let signedOrder2: SignedOrder;
+    let orderFactory: OrderFactory;
+
+    const tokenId = new BigNumber(123456789);
+    const tokenId2 = new BigNumber(987654321);
+    const ERC721_BALANCE = new BigNumber(1);
+    const ERC721_ALLOWANCE = new BigNumber(1);
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    before(async () => {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        const usedAddresses = ([owner, makerAddress, takerAddress] = _.slice(accounts, 0, 3));
+
+        const erc20Wrapper = new ERC20Wrapper(provider, usedAddresses, owner);
+        const erc721Wrapper = new ERC721Wrapper(provider, usedAddresses, owner);
+
+        const numDummyErc20ToDeploy = 2;
+        [erc20Token, zrxToken] = await erc20Wrapper.deployDummyTokensAsync(
+            numDummyErc20ToDeploy,
+            constants.DUMMY_TOKEN_DECIMALS,
+        );
+        erc20Proxy = await erc20Wrapper.deployProxyAsync();
+
+        [erc721Token] = await erc721Wrapper.deployDummyTokensAsync();
+        erc721Proxy = await erc721Wrapper.deployProxyAsync();
+
+        const zrxAssetData = assetDataUtils.encodeERC20AssetData(zrxToken.address);
+        exchange = await ExchangeContract.deployFrom0xArtifactAsync(
+            artifacts.Exchange,
+            provider,
+            txDefaults,
+            zrxAssetData,
+        );
+        const exchangeWrapper = new ExchangeWrapper(exchange, provider);
+        await exchangeWrapper.registerAssetProxyAsync(erc20Proxy.address, owner);
+        await exchangeWrapper.registerAssetProxyAsync(erc721Proxy.address, owner);
+
+        orderValidator = await OrderValidatorContract.deployFrom0xArtifactAsync(
+            artifacts.OrderValidator,
+            provider,
+            txDefaults,
+            exchange.address,
+            zrxAssetData,
+        );
+
+        erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
+        erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, tokenId);
+        const defaultOrderParams = {
+            ...constants.STATIC_ORDER_PARAMS,
+            exchangeAddress: exchange.address,
+            makerAddress,
+            feeRecipientAddress: constants.NULL_ADDRESS,
+            makerAssetData: erc20AssetData,
+            takerAssetData: erc721AssetData,
+        };
+        const privateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
+        orderFactory = new OrderFactory(privateKey, defaultOrderParams);
+    });
+
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    describe('getBalanceAndAllowance', () => {
+        describe('getERC721TokenOwner', async () => {
+            it('should return the null address when tokenId is not owned', async () => {
+                const tokenOwner = await orderValidator.getERC721TokenOwner.callAsync(makerAddress, tokenId);
+                expect(tokenOwner).to.be.equal(constants.NULL_ADDRESS);
+            });
+            it('should return the owner address when tokenId is owned', async () => {
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc721Token.mint.sendTransactionAsync(makerAddress, tokenId),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const tokenOwner = await orderValidator.getERC721TokenOwner.callAsync(erc721Token.address, tokenId);
+                expect(tokenOwner).to.be.equal(makerAddress);
+            });
+        });
+        describe('ERC20 assetData', () => {
+            it('should return the correct balances and allowances when both values are 0', async () => {
+                const [newBalance, newAllowance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc20AssetData,
+                );
+                expect(constants.ZERO_AMOUNT).to.be.bignumber.equal(newBalance);
+                expect(constants.ZERO_AMOUNT).to.be.bignumber.equal(newAllowance);
+            });
+            it('should return the correct balance and allowance when both values are non-zero', async () => {
+                const balance = new BigNumber(123);
+                const allowance = new BigNumber(456);
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc20Token.setBalance.sendTransactionAsync(makerAddress, balance),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc20Token.approve.sendTransactionAsync(erc20Proxy.address, allowance, {
+                        from: makerAddress,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const [newBalance, newAllowance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc20AssetData,
+                );
+                expect(balance).to.be.bignumber.equal(newBalance);
+                expect(allowance).to.be.bignumber.equal(newAllowance);
+            });
+        });
+        describe('ERC721 assetData', () => {
+            it('should return a balance of 0 when the tokenId is not owned by target', async () => {
+                const [newBalance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc721AssetData,
+                );
+                expect(newBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            });
+            it('should return an allowance of 0 when no approval is set', async () => {
+                const [, newAllowance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc721AssetData,
+                );
+                expect(newAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            });
+            it('should return a balance of 1 when the tokenId is owned by target', async () => {
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc721Token.mint.sendTransactionAsync(makerAddress, tokenId),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const [newBalance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc721AssetData,
+                );
+                expect(newBalance).to.be.bignumber.equal(ERC721_BALANCE);
+            });
+            it('should return an allowance of 1 when ERC721Proxy is approved for all', async () => {
+                const isApproved = true;
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc721Token.setApprovalForAll.sendTransactionAsync(erc721Proxy.address, isApproved, {
+                        from: makerAddress,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const [, newAllowance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc721AssetData,
+                );
+                expect(newAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            });
+            it('should return an allowance of 1 when ERC721Proxy is approved for specific tokenId', async () => {
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc721Token.mint.sendTransactionAsync(makerAddress, tokenId),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                await web3Wrapper.awaitTransactionSuccessAsync(
+                    await erc721Token.approve.sendTransactionAsync(erc721Proxy.address, tokenId, {
+                        from: makerAddress,
+                    }),
+                    constants.AWAIT_TRANSACTION_MINED_MS,
+                );
+                const [, newAllowance] = await orderValidator.getBalanceAndAllowance.callAsync(
+                    makerAddress,
+                    erc721AssetData,
+                );
+                expect(newAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            });
+        });
+    });
+    describe('getBalancesAndAllowances', () => {
+        it('should return the correct balances and allowances when all values are 0', async () => {
+            const [
+                [erc20Balance, erc721Balance],
+                [erc20Allowance, erc721Allowance],
+            ] = await orderValidator.getBalancesAndAllowances.callAsync(makerAddress, [
+                erc20AssetData,
+                erc721AssetData,
+            ]);
+            expect(erc20Balance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(erc721Balance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(erc20Allowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(erc721Allowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return the correct balances and allowances when balances and allowances are non-zero', async () => {
+            const balance = new BigNumber(123);
+            const allowance = new BigNumber(456);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.setBalance.sendTransactionAsync(makerAddress, balance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.approve.sendTransactionAsync(erc20Proxy.address, allowance, {
+                    from: makerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.mint.sendTransactionAsync(makerAddress, tokenId),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.approve.sendTransactionAsync(erc721Proxy.address, tokenId, {
+                    from: makerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const [
+                [erc20Balance, erc721Balance],
+                [erc20Allowance, erc721Allowance],
+            ] = await orderValidator.getBalancesAndAllowances.callAsync(makerAddress, [
+                erc20AssetData,
+                erc721AssetData,
+            ]);
+            expect(erc20Balance).to.be.bignumber.equal(balance);
+            expect(erc721Balance).to.be.bignumber.equal(ERC721_BALANCE);
+            expect(erc20Allowance).to.be.bignumber.equal(allowance);
+            expect(erc721Allowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+        });
+    });
+    describe('getTraderInfo', () => {
+        beforeEach(async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync();
+        });
+        it('should return the correct info when no balances or allowances are set', async () => {
+            const traderInfo = await orderValidator.getTraderInfo.callAsync(signedOrder, takerAddress);
+            expect(traderInfo.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return the correct info when balances and allowances are set', async () => {
+            const makerBalance = new BigNumber(123);
+            const makerAllowance = new BigNumber(456);
+            const makerZrxBalance = new BigNumber(789);
+            const takerZrxAllowance = new BigNumber(987);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.setBalance.sendTransactionAsync(makerAddress, makerBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.approve.sendTransactionAsync(erc20Proxy.address, makerAllowance, {
+                    from: makerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.setBalance.sendTransactionAsync(makerAddress, makerZrxBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.approve.sendTransactionAsync(erc20Proxy.address, takerZrxAllowance, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.mint.sendTransactionAsync(takerAddress, tokenId),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.approve.sendTransactionAsync(erc721Proxy.address, tokenId, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const traderInfo = await orderValidator.getTraderInfo.callAsync(signedOrder, takerAddress);
+            expect(traderInfo.makerBalance).to.be.bignumber.equal(makerBalance);
+            expect(traderInfo.makerAllowance).to.be.bignumber.equal(makerAllowance);
+            expect(traderInfo.takerBalance).to.be.bignumber.equal(ERC721_BALANCE);
+            expect(traderInfo.takerAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            expect(traderInfo.makerZrxBalance).to.be.bignumber.equal(makerZrxBalance);
+            expect(traderInfo.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxAllowance).to.be.bignumber.equal(takerZrxAllowance);
+        });
+    });
+    describe('getTradersInfo', () => {
+        beforeEach(async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync();
+            signedOrder2 = await orderFactory.newSignedOrderAsync({
+                takerAssetData: assetDataUtils.encodeERC721AssetData(erc721Token.address, tokenId2),
+            });
+        });
+        it('should return the correct info when no balances or allowances have been set', async () => {
+            const orders = [signedOrder, signedOrder2];
+            const takers = [takerAddress, takerAddress];
+            const [traderInfo1, traderInfo2] = await orderValidator.getTradersInfo.callAsync(orders, takers);
+            expect(traderInfo1.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return the correct info when balances and allowances are set', async () => {
+            const makerBalance = new BigNumber(123);
+            const makerAllowance = new BigNumber(456);
+            const makerZrxBalance = new BigNumber(789);
+            const takerZrxAllowance = new BigNumber(987);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.setBalance.sendTransactionAsync(makerAddress, makerBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.approve.sendTransactionAsync(erc20Proxy.address, makerAllowance, {
+                    from: makerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.setBalance.sendTransactionAsync(makerAddress, makerZrxBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.approve.sendTransactionAsync(erc20Proxy.address, takerZrxAllowance, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const isApproved = true;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.setApprovalForAll.sendTransactionAsync(erc721Proxy.address, isApproved, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.mint.sendTransactionAsync(takerAddress, tokenId2),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const orders = [signedOrder, signedOrder2];
+            const takers = [takerAddress, takerAddress];
+            const [traderInfo1, traderInfo2] = await orderValidator.getTradersInfo.callAsync(orders, takers);
+
+            expect(traderInfo1.makerBalance).to.be.bignumber.equal(makerBalance);
+            expect(traderInfo1.makerAllowance).to.be.bignumber.equal(makerAllowance);
+            expect(traderInfo1.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            expect(traderInfo1.makerZrxBalance).to.be.bignumber.equal(makerZrxBalance);
+            expect(traderInfo1.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxAllowance).to.be.bignumber.equal(takerZrxAllowance);
+            expect(traderInfo2.makerBalance).to.be.bignumber.equal(makerBalance);
+            expect(traderInfo2.makerAllowance).to.be.bignumber.equal(makerAllowance);
+            expect(traderInfo2.takerBalance).to.be.bignumber.equal(ERC721_BALANCE);
+            expect(traderInfo2.takerAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            expect(traderInfo2.makerZrxBalance).to.be.bignumber.equal(makerZrxBalance);
+            expect(traderInfo2.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxAllowance).to.be.bignumber.equal(takerZrxAllowance);
+        });
+    });
+    describe('getOrderAndTraderInfo', () => {
+        beforeEach(async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync();
+        });
+        it('should return the correct info when no balances or allowances are set', async () => {
+            const [orderInfo, traderInfo] = await orderValidator.getOrderAndTraderInfo.callAsync(
+                signedOrder,
+                takerAddress,
+            );
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FILLABLE);
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return the correct info when balances and allowances are set', async () => {
+            const makerBalance = new BigNumber(123);
+            const makerAllowance = new BigNumber(456);
+            const makerZrxBalance = new BigNumber(789);
+            const takerZrxAllowance = new BigNumber(987);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.setBalance.sendTransactionAsync(makerAddress, makerBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.approve.sendTransactionAsync(erc20Proxy.address, makerAllowance, {
+                    from: makerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.setBalance.sendTransactionAsync(makerAddress, makerZrxBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.approve.sendTransactionAsync(erc20Proxy.address, takerZrxAllowance, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.mint.sendTransactionAsync(takerAddress, tokenId),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.approve.sendTransactionAsync(erc721Proxy.address, tokenId, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const [orderInfo, traderInfo] = await orderValidator.getOrderAndTraderInfo.callAsync(
+                signedOrder,
+                takerAddress,
+            );
+            const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
+            expect(orderInfo.orderStatus).to.be.equal(OrderStatus.FILLABLE);
+            expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
+            expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.makerBalance).to.be.bignumber.equal(makerBalance);
+            expect(traderInfo.makerAllowance).to.be.bignumber.equal(makerAllowance);
+            expect(traderInfo.takerBalance).to.be.bignumber.equal(ERC721_BALANCE);
+            expect(traderInfo.takerAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            expect(traderInfo.makerZrxBalance).to.be.bignumber.equal(makerZrxBalance);
+            expect(traderInfo.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo.takerZrxAllowance).to.be.bignumber.equal(takerZrxAllowance);
+        });
+    });
+    describe('getOrdersAndTradersInfo', () => {
+        beforeEach(async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync();
+            signedOrder2 = await orderFactory.newSignedOrderAsync({
+                takerAssetData: assetDataUtils.encodeERC721AssetData(erc721Token.address, tokenId2),
+            });
+        });
+        it('should return the correct info when no balances or allowances have been set', async () => {
+            const orders = [signedOrder, signedOrder2];
+            const takers = [takerAddress, takerAddress];
+            const [
+                [orderInfo1, orderInfo2],
+                [traderInfo1, traderInfo2],
+            ] = await orderValidator.getOrdersAndTradersInfo.callAsync(orders, takers);
+            const expectedOrderHash1 = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedOrderHash2 = orderHashUtils.getOrderHashHex(signedOrder2);
+            expect(orderInfo1.orderStatus).to.be.equal(OrderStatus.FILLABLE);
+            expect(orderInfo1.orderHash).to.be.equal(expectedOrderHash1);
+            expect(orderInfo1.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(orderInfo2.orderStatus).to.be.equal(OrderStatus.FILLABLE);
+            expect(orderInfo2.orderHash).to.be.equal(expectedOrderHash2);
+            expect(orderInfo2.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+        });
+        it('should return the correct info when balances and allowances are set', async () => {
+            const makerBalance = new BigNumber(123);
+            const makerAllowance = new BigNumber(456);
+            const makerZrxBalance = new BigNumber(789);
+            const takerZrxAllowance = new BigNumber(987);
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.setBalance.sendTransactionAsync(makerAddress, makerBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc20Token.approve.sendTransactionAsync(erc20Proxy.address, makerAllowance, {
+                    from: makerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.setBalance.sendTransactionAsync(makerAddress, makerZrxBalance),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await zrxToken.approve.sendTransactionAsync(erc20Proxy.address, takerZrxAllowance, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const isApproved = true;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.setApprovalForAll.sendTransactionAsync(erc721Proxy.address, isApproved, {
+                    from: takerAddress,
+                }),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await erc721Token.mint.sendTransactionAsync(takerAddress, tokenId2),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+            const orders = [signedOrder, signedOrder2];
+            const takers = [takerAddress, takerAddress];
+            const [
+                [orderInfo1, orderInfo2],
+                [traderInfo1, traderInfo2],
+            ] = await orderValidator.getOrdersAndTradersInfo.callAsync(orders, takers);
+            const expectedOrderHash1 = orderHashUtils.getOrderHashHex(signedOrder);
+            const expectedOrderHash2 = orderHashUtils.getOrderHashHex(signedOrder2);
+            expect(orderInfo1.orderStatus).to.be.equal(OrderStatus.FILLABLE);
+            expect(orderInfo1.orderHash).to.be.equal(expectedOrderHash1);
+            expect(orderInfo1.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(orderInfo2.orderStatus).to.be.equal(OrderStatus.FILLABLE);
+            expect(orderInfo2.orderHash).to.be.equal(expectedOrderHash2);
+            expect(orderInfo2.orderTakerAssetFilledAmount).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.makerBalance).to.be.bignumber.equal(makerBalance);
+            expect(traderInfo1.makerAllowance).to.be.bignumber.equal(makerAllowance);
+            expect(traderInfo1.takerBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            expect(traderInfo1.makerZrxBalance).to.be.bignumber.equal(makerZrxBalance);
+            expect(traderInfo1.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo1.takerZrxAllowance).to.be.bignumber.equal(takerZrxAllowance);
+            expect(traderInfo2.makerBalance).to.be.bignumber.equal(makerBalance);
+            expect(traderInfo2.makerAllowance).to.be.bignumber.equal(makerAllowance);
+            expect(traderInfo2.takerBalance).to.be.bignumber.equal(ERC721_BALANCE);
+            expect(traderInfo2.takerAllowance).to.be.bignumber.equal(ERC721_ALLOWANCE);
+            expect(traderInfo2.makerZrxBalance).to.be.bignumber.equal(makerZrxBalance);
+            expect(traderInfo2.makerZrxAllowance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxBalance).to.be.bignumber.equal(constants.ZERO_AMOUNT);
+            expect(traderInfo2.takerZrxAllowance).to.be.bignumber.equal(takerZrxAllowance);
+        });
+    });
+});
+// tslint:disable:max-file-line-count
diff --git a/packages/contracts/test/multisig/asset_proxy_owner.ts b/packages/contracts/test/multisig/asset_proxy_owner.ts
index 6b98605d3..9515941ff 100644
--- a/packages/contracts/test/multisig/asset_proxy_owner.ts
+++ b/packages/contracts/test/multisig/asset_proxy_owner.ts
@@ -422,7 +422,7 @@ describe('AssetProxyOwner', () => {
                 await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
 
                 const execRes = await multiSigWrapper.executeRemoveAuthorizedAddressAtIndexAsync(txId, owners[0]);
-                const execLog = execRes.logs[0] as LogWithDecodedArgs<AssetProxyOwnerExecutionEventArgs>;
+                const execLog = execRes.logs[1] as LogWithDecodedArgs<AssetProxyOwnerExecutionEventArgs>;
                 expect(execLog.args.transactionId).to.be.bignumber.equal(txId);
 
                 const tx = await testAssetProxyOwner.transactions.callAsync(txId);
@@ -449,7 +449,7 @@ describe('AssetProxyOwner', () => {
                 await multiSigWrapper.confirmTransactionAsync(txId, owners[1]);
 
                 const execRes = await multiSigWrapper.executeRemoveAuthorizedAddressAtIndexAsync(txId, owners[0]);
-                const execLog = execRes.logs[0] as LogWithDecodedArgs<AssetProxyOwnerExecutionEventArgs>;
+                const execLog = execRes.logs[1] as LogWithDecodedArgs<AssetProxyOwnerExecutionEventArgs>;
                 expect(execLog.args.transactionId).to.be.bignumber.equal(txId);
 
                 const tx = await testAssetProxyOwner.transactions.callAsync(txId);
diff --git a/packages/contracts/test/tokens/erc721_token.ts b/packages/contracts/test/tokens/erc721_token.ts
new file mode 100644
index 000000000..e61fd7d51
--- /dev/null
+++ b/packages/contracts/test/tokens/erc721_token.ts
@@ -0,0 +1,279 @@
+import { BlockchainLifecycle } from '@0xproject/dev-utils';
+import { RevertReason } from '@0xproject/types';
+import { BigNumber } from '@0xproject/utils';
+import * as chai from 'chai';
+import { LogWithDecodedArgs } from 'ethereum-types';
+
+import {
+    DummyERC721ReceiverContract,
+    DummyERC721ReceiverTokenReceivedEventArgs,
+} from '../../generated_contract_wrappers/dummy_erc721_receiver';
+import {
+    DummyERC721TokenContract,
+    DummyERC721TokenTransferEventArgs,
+} from '../../generated_contract_wrappers/dummy_erc721_token';
+import { InvalidERC721ReceiverContract } from '../../generated_contract_wrappers/invalid_erc721_receiver';
+import { artifacts } from '../utils/artifacts';
+import { expectTransactionFailedAsync, expectTransactionFailedWithoutReasonAsync } from '../utils/assertions';
+import { chaiSetup } from '../utils/chai_setup';
+import { constants } from '../utils/constants';
+import { LogDecoder } from '../utils/log_decoder';
+import { provider, txDefaults, web3Wrapper } from '../utils/web3_wrapper';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+// tslint:disable:no-unnecessary-type-assertion
+describe('ERC721Token', () => {
+    let owner: string;
+    let spender: string;
+    let token: DummyERC721TokenContract;
+    let erc721Receiver: DummyERC721ReceiverContract;
+    let logDecoder: LogDecoder;
+    const tokenId = new BigNumber(1);
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    before(async () => {
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        owner = accounts[0];
+        spender = accounts[1];
+        token = await DummyERC721TokenContract.deployFrom0xArtifactAsync(
+            artifacts.DummyERC721Token,
+            provider,
+            txDefaults,
+            constants.DUMMY_TOKEN_NAME,
+            constants.DUMMY_TOKEN_SYMBOL,
+        );
+        erc721Receiver = await DummyERC721ReceiverContract.deployFrom0xArtifactAsync(
+            artifacts.DummyERC721Receiver,
+            provider,
+            txDefaults,
+        );
+        logDecoder = new LogDecoder(web3Wrapper);
+        await web3Wrapper.awaitTransactionSuccessAsync(
+            await token.mint.sendTransactionAsync(owner, tokenId, { from: owner }),
+            constants.AWAIT_TRANSACTION_MINED_MS,
+        );
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+
+    describe('transferFrom', () => {
+        it('should revert if the tokenId is not owner', async () => {
+            const from = owner;
+            const to = erc721Receiver.address;
+            const unownedTokenId = new BigNumber(2);
+            await expectTransactionFailedAsync(
+                token.transferFrom.sendTransactionAsync(from, to, unownedTokenId),
+                RevertReason.Erc721ZeroOwner,
+            );
+        });
+        it('should revert if transferring to a null address', async () => {
+            const from = owner;
+            const to = constants.NULL_ADDRESS;
+            await expectTransactionFailedAsync(
+                token.transferFrom.sendTransactionAsync(from, to, tokenId),
+                RevertReason.Erc721ZeroToAddress,
+            );
+        });
+        it('should revert if the from address does not own the token', async () => {
+            const from = spender;
+            const to = erc721Receiver.address;
+            await expectTransactionFailedAsync(
+                token.transferFrom.sendTransactionAsync(from, to, tokenId),
+                RevertReason.Erc721OwnerMismatch,
+            );
+        });
+        it('should revert if spender does not own the token, is not approved, and is not approved for all', async () => {
+            const from = owner;
+            const to = erc721Receiver.address;
+            await expectTransactionFailedAsync(
+                token.transferFrom.sendTransactionAsync(from, to, tokenId, { from: spender }),
+                RevertReason.Erc721InvalidSpender,
+            );
+        });
+        it('should transfer the token if called by owner', async () => {
+            const from = owner;
+            const to = erc721Receiver.address;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.transferFrom.sendTransactionAsync(from, to, tokenId),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            expect(log.args._from).to.be.equal(from);
+            expect(log.args._to).to.be.equal(to);
+            expect(log.args._tokenId).to.be.bignumber.equal(tokenId);
+        });
+        it('should transfer the token if spender is approved for all', async () => {
+            const isApproved = true;
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await token.setApprovalForAll.sendTransactionAsync(spender, isApproved),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const from = owner;
+            const to = erc721Receiver.address;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.transferFrom.sendTransactionAsync(from, to, tokenId),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            expect(log.args._from).to.be.equal(from);
+            expect(log.args._to).to.be.equal(to);
+            expect(log.args._tokenId).to.be.bignumber.equal(tokenId);
+        });
+        it('should transfer the token if spender is individually approved', async () => {
+            await web3Wrapper.awaitTransactionSuccessAsync(
+                await token.approve.sendTransactionAsync(spender, tokenId),
+                constants.AWAIT_TRANSACTION_MINED_MS,
+            );
+
+            const from = owner;
+            const to = erc721Receiver.address;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.transferFrom.sendTransactionAsync(from, to, tokenId),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+
+            const approvedAddress = await token.getApproved.callAsync(tokenId);
+            expect(approvedAddress).to.be.equal(constants.NULL_ADDRESS);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            expect(log.args._from).to.be.equal(from);
+            expect(log.args._to).to.be.equal(to);
+            expect(log.args._tokenId).to.be.bignumber.equal(tokenId);
+        });
+    });
+    describe('safeTransferFrom without data', () => {
+        it('should transfer token to a non-contract address if called by owner', async () => {
+            const from = owner;
+            const to = spender;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.safeTransferFrom1.sendTransactionAsync(from, to, tokenId),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            expect(log.args._from).to.be.equal(from);
+            expect(log.args._to).to.be.equal(to);
+            expect(log.args._tokenId).to.be.bignumber.equal(tokenId);
+        });
+        it('should revert if transferring to a contract address without onERC721Received', async () => {
+            const contract = await DummyERC721TokenContract.deployFrom0xArtifactAsync(
+                artifacts.DummyERC721Token,
+                provider,
+                txDefaults,
+                constants.DUMMY_TOKEN_NAME,
+                constants.DUMMY_TOKEN_SYMBOL,
+            );
+            const from = owner;
+            const to = contract.address;
+            await expectTransactionFailedWithoutReasonAsync(
+                token.safeTransferFrom1.sendTransactionAsync(from, to, tokenId),
+            );
+        });
+        it('should revert if onERC721Received does not return the correct value', async () => {
+            const invalidErc721Receiver = await InvalidERC721ReceiverContract.deployFrom0xArtifactAsync(
+                artifacts.InvalidERC721Receiver,
+                provider,
+                txDefaults,
+            );
+            const from = owner;
+            const to = invalidErc721Receiver.address;
+            await expectTransactionFailedAsync(
+                token.safeTransferFrom1.sendTransactionAsync(from, to, tokenId),
+                RevertReason.Erc721InvalidSelector,
+            );
+        });
+        it('should transfer to contract and call onERC721Received with correct return value', async () => {
+            const from = owner;
+            const to = erc721Receiver.address;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.safeTransferFrom1.sendTransactionAsync(from, to, tokenId),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+            const transferLog = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<DummyERC721ReceiverTokenReceivedEventArgs>;
+            expect(transferLog.args._from).to.be.equal(from);
+            expect(transferLog.args._to).to.be.equal(to);
+            expect(transferLog.args._tokenId).to.be.bignumber.equal(tokenId);
+            expect(receiverLog.args.operator).to.be.equal(owner);
+            expect(receiverLog.args.from).to.be.equal(from);
+            expect(receiverLog.args.tokenId).to.be.bignumber.equal(tokenId);
+            expect(receiverLog.args.data).to.be.equal(constants.NULL_BYTES);
+        });
+    });
+    describe('safeTransferFrom with data', () => {
+        const data = '0x0102030405060708090a0b0c0d0e0f';
+        it('should transfer token to a non-contract address if called by owner', async () => {
+            const from = owner;
+            const to = spender;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.safeTransferFrom2.sendTransactionAsync(from, to, tokenId, data),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+            const log = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            expect(log.args._from).to.be.equal(from);
+            expect(log.args._to).to.be.equal(to);
+            expect(log.args._tokenId).to.be.bignumber.equal(tokenId);
+        });
+        it('should revert if transferring to a contract address without onERC721Received', async () => {
+            const contract = await DummyERC721TokenContract.deployFrom0xArtifactAsync(
+                artifacts.DummyERC721Token,
+                provider,
+                txDefaults,
+                constants.DUMMY_TOKEN_NAME,
+                constants.DUMMY_TOKEN_SYMBOL,
+            );
+            const from = owner;
+            const to = contract.address;
+            await expectTransactionFailedWithoutReasonAsync(
+                token.safeTransferFrom2.sendTransactionAsync(from, to, tokenId, data),
+            );
+        });
+        it('should revert if onERC721Received does not return the correct value', async () => {
+            const invalidErc721Receiver = await InvalidERC721ReceiverContract.deployFrom0xArtifactAsync(
+                artifacts.InvalidERC721Receiver,
+                provider,
+                txDefaults,
+            );
+            const from = owner;
+            const to = invalidErc721Receiver.address;
+            await expectTransactionFailedAsync(
+                token.safeTransferFrom2.sendTransactionAsync(from, to, tokenId, data),
+                RevertReason.Erc721InvalidSelector,
+            );
+        });
+        it('should transfer to contract and call onERC721Received with correct return value', async () => {
+            const from = owner;
+            const to = erc721Receiver.address;
+            const txReceipt = await logDecoder.getTxWithDecodedLogsAsync(
+                await token.safeTransferFrom2.sendTransactionAsync(from, to, tokenId, data),
+            );
+            const newOwner = await token.ownerOf.callAsync(tokenId);
+            expect(newOwner).to.be.equal(to);
+            const transferLog = txReceipt.logs[0] as LogWithDecodedArgs<DummyERC721TokenTransferEventArgs>;
+            const receiverLog = txReceipt.logs[1] as LogWithDecodedArgs<DummyERC721ReceiverTokenReceivedEventArgs>;
+            expect(transferLog.args._from).to.be.equal(from);
+            expect(transferLog.args._to).to.be.equal(to);
+            expect(transferLog.args._tokenId).to.be.bignumber.equal(tokenId);
+            expect(receiverLog.args.operator).to.be.equal(owner);
+            expect(receiverLog.args.from).to.be.equal(from);
+            expect(receiverLog.args.tokenId).to.be.bignumber.equal(tokenId);
+            expect(receiverLog.args.data).to.be.equal(data);
+        });
+    });
+});
+// tslint:enable:no-unnecessary-type-assertion
diff --git a/packages/contracts/test/tokens/unlimited_allowance_token.ts b/packages/contracts/test/tokens/unlimited_allowance_token.ts
index 81d931fc5..f2725b408 100644
--- a/packages/contracts/test/tokens/unlimited_allowance_token.ts
+++ b/packages/contracts/test/tokens/unlimited_allowance_token.ts
@@ -17,7 +17,7 @@ const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 describe('UnlimitedAllowanceToken', () => {
     let owner: string;
     let spender: string;
-    const MAX_MINT_VALUE = new BigNumber(100000000000000000000);
+    const MAX_MINT_VALUE = new BigNumber(10000000000000000000000);
     let token: DummyERC20TokenContract;
 
     before(async () => {
diff --git a/packages/contracts/test/utils/artifacts.ts b/packages/contracts/test/utils/artifacts.ts
index 1d5728cba..e8a7585ac 100644
--- a/packages/contracts/test/utils/artifacts.ts
+++ b/packages/contracts/test/utils/artifacts.ts
@@ -4,15 +4,18 @@ import * as AssetProxyOwner from '../../artifacts/AssetProxyOwner.json';
 import * as DummyERC20Token from '../../artifacts/DummyERC20Token.json';
 import * as DummyERC721Receiver from '../../artifacts/DummyERC721Receiver.json';
 import * as DummyERC721Token from '../../artifacts/DummyERC721Token.json';
+import * as DummyNoReturnERC20Token from '../../artifacts/DummyNoReturnERC20Token.json';
 import * as ERC20Proxy from '../../artifacts/ERC20Proxy.json';
 import * as ERC721Proxy from '../../artifacts/ERC721Proxy.json';
 import * as Exchange from '../../artifacts/Exchange.json';
 import * as ExchangeWrapper from '../../artifacts/ExchangeWrapper.json';
 import * as Forwarder from '../../artifacts/Forwarder.json';
 import * as IAssetProxy from '../../artifacts/IAssetProxy.json';
+import * as InvalidERC721Receiver from '../../artifacts/InvalidERC721Receiver.json';
 import * as MixinAuthorizable from '../../artifacts/MixinAuthorizable.json';
 import * as MultiSigWallet from '../../artifacts/MultiSigWallet.json';
 import * as MultiSigWalletWithTimeLock from '../../artifacts/MultiSigWalletWithTimeLock.json';
+import * as OrderValidator from '../../artifacts/OrderValidator.json';
 import * as TestAssetProxyDispatcher from '../../artifacts/TestAssetProxyDispatcher.json';
 import * as TestAssetProxyOwner from '../../artifacts/TestAssetProxyOwner.json';
 import * as TestConstants from '../../artifacts/TestConstants.json';
@@ -32,6 +35,7 @@ export const artifacts = {
     DummyERC20Token: (DummyERC20Token as any) as ContractArtifact,
     DummyERC721Receiver: (DummyERC721Receiver as any) as ContractArtifact,
     DummyERC721Token: (DummyERC721Token as any) as ContractArtifact,
+    DummyNoReturnERC20Token: (DummyNoReturnERC20Token as any) as ContractArtifact,
     ERC20Proxy: (ERC20Proxy as any) as ContractArtifact,
     ERC721Proxy: (ERC721Proxy as any) as ContractArtifact,
     Exchange: (Exchange as any) as ContractArtifact,
@@ -39,9 +43,11 @@ export const artifacts = {
     EtherToken: (EtherToken as any) as ContractArtifact,
     Forwarder: (Forwarder as any) as ContractArtifact,
     IAssetProxy: (IAssetProxy as any) as ContractArtifact,
+    InvalidERC721Receiver: (InvalidERC721Receiver as any) as ContractArtifact,
     MixinAuthorizable: (MixinAuthorizable as any) as ContractArtifact,
     MultiSigWallet: (MultiSigWallet as any) as ContractArtifact,
     MultiSigWalletWithTimeLock: (MultiSigWalletWithTimeLock as any) as ContractArtifact,
+    OrderValidator: (OrderValidator as any) as ContractArtifact,
     TestAssetProxyOwner: (TestAssetProxyOwner as any) as ContractArtifact,
     TestAssetProxyDispatcher: (TestAssetProxyDispatcher as any) as ContractArtifact,
     TestConstants: (TestConstants as any) as ContractArtifact,
diff --git a/packages/contracts/test/utils/erc721_wrapper.ts b/packages/contracts/test/utils/erc721_wrapper.ts
index d023b4d02..743d10706 100644
--- a/packages/contracts/test/utils/erc721_wrapper.ts
+++ b/packages/contracts/test/utils/erc721_wrapper.ts
@@ -81,7 +81,8 @@ export class ERC721Wrapper {
     }
     public async doesTokenExistAsync(tokenAddress: string, tokenId: BigNumber): Promise<boolean> {
         const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
-        const doesExist = await tokenContract.exists.callAsync(tokenId);
+        const owner = await tokenContract.ownerOf.callAsync(tokenId);
+        const doesExist = owner !== constants.NULL_ADDRESS;
         return doesExist;
     }
     public async approveProxyAsync(tokenAddress: string, tokenId: BigNumber): Promise<void> {
diff --git a/packages/contracts/test/utils/exchange_wrapper.ts b/packages/contracts/test/utils/exchange_wrapper.ts
index d57592d6d..619d43994 100644
--- a/packages/contracts/test/utils/exchange_wrapper.ts
+++ b/packages/contracts/test/utils/exchange_wrapper.ts
@@ -17,7 +17,7 @@ export class ExchangeWrapper {
     constructor(exchangeContract: ExchangeContract, provider: Provider) {
         this._exchange = exchangeContract;
         this._web3Wrapper = new Web3Wrapper(provider);
-        this._logDecoder = new LogDecoder(this._web3Wrapper, this._exchange.address);
+        this._logDecoder = new LogDecoder(this._web3Wrapper);
     }
     public async fillOrderAsync(
         signedOrder: SignedOrder,
@@ -266,4 +266,7 @@ export class ExchangeWrapper {
         );
         return data;
     }
+    public getExchangeAddress(): string {
+        return this._exchange.address;
+    }
 }
diff --git a/packages/contracts/test/utils/fill_order_combinatorial_utils.ts b/packages/contracts/test/utils/fill_order_combinatorial_utils.ts
index f18ad0dd3..a9318571c 100644
--- a/packages/contracts/test/utils/fill_order_combinatorial_utils.ts
+++ b/packages/contracts/test/utils/fill_order_combinatorial_utils.ts
@@ -504,7 +504,11 @@ export class FillOrderCombinatorialUtils {
         const actFilledTakerAmount = await this.exchangeWrapper.getTakerAssetFilledAmountAsync(orderHash);
         expect(actFilledTakerAmount).to.be.bignumber.equal(expFilledTakerAmount, 'filledTakerAmount');
 
-        expect(txReceipt.logs.length).to.be.equal(1, 'logs length');
+        const exchangeLogs = _.filter(
+            txReceipt.logs,
+            txLog => txLog.address === this.exchangeWrapper.getExchangeAddress(),
+        );
+        expect(exchangeLogs.length).to.be.equal(1, 'logs length');
         // tslint:disable-next-line:no-unnecessary-type-assertion
         const log = txReceipt.logs[0] as LogWithDecodedArgs<ExchangeFillEventArgs>;
         expect(log.args.makerAddress).to.be.equal(makerAddress, 'log.args.makerAddress');
diff --git a/packages/contracts/test/utils/forwarder_wrapper.ts b/packages/contracts/test/utils/forwarder_wrapper.ts
index 5b9a63ddf..de247a878 100644
--- a/packages/contracts/test/utils/forwarder_wrapper.ts
+++ b/packages/contracts/test/utils/forwarder_wrapper.ts
@@ -58,7 +58,7 @@ export class ForwarderWrapper {
     constructor(contractInstance: ForwarderContract, provider: Provider) {
         this._forwarderContract = contractInstance;
         this._web3Wrapper = new Web3Wrapper(provider);
-        this._logDecoder = new LogDecoder(this._web3Wrapper, this._forwarderContract.address);
+        this._logDecoder = new LogDecoder(this._web3Wrapper);
     }
     public async marketSellOrdersWithEthAsync(
         orders: SignedOrder[],
diff --git a/packages/contracts/test/utils/log_decoder.ts b/packages/contracts/test/utils/log_decoder.ts
index 92e9185d8..77211d357 100644
--- a/packages/contracts/test/utils/log_decoder.ts
+++ b/packages/contracts/test/utils/log_decoder.ts
@@ -16,7 +16,6 @@ import { constants } from './constants';
 
 export class LogDecoder {
     private readonly _web3Wrapper: Web3Wrapper;
-    private readonly _contractAddress: string;
     private readonly _abiDecoder: AbiDecoder;
     public static wrapLogBigNumbers(log: any): any {
         const argNames = _.keys(log.args);
@@ -27,9 +26,8 @@ export class LogDecoder {
             }
         }
     }
-    constructor(web3Wrapper: Web3Wrapper, contractAddress: string) {
+    constructor(web3Wrapper: Web3Wrapper) {
         this._web3Wrapper = web3Wrapper;
-        this._contractAddress = contractAddress;
         const abiArrays: AbiDefinition[][] = [];
         _.forEach(artifacts, (artifact: ContractArtifact) => {
             const compilerOutput = artifact.compilerOutput;
@@ -48,7 +46,6 @@ export class LogDecoder {
     }
     public async getTxWithDecodedLogsAsync(txHash: string): Promise<TransactionReceiptWithDecodedLogs> {
         const tx = await this._web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
-        tx.logs = _.filter(tx.logs, log => log.address === this._contractAddress);
         tx.logs = _.map(tx.logs, log => this.decodeLogOrThrow(log));
         return tx;
     }
diff --git a/packages/contracts/test/utils/multi_sig_wrapper.ts b/packages/contracts/test/utils/multi_sig_wrapper.ts
index 8c8055d4a..e0c27b839 100644
--- a/packages/contracts/test/utils/multi_sig_wrapper.ts
+++ b/packages/contracts/test/utils/multi_sig_wrapper.ts
@@ -16,7 +16,7 @@ export class MultiSigWrapper {
     constructor(multiSigContract: MultiSigWalletContract, provider: Provider) {
         this._multiSig = multiSigContract;
         this._web3Wrapper = new Web3Wrapper(provider);
-        this._logDecoder = new LogDecoder(this._web3Wrapper, this._multiSig.address);
+        this._logDecoder = new LogDecoder(this._web3Wrapper);
     }
     public async submitTransactionAsync(
         destination: string,