Forwarding contract (squashed commits)

18 files changed, 2163 insertions, 8 deletions

diff --git a/packages/contracts/compiler.json b/packages/contracts/compiler.json
index 56c8b1761..5ace566d8 100644
--- a/packages/contracts/compiler.json
+++ b/packages/contracts/compiler.json
@@ -28,6 +28,7 @@
         "ERC721Proxy",
         "Exchange",
         "ExchangeWrapper",
+        "Forwarder",
         "IAssetData",
         "IAssetProxy",
         "IValidator",
diff --git a/packages/contracts/package.json b/packages/contracts/package.json
index e0e82adc7..3b496ad58 100644
--- a/packages/contracts/package.json
+++ b/packages/contracts/package.json
@@ -20,12 +20,10 @@
         "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",
+        "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/**/*",
         "coverage:report:text": "istanbul report text",
         "coverage:report:html": "istanbul report html && open coverage/index.html",
@@ -34,8 +32,7 @@
         "test:circleci": "yarn test"
     },
     "config": {
-        "abis":
-            "../migrations/artifacts/2.0.0/@(AssetProxyOwner|DummyERC20Token|DummyERC721Receiver|DummyERC721Token|ERC20Proxy|ERC721Proxy|Exchange|ExchangeWrapper|IAssetData|IAssetProxy|MixinAuthorizable|MultiSigWallet|MultiSigWalletWithTimeLock|TestAssetProxyOwner|TestAssetProxyDispatcher|TestLibBytes|TestLibs|TestSignatureValidator|TestValidator|TestWallet|TokenRegistry|Whitelist|WETH9|ZRXToken).json"
+        "abis": "../migrations/artifacts/2.0.0/@(AssetProxyOwner|DummyERC20Token|DummyERC721Receiver|DummyERC721Token|ERC20Proxy|ERC721Proxy|Forwarder|Exchange|ExchangeWrapper|IAssetData|IAssetProxy|MixinAuthorizable|MultiSigWallet|MultiSigWalletWithTimeLock|TestAssetProxyOwner|TestAssetProxyDispatcher|TestLibBytes|TestLibs|TestSignatureValidator|TestValidator|TestWallet|TokenRegistry|Whitelist|WETH9|ZRXToken).json"
     },
     "repository": {
         "type": "git",
@@ -88,4 +85,4 @@
         "lodash": "^4.17.4",
         "web3": "^0.20.0"
     }
-}
+}
\ No newline at end of file
diff --git a/packages/contracts/src/2.0.0/forwarder/Forwarder.sol b/packages/contracts/src/2.0.0/forwarder/Forwarder.sol
new file mode 100644
index 000000000..71a4aff13
--- /dev/null
+++ b/packages/contracts/src/2.0.0/forwarder/Forwarder.sol
@@ -0,0 +1,81 @@
+/*
+
+  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 "./MixinWethFees.sol";
+import "./MixinMarketSellTokens.sol";
+import "./MixinMarketBuyTokens.sol";
+import "./MixinConstants.sol";
+import "../utils/Ownable/Ownable.sol";
+
+contract Forwarder is
+    Ownable,
+    MixinConstants,
+    MixinWethFees,
+    MixinMarketBuyZrx,
+    MixinMarketBuyTokens,
+    MixinMarketSellTokens
+{
+    uint256 MAX_UINT = 2**256 - 1;
+
+    constructor (
+        address _exchange,
+        address _etherToken,
+        address _zrxToken,
+        bytes4 _erc20AssetProxyId,
+        bytes memory _zrxAssetData,
+        bytes memory _wethAssetData
+    )
+        public
+        Ownable()
+        MixinConstants(
+            _exchange,
+            _etherToken,
+            _zrxToken,
+            _zrxAssetData,
+            _wethAssetData
+        )
+    {
+        setERC20ProxyApproval(_erc20AssetProxyId);
+    }
+
+    /// @dev Default payabale function, this allows us to withdraw WETH
+    function ()
+        public
+        payable
+    {
+        require(
+            msg.sender == address(ETHER_TOKEN),
+            "DEFAULT_FUNCTION_WETH_CONTRACT_ONLY"
+        );
+    }
+
+    /// @dev Sets the allowances to the proxy for this contract
+    function setERC20ProxyApproval(bytes4 erc20AssetProxyId)
+        public
+        onlyOwner
+    {
+        address proxyAddress = EXCHANGE.getAssetProxy(erc20AssetProxyId);
+        if (proxyAddress != address(0)) {
+            ETHER_TOKEN.approve(proxyAddress, MAX_UINT);
+            ZRX_TOKEN.approve(proxyAddress, MAX_UINT);
+        }
+    }
+}
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinConstants.sol b/packages/contracts/src/2.0.0/forwarder/MixinConstants.sol
new file mode 100644
index 000000000..18f2ba3bc
--- /dev/null
+++ b/packages/contracts/src/2.0.0/forwarder/MixinConstants.sol
@@ -0,0 +1,49 @@
+/*
+
+  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 "../protocol/Exchange/Exchange.sol";
+import { WETH9 as EtherToken } from "../tokens/WETH9/WETH9.sol";
+import "../tokens/ERC20Token/IERC20Token.sol";
+
+contract MixinConstants {
+
+    Exchange EXCHANGE;
+    EtherToken ETHER_TOKEN;
+    IERC20Token ZRX_TOKEN;
+    bytes ZRX_ASSET_DATA;
+    bytes WETH_ASSET_DATA;
+
+    constructor (
+        address _exchange,
+        address _etherToken,
+        address _zrxToken,
+        bytes memory _zrxAssetData,
+        bytes memory _wethAssetData
+    )
+        public
+    {
+        EXCHANGE = Exchange(_exchange);
+        ETHER_TOKEN = EtherToken(_etherToken);
+        ZRX_TOKEN = IERC20Token(_zrxToken);
+        ZRX_ASSET_DATA = _zrxAssetData;
+        WETH_ASSET_DATA = _wethAssetData;
+    }
+
+}
\ No newline at end of file
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinERC20.sol b/packages/contracts/src/2.0.0/forwarder/MixinERC20.sol
new file mode 100644
index 000000000..53d4116d7
--- /dev/null
+++ b/packages/contracts/src/2.0.0/forwarder/MixinERC20.sol
@@ -0,0 +1,68 @@
+/*
+
+  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;
+
+contract MixinERC20 {
+
+    string constant ERROR_TRANSFER_FAILED = "TRANSFER_FAILED";
+    bytes4 constant ERC20_TRANSFER_SELECTOR = bytes4(keccak256("transfer(address,uint256)"));
+
+    function transferToken(
+        address token,
+        address to,
+        uint256 amount
+    )
+        internal
+    {
+        // Transfer tokens.
+        // We do a raw call so we can check the success separate
+        // from the return data.
+        bool success = token.call(abi.encodeWithSelector(
+            ERC20_TRANSFER_SELECTOR,
+            to,
+            amount
+        ));
+        require(
+            success,
+            "TRANSFER_FAILED"
+        );
+        
+        // Check return data.
+        // If there is no return data, we assume the token incorrectly
+        // does not return a bool. In this case we expect it to revert
+        // on failure, which was handled above.
+        // If the token does return data, we require that it is a single
+        // value that evaluates to true.
+        assembly {
+            if returndatasize {
+                success := 0
+                if eq(returndatasize, 32) {
+                    // First 64 bytes of memory are reserved scratch space
+                    returndatacopy(0, 0, 32)
+                    success := mload(0)
+                }
+            }
+        }
+        require(
+            success,
+            "TRANSFER_FAILED"
+        );
+    }
+}
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinERC721.sol b/packages/contracts/src/2.0.0/forwarder/MixinERC721.sol
new file mode 100644
index 000000000..b2e8803a9
--- /dev/null
+++ b/packages/contracts/src/2.0.0/forwarder/MixinERC721.sol
@@ -0,0 +1,64 @@
+/*
+
+  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 "../utils/LibBytes/LibBytes.sol";
+import "../tokens/ERC721Token/IERC721Token.sol";
+
+contract MixinERC721 {
+
+    using LibBytes for bytes;
+    bytes4 constant ERC721_RECEIVED = bytes4(keccak256("onERC721Received(address,uint256,bytes)"));
+    bytes4 constant ERC721_RECEIVED_OPERATOR = bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"));
+
+    function onERC721Received(address, uint256, bytes memory)
+        public
+        pure
+        returns(bytes4)
+    {
+        return ERC721_RECEIVED;
+    }
+
+    function onERC721Received(address, address, uint256, bytes memory)
+        public
+        pure
+        returns(bytes4)
+    {
+        return ERC721_RECEIVED_OPERATOR;
+    }
+
+    function transferERC721Token(
+        bytes memory assetData,
+        address to
+    )
+        internal
+    {
+        // Decode asset data.
+        address token = assetData.readAddress(16);
+        uint256 tokenId = assetData.readUint256(36);
+        bytes memory receiverData = assetData.readBytesWithLength(100);
+        IERC721Token(token).safeTransferFrom(
+            address(this),
+            to,
+            tokenId,
+            receiverData
+        );
+    }
+}
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinErrorMessages.sol b/packages/contracts/src/2.0.0/forwarder/MixinErrorMessages.sol
new file mode 100644
index 000000000..c2a6ea0a4
--- /dev/null
+++ b/packages/contracts/src/2.0.0/forwarder/MixinErrorMessages.sol
@@ -0,0 +1,33 @@
+/*
+
+  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;
+
+/// This contract is intended to serve as a reference, but is not actually used for efficiency reasons.
+contract MixinErrorMessages {
+    string constant VALUE_GREATER_THAN_ZERO = "VALUE_GREATER_THAN_ZERO";
+    string constant FEE_PROPORTION_TOO_LARGE = "FEE_PROPORTION_TOO_LARGE";
+    string constant TAKER_ASSET_ZRX_REQUIRED = "TAKER_ASSET_ZRX_REQUIRED";
+    string constant TAKER_ASSET_WETH_REQUIRED = "TAKER_ASSET_WETH_REQUIRED";
+    string constant SAME_ASSET_TYPE_REQUIRED = "SAME_ASSET_TYPE_REQUIRED";
+    string constant UNACCEPTABLE_THRESHOLD = "UNACCEPTABLE_THRESHOLD";
+    string constant UNSUPPORTED_TOKEN_PROXY = "UNSUPPORTED_TOKEN_PROXY";
+    string constant ASSET_AMOUNT_MATCH_ORDER_SIZE = "ASSET_AMOUNT_MUST_MATCH_ORDER_SIZE";
+    string constant DEFAULT_FUNCTION_WETH_CONTRACT_ONLY = "DEFAULT_FUNCTION_WETH_CONTRACT_ONLY";
+    string constant INVALID_MSG_VALUE = "INVALID_MSG_VALUE";
+}
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinExpectedResults.sol b/packages/contracts/src/2.0.0/forwarder/MixinExpectedResults.sol
new file mode 100644
index 000000000..0bca7dc80
--- /dev/null
+++ b/packages/contracts/src/2.0.0/forwarder/MixinExpectedResults.sol
@@ -0,0 +1,158 @@
+/*
+
+  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 "../utils/LibBytes/LibBytes.sol";
+import "../protocol/Exchange/libs/LibFillResults.sol";
+import "../protocol/Exchange/libs/LibMath.sol";
+import "../protocol/Exchange/libs/LibOrder.sol";
+import "./MixinConstants.sol";
+
+contract MixinExpectedResults is
+    LibMath,
+    LibFillResults,
+    MixinConstants
+{
+
+    /// @dev Simulates the 0x Exchange fillOrder validation and calculations, without performing any state changes.
+    /// @param order An Order struct containing order specifications.
+    /// @param takerAssetFillAmount A number representing the amount of this order to fill.
+    /// @return fillResults Amounts filled and fees paid by maker and taker.
+    function calculateFillResults(
+        LibOrder.Order memory order,
+        uint256 takerAssetFillAmount
+    )
+        internal
+        view
+        returns (FillResults memory fillResults)
+    {
+        LibOrder.OrderInfo memory orderInfo = EXCHANGE.getOrderInfo(order);
+        if (orderInfo.orderStatus != uint8(LibOrder.OrderStatus.FILLABLE)) {
+            return fillResults;
+        }
+        uint256 remainingTakerAssetAmount = safeSub(order.takerAssetAmount, orderInfo.orderTakerAssetFilledAmount);
+        uint256 takerAssetFilledAmount = min256(takerAssetFillAmount, remainingTakerAssetAmount);
+
+        fillResults.takerAssetFilledAmount = takerAssetFilledAmount;
+        fillResults.makerAssetFilledAmount = getPartialAmount(
+            takerAssetFilledAmount,
+            order.takerAssetAmount,
+            order.makerAssetAmount
+        );
+        fillResults.makerFeePaid = getPartialAmount(
+            takerAssetFilledAmount,
+            order.takerAssetAmount,
+            order.makerFee
+        );
+        fillResults.takerFeePaid = getPartialAmount(
+            takerAssetFilledAmount,
+            order.takerAssetAmount,
+            order.takerFee
+        );
+        return fillResults;
+    }
+
+    /// @dev Calculates a FillResults total for selling takerAssetFillAmount over all orders. 
+    ///      Including the fees required to be paid. 
+    /// @param orders An array of Order struct containing order specifications.
+    /// @param takerAssetFillAmount A number representing the amount of this order to fill.
+    /// @return totalFillResults Amounts filled and fees paid by maker and taker.
+    function calculateMarketSellResults(
+        LibOrder.Order[] memory orders,
+        uint256 takerAssetFillAmount
+    )
+        internal
+        view
+        returns (FillResults memory totalFillResults)
+    {
+        for (uint256 i = 0; i < orders.length; i++) {
+            uint256 remainingTakerAssetFillAmount = safeSub(takerAssetFillAmount, totalFillResults.takerAssetFilledAmount);
+            FillResults memory singleFillResult = calculateFillResults(orders[i], remainingTakerAssetFillAmount);
+            addFillResults(totalFillResults, singleFillResult);
+            if (totalFillResults.takerAssetFilledAmount == takerAssetFillAmount) {
+                break;
+            }
+        }
+        return totalFillResults;
+    }
+
+    /// @dev Calculates a total FillResults for buying makerAssetFillAmount over all orders.
+    ///      Including the fees required to be paid. 
+    /// @param orders An array of Order struct containing order specifications.
+    /// @param makerAssetFillAmount A number representing the amount of this order to fill.
+    /// @return totalFillResults Amounts filled and fees paid by maker and taker.
+    function calculateMarketBuyResults(
+        LibOrder.Order[] memory orders,
+        uint256 makerAssetFillAmount
+    )
+        public
+        view
+        returns (FillResults memory totalFillResults)
+    {
+        for (uint256 i = 0; i < orders.length; i++) {
+            uint256 remainingMakerAssetFillAmount = safeSub(makerAssetFillAmount, totalFillResults.makerAssetFilledAmount);
+            uint256 remainingTakerAssetFillAmount = getPartialAmount(
+                orders[i].takerAssetAmount,
+                orders[i].makerAssetAmount,
+                remainingMakerAssetFillAmount
+            );
+            FillResults memory singleFillResult = calculateFillResults(orders[i], remainingTakerAssetFillAmount);
+            addFillResults(totalFillResults, singleFillResult);
+            if (totalFillResults.makerAssetFilledAmount == makerAssetFillAmount) {
+                break;
+            }
+        }
+        return totalFillResults;
+    }
+
+    /// @dev Calculates fill results for buyFeeTokens. This handles fees on buying ZRX
+    ///      so the end result is the expected amount of ZRX (not less after fees).
+    /// @param orders An array of Order struct containing order specifications.
+    /// @param zrxFillAmount A number representing the amount zrx to buy
+    /// @return totalFillResults Expected fill result amounts from buying fees
+    function calculateMarketBuyZrxResults(
+        LibOrder.Order[] memory orders,
+        uint256 zrxFillAmount
+    )
+        public
+        view
+        returns (FillResults memory totalFillResults)
+    {
+        for (uint256 i = 0; i < orders.length; i++) {
+            uint256 remainingZrxFillAmount = safeSub(zrxFillAmount, totalFillResults.makerAssetFilledAmount);
+            // Convert the remaining amount of makerToken to buy into remaining amount
+            // of takerToken to sell, assuming entire amount can be sold in the current order
+            uint256 remainingWethSellAmount = getPartialAmount(
+                orders[i].takerAssetAmount,
+                safeSub(orders[i].makerAssetAmount, orders[i].takerFee), // our exchange rate after fees 
+                remainingZrxFillAmount
+            );
+            FillResults memory singleFillResult = calculateFillResults(orders[i], safeAdd(remainingWethSellAmount, 1));
+
+            singleFillResult.makerAssetFilledAmount = safeSub(singleFillResult.makerAssetFilledAmount, singleFillResult.takerFeePaid);
+            addFillResults(totalFillResults, singleFillResult);
+            // As we compensate for the rounding issue above have slightly more ZRX than the requested zrxFillAmount
+            if (totalFillResults.makerAssetFilledAmount >= zrxFillAmount) {
+                break;
+            }
+        }
+        return totalFillResults;
+    }
+}
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinMarketBuyTokens.sol b/packages/contracts/src/2.0.0/forwarder/MixinMarketBuyTokens.sol
new file mode 100644
index 000000000..ef06fe519
--- /dev/null
+++ b/packages/contracts/src/2.0.0/forwarder/MixinMarketBuyTokens.sol
@@ -0,0 +1,258 @@
+/*
+
+  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 "../utils/LibBytes/LibBytes.sol";
+import "./MixinWethFees.sol";
+import "./MixinMarketBuyZrx.sol";
+import "./MixinExpectedResults.sol";
+import "./MixinERC20.sol";
+import "./MixinERC721.sol";
+import "./MixinConstants.sol";
+import "../protocol/Exchange/libs/LibOrder.sol";
+
+contract MixinMarketBuyTokens is
+    MixinConstants,
+    MixinWethFees,
+    MixinMarketBuyZrx,
+    MixinExpectedResults,
+    MixinERC20,
+    MixinERC721
+{
+    bytes4 public constant ERC20_DATA_ID = bytes4(keccak256("ERC20Token(address)"));
+    bytes4 public constant ERC721_DATA_ID = bytes4(keccak256("ERC721Token(address,uint256,bytes)"));
+
+    /// @dev Buys the exact amount of assets (ERC20 and ERC721), performing fee abstraction if required.
+    ///      All order assets must be of the same type. Deducts a proportional fee to fee recipient.
+    ///      This function is payable and will convert all incoming ETH into WETH and perform the trade on behalf of the caller.
+    ///      The caller is sent all assets from the fill of orders. This function will revert unless the requested amount of assets are purchased.
+    ///      Any excess ETH sent will be returned to the caller
+    /// @param orders An array of Order struct containing order specifications.
+    /// @param signatures An array of Proof that order has been created by maker.
+    /// @param feeOrders An array of Order struct containing order specifications for fees.
+    /// @param makerTokenFillAmount The amount of maker asset to buy.
+    /// @param feeSignatures An array of Proof that order has been created by maker for the fee orders.
+    /// @param feeProportion A proportion deducted off the ETH spent and sent to feeRecipient. The maximum value for this
+    ///        is 1000, aka 10%. Supports up to 2 decimal places. I.e 0.59% is 59.
+    /// @param feeRecipient An address of the fee recipient whom receives feeProportion of ETH.
+    /// @return FillResults amounts filled and fees paid by maker and taker.
+    function marketBuyTokensWithEth(
+        LibOrder.Order[] memory orders,
+        bytes[] memory signatures,
+        LibOrder.Order[] memory feeOrders,
+        bytes[] memory feeSignatures,
+        uint256 makerTokenFillAmount,
+        uint16  feeProportion,
+        address feeRecipient
+    )
+        payable
+        public
+        returns (FillResults memory totalFillResults)
+    {
+        uint256 takerEthAmount = msg.value;
+        require(
+            takerEthAmount > 0,
+            "VALUE_GREATER_THAN_ZERO"
+        );
+        require(
+            makerTokenFillAmount > 0,
+            "VALUE_GREATER_THAN_ZERO"
+        );
+        bytes4 assetDataId = LibBytes.readBytes4(orders[0].makerAssetData, 0);
+        require(
+            assetDataId == ERC20_DATA_ID || assetDataId == ERC721_DATA_ID,
+            "UNSUPPORTED_TOKEN_PROXY"
+        );
+
+        ETHER_TOKEN.deposit.value(takerEthAmount)();
+        if (assetDataId == ERC20_DATA_ID) {
+            totalFillResults = marketBuyERC20TokensInternal(
+                orders,
+                signatures,
+                feeOrders,
+                feeSignatures,
+                makerTokenFillAmount
+            );
+        } else if (assetDataId == ERC721_DATA_ID) {
+            totalFillResults = batchBuyERC721TokensInternal(
+                orders,
+                signatures,
+                feeOrders,
+                feeSignatures
+            );
+        }
+        // Prevent accidental WETH owned by this contract and it being spent
+        require(
+            takerEthAmount >= totalFillResults.takerAssetFilledAmount,
+            "INVALID_MSG_VALUE"
+        );
+        withdrawPayAndDeductEthFee(
+            safeSub(takerEthAmount, totalFillResults.takerAssetFilledAmount),
+            totalFillResults.takerAssetFilledAmount,
+            feeProportion,
+            feeRecipient
+        );
+        return totalFillResults;
+    }
+
+    /// @dev Buys an exact amount of an ERC20 token using WETH.
+    /// @param orders Orders to fill. The maker asset is the ERC20 token to buy. The taker asset is WETH.
+    /// @param signatures Proof that the orders were created by their respective makers.
+    /// @param feeOrders to fill. The maker asset is ZRX and the taker asset is WETH.
+    /// @param feeSignatures Proof that the feeOrders were created by their respective makers.
+    /// @param makerTokenFillAmount Amount of the ERC20 token to buy.
+    /// @return totalFillResults Aggregated fill results of buying the ERC20 and ZRX tokens.
+    function marketBuyERC20TokensInternal(
+        LibOrder.Order[] memory orders,
+        bytes[] memory signatures,
+        LibOrder.Order[] memory feeOrders,
+        bytes[] memory feeSignatures,
+        uint256 makerTokenFillAmount
+    )
+        private
+        returns (FillResults memory totalFillResults)
+    {
+        // We read the maker token address to check if it is ZRX and later use it for transfer
+        address makerTokenAddress = LibBytes.readAddress(orders[0].makerAssetData, 16);
+        // We assume that asset being bought by taker is the same for each order.
+        // Rather than passing this in as calldata, we copy the makerAssetData from the first order onto all later orders.
+        orders[0].takerAssetData = WETH_ASSET_DATA;
+        // We can short cut here for effeciency and use buyFeeTokensInternal if maker asset token is ZRX
+        // this buys us exactly that amount taking into account the fees. This saves gas and calculates the rate correctly
+        FillResults memory marketBuyResults;
+        if (makerTokenAddress == address(ZRX_TOKEN)) {
+            marketBuyResults = marketBuyZrxInternal(
+                orders,
+                signatures,
+                makerTokenFillAmount
+            );
+            // When buying ZRX we round up which can result in a small margin excess
+            require(
+                marketBuyResults.makerAssetFilledAmount >= makerTokenFillAmount,
+                "UNACCEPTABLE_THRESHOLD"
+            );
+            addFillResults(totalFillResults, marketBuyResults);
+            require(
+                isAcceptableThreshold(
+                    safeAdd(totalFillResults.makerAssetFilledAmount, totalFillResults.takerFeePaid), // Total ZRX
+                    totalFillResults.makerAssetFilledAmount // amount going to msg.sender
+                ),
+                "UNACCEPTABLE_THRESHOLD"
+            );
+        } else {
+            FillResults memory calculatedMarketBuyResults = calculateMarketBuyResults(orders, makerTokenFillAmount);
+            if (calculatedMarketBuyResults.takerFeePaid > 0) {
+                // Fees are required for these orders. Buy enough ZRX to cover the future market buy
+                FillResults memory zrxMarketBuyResults = marketBuyZrxInternal(
+                    feeOrders,
+                    feeSignatures,
+                    calculatedMarketBuyResults.takerFeePaid
+                );
+                totalFillResults.takerAssetFilledAmount = zrxMarketBuyResults.takerAssetFilledAmount;
+                totalFillResults.takerFeePaid = zrxMarketBuyResults.takerFeePaid;
+            }
+            // Make our market buy of the requested tokens with the remaining balance
+            marketBuyResults = EXCHANGE.marketBuyOrders(
+                orders,
+                makerTokenFillAmount,
+                signatures
+            );
+            require(
+                marketBuyResults.makerAssetFilledAmount == makerTokenFillAmount,
+                "UNACCEPTABLE_THRESHOLD"
+            );
+            addFillResults(totalFillResults, marketBuyResults);
+            require(
+                isAcceptableThreshold(
+                    totalFillResults.takerAssetFilledAmount,
+                    marketBuyResults.takerAssetFilledAmount
+                ),
+                "UNACCEPTABLE_THRESHOLD"
+            );
+        }
+        // Transfer all purchased tokens to msg.sender
+        transferToken(
+            makerTokenAddress,
+            msg.sender,
+            marketBuyResults.makerAssetFilledAmount
+        );
+        return totalFillResults;
+    }
+
+    /// @dev Buys an all of the ERC721 tokens in the orders.
+    /// @param orders Orders to fill. The maker asset is the ERC721 token to buy. The taker asset is WETH.
+    /// @param signatures Proof that the orders were created by their respective makers.
+    /// @param feeOrders to fill. The maker asset is ZRX and the taker asset is WETH.
+    /// @param feeSignatures Proof that the feeOrders were created by their respective makers.
+    /// @return totalFillResults Aggregated fill results of buying the ERC721 tokens and ZRX tokens.
+    function batchBuyERC721TokensInternal(
+        LibOrder.Order[] memory orders,
+        bytes[] memory signatures,
+        LibOrder.Order[] memory feeOrders,
+        bytes[] memory feeSignatures
+    )
+        private
+        returns (FillResults memory totalFillResults)
+    {
+        uint256 totalZrxFeeAmount;
+        uint256 ordersLength = orders.length;
+        uint256[] memory takerAssetFillAmounts = new uint256[](ordersLength);
+        for (uint256 i = 0; i < ordersLength; i++) {
+            // Total up the fees
+            totalZrxFeeAmount = safeAdd(totalZrxFeeAmount, orders[i].takerFee);
+            // We assume that asset being bought by taker is the same for each order.
+            // Rather than passing this in as calldata, we set the takerAssetData as WETH asset data
+            orders[i].takerAssetData = WETH_ASSET_DATA;
+            // Populate takerAssetFillAmounts for later batchFill
+            takerAssetFillAmounts[i] = orders[i].takerAssetAmount;
+        }
+        if (totalZrxFeeAmount > 0) {
+            // Fees are required for these orders. Buy enough ZRX to cover the future fill
+            FillResults memory zrxMarketBuyResults = marketBuyZrxInternal(
+                feeOrders,
+                feeSignatures,
+                totalZrxFeeAmount
+            );
+            totalFillResults.takerFeePaid = zrxMarketBuyResults.takerFeePaid;
+            totalFillResults.takerAssetFilledAmount = zrxMarketBuyResults.takerAssetFilledAmount;
+        }
+        FillResults memory batchFillResults = EXCHANGE.batchFillOrKillOrders(
+            orders,
+            takerAssetFillAmounts,
+            signatures
+        );
+        addFillResults(totalFillResults, batchFillResults);
+        require(
+            isAcceptableThreshold(
+                totalFillResults.takerAssetFilledAmount,
+                batchFillResults.takerAssetFilledAmount
+            ),
+            "UNACCEPTABLE_THRESHOLD"
+        );
+        // Transfer all of the tokens filled from the batchFill
+        for (i = 0; i < ordersLength; i++) {
+            transferERC721Token(
+                orders[i].makerAssetData,
+                msg.sender
+            );
+        }
+        return totalFillResults;
+    }
+}
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinMarketBuyZrx.sol b/packages/contracts/src/2.0.0/forwarder/MixinMarketBuyZrx.sol
new file mode 100644
index 000000000..4dbb34de3
--- /dev/null
+++ b/packages/contracts/src/2.0.0/forwarder/MixinMarketBuyZrx.sol
@@ -0,0 +1,80 @@
+/*
+
+  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/Exchange.sol";
+import "../protocol/Exchange/libs/LibFillResults.sol";
+import "../protocol/Exchange/libs/LibOrder.sol";
+import "../protocol/Exchange/libs/LibMath.sol";
+import "./MixinConstants.sol";
+
+contract MixinMarketBuyZrx is
+    LibMath,
+    LibFillResults,
+    MixinConstants
+{
+    /// @dev Buys zrxBuyAmount of ZRX fee tokens, taking into account the fees on buying fee tokens. This will guarantee
+    ///      At least zrxBuyAmount of ZRX fee tokens are purchased (sometimes slightly over due to rounding issues).
+    ///      It is possible that a request to buy 200 ZRX fee tokens will require purchasing 202 ZRX tokens
+    ///      As 2 ZRX is required to purchase the 200 ZRX fee tokens. This guarantees at least 200 ZRX for future purchases.
+    /// @param orders An array of Order struct containing order specifications for fees.
+    /// @param signatures An array of Proof that order has been created by maker for the fee orders.
+    /// @param zrxBuyAmount The number of requested ZRX fee tokens.
+    /// @return totalFillResults Amounts filled and fees paid by maker and taker. makerTokenAmount is the zrx amount deducted of fees
+    function marketBuyZrxInternal(
+        LibOrder.Order[] memory orders,
+        bytes[] memory signatures,
+        uint256 zrxBuyAmount
+    )
+        internal
+        returns (FillResults memory totalFillResults)
+    {
+        for (uint256 i = 0; i < orders.length; i++) {
+            // All of these are ZRX/WETH, we can drop the respective assetData from callData
+            orders[i].makerAssetData = ZRX_ASSET_DATA;
+            orders[i].takerAssetData = WETH_ASSET_DATA;
+            // Calculate the remaining amount of makerToken to buy
+            uint256 remainingZrxBuyAmount = safeSub(zrxBuyAmount, totalFillResults.makerAssetFilledAmount);
+            // Convert the remaining amount of makerToken to buy into remaining amount
+            // of takerToken to sell, assuming entire amount can be sold in the current order
+            uint256 remainingWethSellAmount = getPartialAmount(
+                orders[i].takerAssetAmount,
+                safeSub(orders[i].makerAssetAmount, orders[i].takerFee), // our exchange rate after fees 
+                remainingZrxBuyAmount
+            );
+            // Attempt to sell the remaining amount of takerToken
+            // Round up the amount to ensure we don't under buy by a fractional amount
+            FillResults memory singleFillResult = EXCHANGE.fillOrder(
+                orders[i],
+                safeAdd(remainingWethSellAmount, 1),
+                signatures[i]
+            );
+            // We didn't buy the full amount when buying ZRX as some were taken for fees
+            singleFillResult.makerAssetFilledAmount = safeSub(singleFillResult.makerAssetFilledAmount, singleFillResult.takerFeePaid);
+            // Update amounts filled and fees paid by maker and taker
+            addFillResults(totalFillResults, singleFillResult);
+            // Stop execution if the entire amount of makerToken has been bought
+            if (totalFillResults.makerAssetFilledAmount >= zrxBuyAmount) {
+                break;
+            }
+        }
+        return totalFillResults;
+    }
+}
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinMarketSellTokens.sol b/packages/contracts/src/2.0.0/forwarder/MixinMarketSellTokens.sol
new file mode 100644
index 000000000..8c9cdb8d5
--- /dev/null
+++ b/packages/contracts/src/2.0.0/forwarder/MixinMarketSellTokens.sol
@@ -0,0 +1,196 @@
+/*
+
+  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/libs/LibOrder.sol";
+import "../utils/LibBytes/LibBytes.sol";
+import "./MixinWethFees.sol";
+import "./MixinExpectedResults.sol";
+import "./MixinERC20.sol";
+import "./MixinConstants.sol";
+import "./MixinMarketBuyZrx.sol";
+
+contract MixinMarketSellTokens is
+    MixinConstants,
+    MixinWethFees,
+    MixinMarketBuyZrx,
+    MixinExpectedResults,
+    MixinERC20
+{
+    /// @dev Market sells ETH for ERC20 tokens, performing fee abstraction if required. This does not support ERC721 tokens. This function is payable
+    ///      and will convert all incoming ETH into WETH and perform the trade on behalf of the caller.
+    ///      This function allows for a deduction of a proportion of incoming ETH sent to the feeRecipient.
+    ///      The caller is sent all tokens from the operation.
+    ///      If the purchased token amount does not meet an acceptable threshold then this function reverts.
+    /// @param orders An array of Order struct containing order specifications.
+    /// @param signatures An array of Proof that order has been created by maker.
+    /// @param feeOrders An array of Order struct containing order specifications for fees.
+    /// @param feeSignatures An array of Proof that order has been created by maker for the fee orders.
+    /// @param feeProportion A proportion deducted off the incoming ETH and sent to feeRecipient. The maximum value for this
+    ///        is 1000, aka 10%. Supports up to 2 decimal places. I.e 0.59% is 59.
+    /// @param feeRecipient An address of the fee recipient whom receives feeProportion of ETH.
+    /// @return FillResults amounts filled and fees paid by maker and taker.
+    function marketSellEthForERC20(
+        LibOrder.Order[] memory orders,
+        bytes[] memory signatures,
+        LibOrder.Order[] memory feeOrders,
+        bytes[] memory feeSignatures,
+        uint16  feeProportion,
+        address feeRecipient
+    )
+        payable
+        public
+        returns (FillResults memory totalFillResults)
+    {
+        uint256 takerEthAmount = msg.value;
+        require(
+            takerEthAmount > 0,
+            "VALUE_GREATER_THAN_ZERO"
+        );
+        // Deduct the fee from the total amount of ETH sent in
+        uint256 ethFeeAmount = payEthFee(
+            takerEthAmount,
+            feeProportion,
+            feeRecipient
+        );
+        uint256 wethSellAmount = safeSub(takerEthAmount, ethFeeAmount);
+
+        // Deposit the remaining to be used for trading
+        ETHER_TOKEN.deposit.value(wethSellAmount)();
+        // Populate the known assetData, as it is always WETH the caller can provide null bytes to save gas
+        // marketSellOrders fills the remaining
+        address makerTokenAddress = LibBytes.readAddress(orders[0].makerAssetData, 16);
+        orders[0].takerAssetData = WETH_ASSET_DATA;
+        if (makerTokenAddress == address(ZRX_TOKEN)) {
+            // If this is ZRX then we market sell from the orders, rather than a 2 step of buying ZRX fees from feeOrders
+            // then buying ZRX from orders
+            totalFillResults = marketSellEthForZRXInternal(
+                orders,
+                signatures,
+                wethSellAmount
+            );
+        } else {
+            totalFillResults = marketSellEthForERC20Internal(
+                orders,
+                signatures,
+                feeOrders,
+                feeSignatures,
+                wethSellAmount
+            );
+        }
+        // Prevent accidental WETH owned by this contract and it being spent
+        require(
+            takerEthAmount >= totalFillResults.takerAssetFilledAmount,
+            "INVALID_MSG_VALUE"
+        );
+        // Ensure no WETH is left in this contract
+        require(
+            wethSellAmount == totalFillResults.takerAssetFilledAmount,
+            "UNACCEPTABLE_THRESHOLD"
+        );
+        // Transfer all tokens to msg.sender
+        transferToken(
+            makerTokenAddress,
+            msg.sender,
+            totalFillResults.makerAssetFilledAmount
+        );
+        return totalFillResults;
+    }
+
+    /// @dev Market sells WETH for ERC20 tokens.
+    /// @param orders An array of Order struct containing order specifications.
+    /// @param signatures An array of Proof that order has been created by maker.
+    /// @param feeOrders An array of Order struct containing order specifications for fees.
+    /// @param feeSignatures An array of Proof that order has been created by maker for the fee orders.
+    /// @param wethSellAmount The amount of WETH to sell.
+    /// @return FillResults amounts filled and fees paid by maker and taker.
+    function marketSellEthForERC20Internal(
+        LibOrder.Order[] memory orders,
+        bytes[] memory signatures,
+        LibOrder.Order[] memory feeOrders,
+        bytes[] memory feeSignatures,
+        uint256 wethSellAmount
+    )
+        internal
+        returns (FillResults memory totalFillResults)
+    {
+        uint256 remainingWethSellAmount = wethSellAmount;
+        FillResults memory calculatedMarketSellResults = calculateMarketSellResults(orders, wethSellAmount);
+        if (calculatedMarketSellResults.takerFeePaid > 0) {
+            // Fees are required for these orders. Buy enough ZRX to cover the future market buy
+            FillResults memory feeTokensResults = marketBuyZrxInternal(
+                feeOrders,
+                feeSignatures,
+                calculatedMarketSellResults.takerFeePaid
+            );
+            // Ensure the token abstraction was fair if fees were proportionally too high, we fail
+            require(
+                isAcceptableThreshold(
+                    wethSellAmount,
+                    safeSub(wethSellAmount, feeTokensResults.takerAssetFilledAmount)
+                ),
+                "UNACCEPTABLE_THRESHOLD"
+            );
+            remainingWethSellAmount = safeSub(remainingWethSellAmount, feeTokensResults.takerAssetFilledAmount);
+            totalFillResults.takerFeePaid = feeTokensResults.takerFeePaid;
+            totalFillResults.takerAssetFilledAmount = feeTokensResults.takerAssetFilledAmount;
+        }
+        // Make our market sell to buy the requested tokens with the remaining balance
+        FillResults memory requestedTokensResults = EXCHANGE.marketSellOrders(
+            orders,
+            remainingWethSellAmount,
+            signatures
+        );
+        // Update our return FillResult with the market sell
+        addFillResults(totalFillResults, requestedTokensResults);
+        return totalFillResults;
+    }
+
+    /// @dev Market sells WETH for ZRX tokens.
+    /// @param orders An array of Order struct containing order specifications.
+    /// @param signatures An array of Proof that order has been created by maker.
+    /// @param wethSellAmount The amount of WETH to sell.
+    /// @return FillResults amounts filled and fees paid by maker and taker.
+    function marketSellEthForZRXInternal(
+        LibOrder.Order[] memory orders,
+        bytes[] memory signatures,
+        uint256 wethSellAmount
+    )
+        internal
+        returns (FillResults memory totalFillResults)
+    {
+        // Make our market sell to buy the requested tokens with the remaining balance
+        totalFillResults = EXCHANGE.marketSellOrders(
+            orders,
+            wethSellAmount,
+            signatures
+        );
+        // Exchange does not special case ZRX in the makerAssetFilledAmount, if fees were deducted then using this amount
+        // for future transfers is invalid.
+        uint256 zrxAmountBought = safeSub(totalFillResults.makerAssetFilledAmount, totalFillResults.takerFeePaid);
+        require(
+            isAcceptableThreshold(totalFillResults.makerAssetFilledAmount, zrxAmountBought),
+            "UNACCEPTABLE_THRESHOLD"
+        );
+        totalFillResults.makerAssetFilledAmount = zrxAmountBought;
+        return totalFillResults;
+    }
+
+}
diff --git a/packages/contracts/src/2.0.0/forwarder/MixinWethFees.sol b/packages/contracts/src/2.0.0/forwarder/MixinWethFees.sol
new file mode 100644
index 000000000..9206c5fe0
--- /dev/null
+++ b/packages/contracts/src/2.0.0/forwarder/MixinWethFees.sol
@@ -0,0 +1,114 @@
+/*
+
+  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 { WETH9 as EtherToken } from "../tokens/WETH9/WETH9.sol";
+import "../protocol/Exchange/libs/LibMath.sol";
+import "./MixinConstants.sol";
+
+contract MixinWethFees is
+    LibMath,
+    MixinConstants
+{
+
+    uint16  constant public PERCENTAGE_DENOMINATOR = 10000; // 9800 == 98%, 10000 == 100%
+    uint16  constant public MAX_FEE = 1000; // 10%
+    uint16  constant public ALLOWABLE_EXCHANGE_PERCENTAGE = 9500; // 95%
+
+    /// @dev Pays the feeRecipient feeProportion of the total takerEthAmount, denominated in ETH
+    /// @param takerEthAmount The total amount that was transacted in WETH, fees are calculated from this value.
+    /// @param feeProportion The proportion of fees
+    /// @param feeRecipient The recipient of the fees
+    /// @return ethFeeAmount Amount of ETH paid to feeRecipient as fee.
+    function payEthFee(
+        uint256 takerEthAmount,
+        uint16 feeProportion,
+        address feeRecipient
+    )
+        internal
+        returns (uint256 ethFeeAmount)
+    {
+        if (feeProportion > 0 && feeRecipient != address(0)) {
+            require(
+                feeProportion <= MAX_FEE,
+                "FEE_PROPORTION_TOO_LARGE"
+            );
+            // 1.5% is 150, allowing for 2 decimal precision, i.e 0.05% is 5
+            ethFeeAmount = getPartialAmount(
+                feeProportion,
+                PERCENTAGE_DENOMINATOR,
+                takerEthAmount
+            );
+            feeRecipient.transfer(ethFeeAmount);
+        }
+        return ethFeeAmount;
+    }
+
+    /// @dev Withdraws the remaining WETH, deduct and pay fees from this amount based on the takerTokenAmount to the feeRecipient.
+    ///      If a user overpaid ETH initially, the fees are calculated from the amount traded and deducted from withdrawAmount.
+    ///      Any remaining ETH is sent back to the user.
+    /// @param ethWithdrawAmount The amount to withdraw from the WETH contract.
+    /// @param wethAmountSold The total amount that was transacted in WETH, fees are calculated from this value.
+    /// @param feeProportion The proportion of fees
+    /// @param feeRecipient The recipient of the fees
+    function withdrawPayAndDeductEthFee(
+        uint256 ethWithdrawAmount,
+        uint256 wethAmountSold,
+        uint16 feeProportion,
+        address feeRecipient
+    )
+        internal
+    {
+        // Return all of the excess WETH if any after deducting fees on the amount
+        if (ethWithdrawAmount > 0) {
+            ETHER_TOKEN.withdraw(ethWithdrawAmount);
+            // Fees proportional to the amount traded
+            uint256 ethFeeAmount = payEthFee(
+                wethAmountSold,
+                feeProportion,
+                feeRecipient
+            );
+            uint256 unspentEthAmount = safeSub(ethWithdrawAmount, ethFeeAmount);
+            if (unspentEthAmount > 0) {
+                msg.sender.transfer(unspentEthAmount);
+            }
+        }
+    }
+
+    /// @dev Checks whether the amount of tokens sold against the amount of tokens requested
+    ///      is within a certain threshold. This ensures the caller gets a fair deal when
+    ///      performing any token fee abstraction. Threshold is 95%. If fee abstraction costs more than
+    ///      5% of the total transaction, we return false.
+    /// @param requestedSellAmount The amount the user requested, or sent in to a payable function
+    /// @param tokenAmountSold The amount of the token that was sold after fee abstraction
+    /// @return bool of whether this is within an acceptable threshold
+    function isAcceptableThreshold(uint256 requestedSellAmount, uint256 tokenAmountSold)
+        internal
+        pure
+        returns (bool)
+    {
+        uint256 acceptableSellAmount = getPartialAmount(
+            ALLOWABLE_EXCHANGE_PERCENTAGE,
+            PERCENTAGE_DENOMINATOR,
+            requestedSellAmount
+        );
+        return tokenAmountSold >= acceptableSellAmount;
+    }
+}
diff --git a/packages/contracts/src/2.0.0/protocol/Exchange/MixinExchangeCore.sol b/packages/contracts/src/2.0.0/protocol/Exchange/MixinExchangeCore.sol
index c0ed023ac..d377dc943 100644
--- a/packages/contracts/src/2.0.0/protocol/Exchange/MixinExchangeCore.sol
+++ b/packages/contracts/src/2.0.0/protocol/Exchange/MixinExchangeCore.sol
@@ -396,7 +396,7 @@ contract MixinExchangeCore is
         return fillResults;
     }
 
-   /// @dev Settles an order by transferring assets between counterparties.
+    /// @dev Settles an order by transferring assets between counterparties.
     /// @param order Order struct containing order specifications.
     /// @param takerAddress Address selling takerAsset and buying makerAsset.
     /// @param fillResults Amounts to be filled and fees paid by maker and taker.
diff --git a/packages/contracts/test/forwarder/forwarder.ts b/packages/contracts/test/forwarder/forwarder.ts
new file mode 100644
index 000000000..0b6e24451
--- /dev/null
+++ b/packages/contracts/test/forwarder/forwarder.ts
@@ -0,0 +1,818 @@
+import { BlockchainLifecycle } from '@0xproject/dev-utils';
+import { assetProxyUtils } from '@0xproject/order-utils';
+import { AssetProxyId, SignedOrder } from '@0xproject/types';
+import { BigNumber } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as chai from 'chai';
+import { TransactionReceiptWithDecodedLogs } from 'ethereum-types';
+
+import { DummyERC20TokenContract } from '../../generated_contract_wrappers/dummy_e_r_c20_token';
+import { DummyERC721TokenContract } from '../../generated_contract_wrappers/dummy_e_r_c721_token';
+import { ExchangeContract } from '../../generated_contract_wrappers/exchange';
+import { ForwarderContract } from '../../generated_contract_wrappers/forwarder';
+import { WETH9Contract } from '../../generated_contract_wrappers/weth9';
+import { artifacts } from '../utils/artifacts';
+import { expectRevertOrAlwaysFailingTransactionAsync, expectRevertOrOtherErrorAsync } from '../utils/assertions';
+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 { formatters } from '../utils/formatters';
+import { ForwarderWrapper } from '../utils/forwarder_wrapper';
+import { OrderFactory } from '../utils/order_factory';
+import { ContractName, ERC20BalancesByOwner } from '../utils/types';
+import { provider, txDefaults, web3Wrapper } from '../utils/web3_wrapper';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+const DECIMALS_DEFAULT = 18;
+// Set a gasPrice so when checking balance of msg.sender we can accurately calculate gasPrice*gasUsed
+const DEFAULT_GAS_PRICE = new BigNumber(1);
+
+describe(ContractName.Forwarder, () => {
+    let makerAddress: string;
+    let owner: string;
+    let takerAddress: string;
+    let feeRecipientAddress: string;
+    let otherAddress: string;
+    let defaultMakerAssetAddress: string;
+
+    let weth: DummyERC20TokenContract;
+    let zrxToken: DummyERC20TokenContract;
+    let erc721Token: DummyERC721TokenContract;
+    let forwarderContract: ForwarderContract;
+    let wethContract: WETH9Contract;
+    let forwarderWrapper: ForwarderWrapper;
+    let exchangeWrapper: ExchangeWrapper;
+
+    let signedOrder: SignedOrder;
+    let signedOrders: SignedOrder[];
+    let orderWithFee: SignedOrder;
+    let signedOrdersWithFee: SignedOrder[];
+    let feeOrder: SignedOrder;
+    let feeOrders: SignedOrder[];
+    let orderFactory: OrderFactory;
+    let erc20Wrapper: ERC20Wrapper;
+    let erc20Balances: ERC20BalancesByOwner;
+    let tx: TransactionReceiptWithDecodedLogs;
+
+    let erc721MakerAssetIds: BigNumber[];
+    let feeProportion: number = 0;
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+        const accounts = await web3Wrapper.getAvailableAddressesAsync();
+        const usedAddresses = ([owner, makerAddress, takerAddress, feeRecipientAddress, otherAddress] = accounts);
+
+        const erc721Wrapper = new ERC721Wrapper(provider, usedAddresses, owner);
+        erc20Wrapper = new ERC20Wrapper(provider, usedAddresses, owner);
+
+        const numDummyErc20ToDeploy = 3;
+        let erc20TokenA;
+        [erc20TokenA, zrxToken] = await erc20Wrapper.deployDummyTokensAsync(
+            numDummyErc20ToDeploy,
+            constants.DUMMY_TOKEN_DECIMALS,
+        );
+        const erc20Proxy = await erc20Wrapper.deployProxyAsync();
+        await erc20Wrapper.setBalancesAndAllowancesAsync();
+
+        [erc721Token] = await erc721Wrapper.deployDummyTokensAsync();
+        const erc721Proxy = await erc721Wrapper.deployProxyAsync();
+        await erc721Wrapper.setBalancesAndAllowancesAsync();
+        const erc721Balances = await erc721Wrapper.getBalancesAsync();
+        erc721MakerAssetIds = erc721Balances[makerAddress][erc721Token.address];
+
+        wethContract = await WETH9Contract.deployFrom0xArtifactAsync(artifacts.EtherToken, provider, txDefaults);
+        weth = new DummyERC20TokenContract(wethContract.abi, wethContract.address, provider);
+        erc20Wrapper.addDummyTokenContract(weth);
+
+        const wethAssetData = assetProxyUtils.encodeERC20AssetData(wethContract.address);
+        const zrxAssetData = assetProxyUtils.encodeERC20AssetData(zrxToken.address);
+        const exchangeInstance = await ExchangeContract.deployFrom0xArtifactAsync(
+            artifacts.Exchange,
+            provider,
+            txDefaults,
+            zrxAssetData,
+        );
+        const exchangeContract = new ExchangeContract(exchangeInstance.abi, exchangeInstance.address, provider);
+        exchangeWrapper = new ExchangeWrapper(exchangeContract, provider);
+        await exchangeWrapper.registerAssetProxyAsync(erc20Proxy.address, owner);
+        await exchangeWrapper.registerAssetProxyAsync(erc721Proxy.address, owner);
+
+        await erc20Proxy.addAuthorizedAddress.sendTransactionAsync(exchangeInstance.address, {
+            from: owner,
+        });
+        await erc721Proxy.addAuthorizedAddress.sendTransactionAsync(exchangeInstance.address, {
+            from: owner,
+        });
+
+        defaultMakerAssetAddress = erc20TokenA.address;
+        const defaultTakerAssetAddress = wethContract.address;
+        const defaultOrderParams = {
+            exchangeAddress: exchangeInstance.address,
+            makerAddress,
+            feeRecipientAddress,
+            makerAssetData: assetProxyUtils.encodeERC20AssetData(defaultMakerAssetAddress),
+            takerAssetData: assetProxyUtils.encodeERC20AssetData(defaultTakerAssetAddress),
+            makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), DECIMALS_DEFAULT),
+            takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), DECIMALS_DEFAULT),
+            makerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), DECIMALS_DEFAULT),
+            takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(0), DECIMALS_DEFAULT),
+        };
+        const privateKey = constants.TESTRPC_PRIVATE_KEYS[accounts.indexOf(makerAddress)];
+        orderFactory = new OrderFactory(privateKey, defaultOrderParams);
+
+        const forwarderInstance = await ForwarderContract.deployFrom0xArtifactAsync(
+            artifacts.Forwarder,
+            provider,
+            txDefaults,
+            exchangeInstance.address,
+            wethContract.address,
+            zrxToken.address,
+            AssetProxyId.ERC20,
+            zrxAssetData,
+            wethAssetData,
+        );
+        forwarderContract = new ForwarderContract(forwarderInstance.abi, forwarderInstance.address, provider);
+        forwarderWrapper = new ForwarderWrapper(forwarderContract, provider, zrxToken.address);
+        erc20Wrapper.addTokenOwnerAddress(forwarderInstance.address);
+
+        web3Wrapper.abiDecoder.addABI(forwarderContract.abi);
+        web3Wrapper.abiDecoder.addABI(exchangeInstance.abi);
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+        feeProportion = 0;
+        erc20Balances = await erc20Wrapper.getBalancesAsync();
+        signedOrder = orderFactory.newSignedOrder();
+        signedOrders = [signedOrder];
+        feeOrder = orderFactory.newSignedOrder({
+            makerAssetData: assetProxyUtils.encodeERC20AssetData(zrxToken.address),
+            takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), DECIMALS_DEFAULT),
+        });
+        feeOrders = [feeOrder];
+        orderWithFee = orderFactory.newSignedOrder({
+            takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), DECIMALS_DEFAULT),
+        });
+        signedOrdersWithFee = [orderWithFee];
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('calculations', () => {
+        it('throws if orders passed in are not enough to satisfy requested amount', async () => {
+            feeOrders = [feeOrder];
+            const makerTokenFillAmount = feeOrder.makerAssetAmount.div(2);
+            const fillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                feeOrders,
+                [],
+                feeProportion,
+                makerTokenFillAmount,
+            );
+            // Fill the feeOrder
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync(feeOrders, [], makerTokenFillAmount, {
+                from: takerAddress,
+                value: fillAmountWei,
+            });
+            return expectRevertOrOtherErrorAsync(
+                forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                    feeOrders,
+                    [],
+                    feeProportion,
+                    makerTokenFillAmount,
+                ),
+                'Unable to satisfy makerAssetFillAmount with provided orders',
+            );
+        });
+        it('throws if orders passed are cancelled', async () => {
+            tx = await exchangeWrapper.cancelOrderAsync(feeOrder, makerAddress);
+            // Cancel the feeOrder
+            return expectRevertOrOtherErrorAsync(
+                forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                    feeOrders,
+                    [],
+                    feeProportion,
+                    feeOrder.makerAssetAmount.div(2),
+                ),
+                'Unable to satisfy makerAssetFillAmount with provided orders',
+            );
+        });
+    });
+    describe('marketSellEthForERC20 without extra fees', () => {
+        it('should fill the order', async () => {
+            const fillAmount = signedOrder.takerAssetAmount.div(2);
+            const makerBalanceBefore = erc20Balances[makerAddress][defaultMakerAssetAddress];
+            const takerBalanceBefore = erc20Balances[takerAddress][defaultMakerAssetAddress];
+            feeOrders = [];
+            tx = await forwarderWrapper.marketSellEthForERC20Async(signedOrders, feeOrders, {
+                value: fillAmount,
+                from: takerAddress,
+            });
+            const newBalances = await erc20Wrapper.getBalancesAsync();
+            const makerBalanceAfter = newBalances[makerAddress][defaultMakerAssetAddress];
+            const takerBalanceAfter = newBalances[takerAddress][defaultMakerAssetAddress];
+            const makerTokenFillAmount = fillAmount
+                .times(signedOrder.makerAssetAmount)
+                .dividedToIntegerBy(signedOrder.takerAssetAmount);
+
+            expect(makerBalanceAfter).to.be.bignumber.equal(makerBalanceBefore.minus(makerTokenFillAmount));
+            expect(takerBalanceAfter).to.be.bignumber.equal(takerBalanceBefore.plus(makerTokenFillAmount));
+            expect(newBalances[forwarderContract.address][weth.address]).to.be.bignumber.equal(new BigNumber(0));
+        });
+        it('should fill the order and perform fee abstraction', async () => {
+            const fillAmount = signedOrder.takerAssetAmount.div(4);
+            const takerBalanceBefore = erc20Balances[takerAddress][defaultMakerAssetAddress];
+            tx = await forwarderWrapper.marketSellEthForERC20Async(signedOrdersWithFee, feeOrders, {
+                value: fillAmount,
+                from: takerAddress,
+            });
+            const newBalances = await erc20Wrapper.getBalancesAsync();
+            const takerBalanceAfter = newBalances[takerAddress][defaultMakerAssetAddress];
+
+            const acceptPercentage = 98;
+            const acceptableThreshold = takerBalanceBefore.plus(fillAmount.times(acceptPercentage).dividedBy(100));
+            const isWithinThreshold = takerBalanceAfter.greaterThanOrEqualTo(acceptableThreshold);
+            expect(isWithinThreshold).to.be.true();
+            expect(newBalances[forwarderContract.address][weth.address]).to.be.bignumber.equal(new BigNumber(0));
+        });
+        it('should fill the order when token is ZRX with fees', async () => {
+            orderWithFee = orderFactory.newSignedOrder({
+                makerAssetData: assetProxyUtils.encodeERC20AssetData(zrxToken.address),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), DECIMALS_DEFAULT),
+            });
+            signedOrdersWithFee = [orderWithFee];
+            feeOrders = [];
+            const fillAmount = signedOrder.takerAssetAmount.div(4);
+            const takerBalanceBefore = erc20Balances[takerAddress][zrxToken.address];
+            tx = await forwarderWrapper.marketSellEthForERC20Async(signedOrdersWithFee, feeOrders, {
+                value: fillAmount,
+                from: takerAddress,
+            });
+            const newBalances = await erc20Wrapper.getBalancesAsync();
+            const takerBalanceAfter = newBalances[takerAddress][zrxToken.address];
+
+            const acceptPercentage = 98;
+            const acceptableThreshold = takerBalanceBefore.plus(fillAmount.times(acceptPercentage).dividedBy(100));
+            const isWithinThreshold = takerBalanceAfter.greaterThanOrEqualTo(acceptableThreshold);
+            expect(isWithinThreshold).to.be.true();
+            expect(newBalances[forwarderContract.address][weth.address]).to.be.bignumber.equal(new BigNumber(0));
+        });
+        it('should fail if sent an ETH amount too high', async () => {
+            signedOrder = orderFactory.newSignedOrder({
+                makerAssetData: assetProxyUtils.encodeERC20AssetData(zrxToken.address),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), DECIMALS_DEFAULT),
+            });
+            const fillAmount = signedOrder.takerAssetAmount.times(2);
+            return expectRevertOrAlwaysFailingTransactionAsync(
+                forwarderWrapper.marketSellEthForERC20Async(signedOrdersWithFee, feeOrders, {
+                    value: fillAmount,
+                    from: takerAddress,
+                }),
+            );
+        });
+        it('should fail if fee abstraction amount is too high', async () => {
+            orderWithFee = orderFactory.newSignedOrder({
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(50), DECIMALS_DEFAULT),
+            });
+            signedOrdersWithFee = [orderWithFee];
+            feeOrder = orderFactory.newSignedOrder({
+                makerAssetData: assetProxyUtils.encodeERC20AssetData(zrxToken.address),
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), DECIMALS_DEFAULT),
+            });
+            feeOrders = [feeOrder];
+            const fillAmount = signedOrder.takerAssetAmount.div(4);
+            return expectRevertOrAlwaysFailingTransactionAsync(
+                forwarderWrapper.marketSellEthForERC20Async(signedOrdersWithFee, feeOrders, {
+                    value: fillAmount,
+                    from: takerAddress,
+                }),
+            );
+        });
+        it('throws when mixed ERC721 and ERC20 assets with ERC20 first', async () => {
+            const makerAssetId = erc721MakerAssetIds[0];
+            const erc721SignedOrder = orderFactory.newSignedOrder({
+                makerAssetAmount: new BigNumber(1),
+                makerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
+            });
+            const erc20SignedOrder = orderFactory.newSignedOrder();
+            signedOrders = [erc20SignedOrder, erc721SignedOrder];
+            const fillAmountWei = erc20SignedOrder.takerAssetAmount.plus(erc721SignedOrder.takerAssetAmount);
+            return expectRevertOrAlwaysFailingTransactionAsync(
+                forwarderWrapper.marketSellEthForERC20Async(signedOrders, feeOrders, {
+                    from: takerAddress,
+                    value: fillAmountWei,
+                }),
+            );
+        });
+    });
+    describe('marketSellEthForERC20 with extra fees', () => {
+        it('should fill the order and send fee to fee recipient', async () => {
+            const initEthBalance = await web3Wrapper.getBalanceInWeiAsync(feeRecipientAddress);
+            const fillAmount = signedOrder.takerAssetAmount.div(2);
+            feeProportion = 150; // 1.5%
+            feeOrders = [];
+            tx = await forwarderWrapper.marketSellEthForERC20Async(
+                signedOrders,
+                feeOrders,
+                {
+                    from: takerAddress,
+                    value: fillAmount,
+                    gasPrice: DEFAULT_GAS_PRICE,
+                },
+                {
+                    feeProportion,
+                    feeRecipient: feeRecipientAddress,
+                },
+            );
+            const newBalances = await erc20Wrapper.getBalancesAsync();
+            const makerBalanceBefore = erc20Balances[makerAddress][defaultMakerAssetAddress];
+            const makerBalanceAfter = newBalances[makerAddress][defaultMakerAssetAddress];
+            const takerBalanceAfter = newBalances[takerAddress][defaultMakerAssetAddress];
+            const afterEthBalance = await web3Wrapper.getBalanceInWeiAsync(feeRecipientAddress);
+            const takerBoughtAmount = takerBalanceAfter.minus(erc20Balances[takerAddress][defaultMakerAssetAddress]);
+
+            expect(makerBalanceAfter).to.be.bignumber.equal(makerBalanceBefore.minus(takerBoughtAmount));
+            expect(afterEthBalance).to.be.bignumber.equal(
+                initEthBalance.plus(fillAmount.times(feeProportion).dividedBy(10000)),
+            );
+            expect(newBalances[forwarderContract.address][weth.address]).to.be.bignumber.equal(new BigNumber(0));
+        });
+        it('should fail if the fee is set too high', async () => {
+            const initEthBalance = await web3Wrapper.getBalanceInWeiAsync(feeRecipientAddress);
+            const fillAmount = signedOrder.takerAssetAmount.div(2);
+            feeProportion = 1500; // 15.0%
+            feeOrders = [];
+            expectRevertOrAlwaysFailingTransactionAsync(
+                forwarderWrapper.marketSellEthForERC20Async(
+                    signedOrders,
+                    feeOrders,
+                    {
+                        from: takerAddress,
+                        value: fillAmount,
+                        gasPrice: DEFAULT_GAS_PRICE,
+                    },
+                    {
+                        feeProportion,
+                        feeRecipient: feeRecipientAddress,
+                    },
+                ),
+            );
+            const afterEthBalance = await web3Wrapper.getBalanceInWeiAsync(feeRecipientAddress);
+            expect(afterEthBalance).to.be.bignumber.equal(initEthBalance);
+        });
+    });
+    describe('marketBuyTokensWithEth', () => {
+        it('should buy the exact amount of assets', async () => {
+            const makerAssetAmount = signedOrder.makerAssetAmount.div(2);
+            const initEthBalance = await web3Wrapper.getBalanceInWeiAsync(takerAddress);
+            const balancesBefore = await erc20Wrapper.getBalancesAsync();
+            const rate = signedOrder.makerAssetAmount.dividedBy(signedOrder.takerAssetAmount);
+            const fillAmountWei = makerAssetAmount.dividedToIntegerBy(rate);
+            feeOrders = [];
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync(signedOrders, feeOrders, makerAssetAmount, {
+                from: takerAddress,
+                value: fillAmountWei,
+                gasPrice: DEFAULT_GAS_PRICE,
+            });
+            const newBalances = await erc20Wrapper.getBalancesAsync();
+            const takerBalanceBefore = balancesBefore[takerAddress][defaultMakerAssetAddress];
+            const takerBalanceAfter = newBalances[takerAddress][defaultMakerAssetAddress];
+            const afterEthBalance = await web3Wrapper.getBalanceInWeiAsync(takerAddress);
+            const expectedEthBalanceAfterGasCosts = initEthBalance.minus(fillAmountWei).minus(tx.gasUsed);
+            expect(takerBalanceAfter).to.be.bignumber.eq(takerBalanceBefore.plus(makerAssetAmount));
+            expect(afterEthBalance).to.be.bignumber.eq(expectedEthBalanceAfterGasCosts);
+        });
+        it('should buy the exact amount of assets and return excess ETH', async () => {
+            const makerAssetAmount = signedOrder.makerAssetAmount.div(2);
+            const initEthBalance = await web3Wrapper.getBalanceInWeiAsync(takerAddress);
+            const balancesBefore = await erc20Wrapper.getBalancesAsync();
+            const rate = signedOrder.makerAssetAmount.dividedBy(signedOrder.takerAssetAmount);
+            const fillAmount = makerAssetAmount.dividedToIntegerBy(rate);
+            const excessFillAmount = fillAmount.times(2);
+            feeOrders = [];
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync(signedOrders, feeOrders, makerAssetAmount, {
+                from: takerAddress,
+                value: excessFillAmount,
+                gasPrice: DEFAULT_GAS_PRICE,
+            });
+            const newBalances = await erc20Wrapper.getBalancesAsync();
+            const takerBalanceBefore = balancesBefore[takerAddress][defaultMakerAssetAddress];
+            const takerBalanceAfter = newBalances[takerAddress][defaultMakerAssetAddress];
+            const afterEthBalance = await web3Wrapper.getBalanceInWeiAsync(takerAddress);
+            const expectedEthBalanceAfterGasCosts = initEthBalance.minus(fillAmount).minus(tx.gasUsed);
+            expect(takerBalanceAfter).to.be.bignumber.eq(takerBalanceBefore.plus(makerAssetAmount));
+            expect(afterEthBalance).to.be.bignumber.eq(expectedEthBalanceAfterGasCosts);
+        });
+        it('should buy the exact amount of assets with fee abstraction', async () => {
+            const makerAssetAmount = signedOrder.makerAssetAmount.div(2);
+            const balancesBefore = await erc20Wrapper.getBalancesAsync();
+            const rate = signedOrder.makerAssetAmount.dividedBy(signedOrder.takerAssetAmount);
+            const fillAmount = makerAssetAmount.dividedToIntegerBy(rate);
+            const excessFillAmount = fillAmount.times(2);
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync(signedOrdersWithFee, feeOrders, makerAssetAmount, {
+                from: takerAddress,
+                value: excessFillAmount,
+            });
+            const newBalances = await erc20Wrapper.getBalancesAsync();
+            const takerBalanceBefore = balancesBefore[takerAddress][defaultMakerAssetAddress];
+            const takerBalanceAfter = newBalances[takerAddress][defaultMakerAssetAddress];
+            expect(takerBalanceAfter).to.be.bignumber.eq(takerBalanceBefore.plus(makerAssetAmount));
+        });
+        it('should buy the exact amount of assets when buying zrx with fee abstraction', async () => {
+            signedOrder = orderFactory.newSignedOrder({
+                makerAssetData: assetProxyUtils.encodeERC20AssetData(zrxToken.address),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), DECIMALS_DEFAULT),
+            });
+            signedOrdersWithFee = [signedOrder];
+            feeOrders = [];
+            const makerAssetAmount = signedOrder.makerAssetAmount.div(2);
+            const takerWeiBalanceBefore = await web3Wrapper.getBalanceInWeiAsync(takerAddress);
+            const balancesBefore = await erc20Wrapper.getBalancesAsync();
+            const fillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                signedOrdersWithFee,
+                feeOrders,
+                feeProportion,
+                makerAssetAmount,
+            );
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync(signedOrdersWithFee, feeOrders, makerAssetAmount, {
+                from: takerAddress,
+                value: fillAmountWei,
+                gasPrice: DEFAULT_GAS_PRICE,
+            });
+            const newBalances = await erc20Wrapper.getBalancesAsync();
+            const takerTokenBalanceBefore = balancesBefore[takerAddress][zrxToken.address];
+            const takerTokenBalanceAfter = newBalances[takerAddress][zrxToken.address];
+            const takerWeiBalanceAfter = await web3Wrapper.getBalanceInWeiAsync(takerAddress);
+            const expectedCostAfterGas = fillAmountWei.plus(tx.gasUsed);
+            expect(takerTokenBalanceAfter).to.be.bignumber.greaterThan(takerTokenBalanceBefore.plus(makerAssetAmount));
+            expect(takerWeiBalanceAfter).to.be.bignumber.equal(takerWeiBalanceBefore.minus(expectedCostAfterGas));
+        });
+        it('throws if fees are higher than 5% when buying zrx', async () => {
+            const highFeeZRXOrder = orderFactory.newSignedOrder({
+                makerAssetData: assetProxyUtils.encodeERC20AssetData(zrxToken.address),
+                makerAssetAmount: signedOrder.makerAssetAmount,
+                takerFee: signedOrder.makerAssetAmount.times(0.06),
+            });
+            signedOrdersWithFee = [highFeeZRXOrder];
+            feeOrders = [];
+            const makerAssetAmount = signedOrder.makerAssetAmount.div(2);
+            const fillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                signedOrdersWithFee,
+                feeOrders,
+                feeProportion,
+                makerAssetAmount,
+            );
+            return expectRevertOrAlwaysFailingTransactionAsync(
+                forwarderWrapper.marketBuyTokensWithEthAsync(signedOrdersWithFee, feeOrders, makerAssetAmount, {
+                    from: takerAddress,
+                    value: fillAmountWei,
+                }),
+            );
+        });
+        it('throws if fees are higher than 5% when buying erc20', async () => {
+            const highFeeERC20Order = orderFactory.newSignedOrder({
+                takerFee: signedOrder.makerAssetAmount.times(0.06),
+            });
+            signedOrdersWithFee = [highFeeERC20Order];
+            feeOrders = [feeOrder];
+            const makerAssetAmount = signedOrder.makerAssetAmount.div(2);
+            const fillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                signedOrdersWithFee,
+                feeOrders,
+                feeProportion,
+                makerAssetAmount,
+            );
+            return expectRevertOrAlwaysFailingTransactionAsync(
+                forwarderWrapper.marketBuyTokensWithEthAsync(signedOrdersWithFee, feeOrders, makerAssetAmount, {
+                    from: takerAddress,
+                    value: fillAmountWei,
+                }),
+            );
+        });
+        it('throws if makerAssetAmount is 0', async () => {
+            const makerAssetAmount = new BigNumber(0);
+            const fillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                signedOrdersWithFee,
+                feeOrders,
+                feeProportion,
+                makerAssetAmount,
+            );
+            return expectRevertOrAlwaysFailingTransactionAsync(
+                forwarderWrapper.marketBuyTokensWithEthAsync(signedOrdersWithFee, feeOrders, makerAssetAmount, {
+                    from: takerAddress,
+                    value: fillAmountWei,
+                }),
+            );
+        });
+        it('throws if the amount of ETH sent in is less than the takerAssetFilledAmount', async () => {
+            const makerAssetAmount = signedOrder.makerAssetAmount;
+            const fillAmount = signedOrder.takerAssetAmount.div(2);
+            const zero = new BigNumber(0);
+            // Deposit enough taker balance to fill the order
+            const wethDepositTxHash = await wethContract.deposit.sendTransactionAsync({
+                from: takerAddress,
+                value: signedOrder.takerAssetAmount,
+            });
+            await web3Wrapper.awaitTransactionSuccessAsync(wethDepositTxHash);
+            // Transfer all of this WETH to the forwarding contract
+            const wethTransferTxHash = await wethContract.transfer.sendTransactionAsync(
+                forwarderContract.address,
+                signedOrder.takerAssetAmount,
+                { from: takerAddress },
+            );
+            await web3Wrapper.awaitTransactionSuccessAsync(wethTransferTxHash);
+            // We use the contract directly to get around wrapper validations and calculations
+            const formattedOrders = formatters.createMarketSellOrders(signedOrders, zero);
+            const formattedFeeOrders = formatters.createMarketSellOrders(feeOrders, zero);
+            return expectRevertOrAlwaysFailingTransactionAsync(
+                forwarderContract.marketBuyTokensWithEth.sendTransactionAsync(
+                    formattedOrders.orders,
+                    formattedOrders.signatures,
+                    formattedFeeOrders.orders,
+                    formattedFeeOrders.signatures,
+                    makerAssetAmount,
+                    zero,
+                    constants.NULL_ADDRESS,
+                    { value: fillAmount, from: takerAddress },
+                ),
+            );
+        });
+    });
+    describe('marketBuyTokensWithEth - ERC721', async () => {
+        it('buys ERC721 assets', async () => {
+            const makerAssetId = erc721MakerAssetIds[0];
+            signedOrder = orderFactory.newSignedOrder({
+                makerAssetAmount: new BigNumber(1),
+                makerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
+            });
+            feeOrders = [];
+            signedOrders = [signedOrder];
+            const makerAssetAmount = new BigNumber(signedOrders.length);
+            const fillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                signedOrders,
+                feeOrders,
+                feeProportion,
+                makerAssetAmount,
+            );
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync(signedOrders, feeOrders, makerAssetAmount, {
+                from: takerAddress,
+                value: fillAmountWei,
+            });
+            const newOwnerTakerAsset = await erc721Token.ownerOf.callAsync(makerAssetId);
+            expect(newOwnerTakerAsset).to.be.bignumber.equal(takerAddress);
+        });
+        it('buys ERC721 assets with fee abstraction', async () => {
+            const makerAssetId = erc721MakerAssetIds[0];
+            signedOrder = orderFactory.newSignedOrder({
+                makerAssetAmount: new BigNumber(1),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), DECIMALS_DEFAULT),
+                makerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
+            });
+            signedOrders = [signedOrder];
+            const makerAssetAmount = new BigNumber(signedOrders.length);
+            const fillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                signedOrders,
+                feeOrders,
+                feeProportion,
+                makerAssetAmount,
+            );
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync(signedOrders, feeOrders, makerAssetAmount, {
+                from: takerAddress,
+                value: fillAmountWei,
+            });
+            const newOwnerTakerAsset = await erc721Token.ownerOf.callAsync(makerAssetId);
+            expect(newOwnerTakerAsset).to.be.bignumber.equal(takerAddress);
+        });
+        it('buys ERC721 assets with fee abstraction and pays fee to fee recipient', async () => {
+            const makerAssetId = erc721MakerAssetIds[0];
+            signedOrder = orderFactory.newSignedOrder({
+                makerAssetAmount: new BigNumber(1),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(1), DECIMALS_DEFAULT),
+                makerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
+            });
+            signedOrders = [signedOrder];
+            feeProportion = 100;
+            const initTakerBalanceWei = await web3Wrapper.getBalanceInWeiAsync(takerAddress);
+            const initFeeRecipientBalanceWei = await web3Wrapper.getBalanceInWeiAsync(feeRecipientAddress);
+            const makerAssetAmount = new BigNumber(signedOrders.length);
+            const fillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                signedOrders,
+                feeOrders,
+                feeProportion,
+                makerAssetAmount,
+            );
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync(
+                signedOrders,
+                feeOrders,
+                makerAssetAmount,
+                {
+                    from: takerAddress,
+                    value: fillAmountWei,
+                    gasPrice: DEFAULT_GAS_PRICE,
+                },
+                {
+                    feeProportion,
+                    feeRecipient: feeRecipientAddress,
+                },
+            );
+            const afterFeeRecipientEthBalance = await web3Wrapper.getBalanceInWeiAsync(feeRecipientAddress);
+            const afterTakerBalanceWei = await web3Wrapper.getBalanceInWeiAsync(takerAddress);
+            const takerFilledAmount = initTakerBalanceWei.minus(afterTakerBalanceWei).plus(tx.gasUsed);
+            const newOwnerTakerAsset = await erc721Token.ownerOf.callAsync(makerAssetId);
+            expect(newOwnerTakerAsset).to.be.bignumber.equal(takerAddress);
+            const balanceDiff = afterFeeRecipientEthBalance.minus(initFeeRecipientBalanceWei);
+            expect(takerFilledAmount.dividedToIntegerBy(balanceDiff)).to.be.bignumber.equal(101);
+            expect(takerFilledAmount.minus(balanceDiff).dividedToIntegerBy(balanceDiff)).to.be.bignumber.equal(100);
+        });
+        it('buys multiple ERC721 assets with fee abstraction and pays fee to fee recipient', async () => {
+            const makerAssetId1 = erc721MakerAssetIds[0];
+            const makerAssetId2 = erc721MakerAssetIds[1];
+            const signedOrder1 = orderFactory.newSignedOrder({
+                makerAssetAmount: new BigNumber(1),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(3), DECIMALS_DEFAULT),
+                makerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, makerAssetId1),
+            });
+            const signedOrder2 = orderFactory.newSignedOrder({
+                makerAssetAmount: new BigNumber(1),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(4), DECIMALS_DEFAULT),
+                makerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, makerAssetId2),
+            });
+            signedOrders = [signedOrder1, signedOrder2];
+            feeProportion = 10;
+            const makerAssetAmount = new BigNumber(signedOrders.length);
+            const fillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                signedOrders,
+                feeOrders,
+                feeProportion,
+                makerAssetAmount,
+            );
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync(signedOrders, feeOrders, makerAssetAmount, {
+                from: takerAddress,
+                value: fillAmountWei,
+            });
+            const newOwnerTakerAsset1 = await erc721Token.ownerOf.callAsync(makerAssetId1);
+            expect(newOwnerTakerAsset1).to.be.bignumber.equal(takerAddress);
+            const newOwnerTakerAsset2 = await erc721Token.ownerOf.callAsync(makerAssetId2);
+            expect(newOwnerTakerAsset2).to.be.bignumber.equal(takerAddress);
+        });
+        it('buys ERC721 assets with fee abstraction and handles fee orders filled and excess eth', async () => {
+            const makerAssetId = erc721MakerAssetIds[0];
+            feeProportion = 0;
+            // In this scenario a total of 6 ZRX fees need to be paid.
+            // There are two fee orders, but the first fee order is partially filled while
+            // the Forwarding contract tx is in the mempool.
+            const erc721MakerAssetAmount = new BigNumber(1);
+            signedOrder = orderFactory.newSignedOrder({
+                makerAssetAmount: erc721MakerAssetAmount,
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), DECIMALS_DEFAULT),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(6), DECIMALS_DEFAULT),
+                makerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
+            });
+            signedOrders = [signedOrder];
+            const firstFeeOrder = orderFactory.newSignedOrder({
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(8), DECIMALS_DEFAULT),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(0.1), DECIMALS_DEFAULT),
+                makerAssetData: assetProxyUtils.encodeERC20AssetData(zrxToken.address),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(0), DECIMALS_DEFAULT),
+            });
+            const secondFeeOrder = orderFactory.newSignedOrder({
+                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(8), DECIMALS_DEFAULT),
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(0.12), DECIMALS_DEFAULT),
+                makerAssetData: assetProxyUtils.encodeERC20AssetData(zrxToken.address),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(0), DECIMALS_DEFAULT),
+            });
+            feeOrders = [firstFeeOrder, secondFeeOrder];
+            const makerAssetAmount = new BigNumber(signedOrders.length);
+            const fillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                signedOrders,
+                feeOrders,
+                feeProportion,
+                erc721MakerAssetAmount,
+            );
+            // Simulate another otherAddress user partially filling firstFeeOrder
+            const firstFeeOrderFillAmount = firstFeeOrder.makerAssetAmount.div(2);
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync([firstFeeOrder], [], firstFeeOrderFillAmount, {
+                from: otherAddress,
+                value: fillAmountWei,
+            });
+            // For tests we calculate how much this should've cost given that firstFeeOrder was filled
+            const expectedFillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                signedOrders,
+                feeOrders,
+                feeProportion,
+                erc721MakerAssetAmount,
+            );
+            // With 4 ZRX remaining in firstFeeOrder, the secondFeeOrder will need to be filled to make up
+            // the total amount of fees required (6)
+            // Since the fee orders can be filled while the transaction is pending the user safely sends in
+            // extra ether to cover any slippage
+            const initEthBalance = await web3Wrapper.getBalanceInWeiAsync(takerAddress);
+            const slippageFillAmountWei = fillAmountWei.times(2);
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync(signedOrders, feeOrders, makerAssetAmount, {
+                from: takerAddress,
+                value: slippageFillAmountWei,
+                gasPrice: DEFAULT_GAS_PRICE,
+            });
+            const afterEthBalance = await web3Wrapper.getBalanceInWeiAsync(takerAddress);
+            const expectedEthBalanceAfterGasCosts = initEthBalance.minus(expectedFillAmountWei).minus(tx.gasUsed);
+            const newOwnerTakerAsset = await erc721Token.ownerOf.callAsync(makerAssetId);
+            expect(newOwnerTakerAsset).to.be.bignumber.equal(takerAddress);
+            expect(afterEthBalance).to.be.bignumber.equal(expectedEthBalanceAfterGasCosts);
+        });
+        it('buys ERC721 assets with fee abstraction and handles fee orders filled', async () => {
+            const makerAssetId = erc721MakerAssetIds[0];
+            feeProportion = 0;
+            // In this scenario a total of 6 ZRX fees need to be paid.
+            // There are two fee orders, but the first fee order is partially filled while
+            // the Forwarding contract tx is in the mempool.
+            const erc721MakerAssetAmount = new BigNumber(1);
+            signedOrder = orderFactory.newSignedOrder({
+                makerAssetAmount: erc721MakerAssetAmount,
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), DECIMALS_DEFAULT),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(6), DECIMALS_DEFAULT),
+                makerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
+            });
+            const zrxMakerAssetAmount = Web3Wrapper.toBaseUnitAmount(new BigNumber(8), DECIMALS_DEFAULT);
+            signedOrders = [signedOrder];
+            const firstFeeOrder = orderFactory.newSignedOrder({
+                makerAssetAmount: zrxMakerAssetAmount,
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(0.1), DECIMALS_DEFAULT),
+                makerAssetData: assetProxyUtils.encodeERC20AssetData(zrxToken.address),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(0), DECIMALS_DEFAULT),
+            });
+            const secondFeeOrder = orderFactory.newSignedOrder({
+                makerAssetAmount: zrxMakerAssetAmount,
+                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(0.12), DECIMALS_DEFAULT),
+                makerAssetData: assetProxyUtils.encodeERC20AssetData(zrxToken.address),
+                takerFee: Web3Wrapper.toBaseUnitAmount(new BigNumber(0), DECIMALS_DEFAULT),
+            });
+            feeOrders = [firstFeeOrder, secondFeeOrder];
+            const makerAssetAmount = new BigNumber(signedOrders.length);
+            const fillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                signedOrders,
+                feeOrders,
+                feeProportion,
+                erc721MakerAssetAmount,
+            );
+            // Simulate another otherAddress user partially filling firstFeeOrder
+            const firstFeeOrderFillAmount = firstFeeOrder.makerAssetAmount.div(2);
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync([firstFeeOrder], [], firstFeeOrderFillAmount, {
+                from: otherAddress,
+                value: fillAmountWei,
+            });
+            const expectedFillAmountWei = await forwarderWrapper.calculateMarketBuyFillAmountWeiAsync(
+                signedOrders,
+                feeOrders,
+                feeProportion,
+                erc721MakerAssetAmount,
+            );
+            tx = await forwarderWrapper.marketBuyTokensWithEthAsync(signedOrders, feeOrders, makerAssetAmount, {
+                from: takerAddress,
+                value: expectedFillAmountWei,
+            });
+            const newOwnerTakerAsset = await erc721Token.ownerOf.callAsync(makerAssetId);
+            expect(newOwnerTakerAsset).to.be.bignumber.equal(takerAddress);
+        });
+        it('throws when mixed ERC721 and ERC20 assets', async () => {
+            const makerAssetId = erc721MakerAssetIds[0];
+            const erc721SignedOrder = orderFactory.newSignedOrder({
+                makerAssetAmount: new BigNumber(1),
+                makerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
+            });
+            const erc20SignedOrder = orderFactory.newSignedOrder();
+            signedOrders = [erc721SignedOrder, erc20SignedOrder];
+            const makerAssetAmount = new BigNumber(signedOrders.length);
+            const fillAmountWei = erc20SignedOrder.takerAssetAmount.plus(erc721SignedOrder.takerAssetAmount);
+            return expectRevertOrAlwaysFailingTransactionAsync(
+                forwarderWrapper.marketBuyTokensWithEthAsync(signedOrders, feeOrders, makerAssetAmount, {
+                    from: takerAddress,
+                    value: fillAmountWei,
+                }),
+            );
+        });
+        it('throws when mixed ERC721 and ERC20 assets with ERC20 first', async () => {
+            const makerAssetId = erc721MakerAssetIds[0];
+            const erc721SignedOrder = orderFactory.newSignedOrder({
+                makerAssetAmount: new BigNumber(1),
+                makerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
+            });
+            const erc20SignedOrder = orderFactory.newSignedOrder();
+            signedOrders = [erc20SignedOrder, erc721SignedOrder];
+            const makerAssetAmount = new BigNumber(signedOrders.length);
+            const fillAmountWei = erc20SignedOrder.takerAssetAmount.plus(erc721SignedOrder.takerAssetAmount);
+            return expectRevertOrAlwaysFailingTransactionAsync(
+                forwarderWrapper.marketBuyTokensWithEthAsync(signedOrders, feeOrders, makerAssetAmount, {
+                    from: takerAddress,
+                    value: fillAmountWei,
+                }),
+            );
+        });
+    });
+});
+// tslint:disable:max-file-line-count
+// tslint:enable:no-unnecessary-type-assertion
diff --git a/packages/contracts/test/utils/artifacts.ts b/packages/contracts/test/utils/artifacts.ts
index 23e93c085..d3f808218 100644
--- a/packages/contracts/test/utils/artifacts.ts
+++ b/packages/contracts/test/utils/artifacts.ts
@@ -8,6 +8,7 @@ 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 MixinAuthorizable from '../../artifacts/MixinAuthorizable.json';
 import * as MultiSigWallet from '../../artifacts/MultiSigWallet.json';
@@ -34,6 +35,7 @@ export const artifacts = {
     Exchange: (Exchange as any) as ContractArtifact,
     ExchangeWrapper: (ExchangeWrapper as any) as ContractArtifact,
     EtherToken: (EtherToken as any) as ContractArtifact,
+    Forwarder: (Forwarder as any) as ContractArtifact,
     IAssetProxy: (IAssetProxy as any) as ContractArtifact,
     MixinAuthorizable: (MixinAuthorizable as any) as ContractArtifact,
     MultiSigWallet: (MultiSigWallet as any) as ContractArtifact,
diff --git a/packages/contracts/test/utils/erc20_wrapper.ts b/packages/contracts/test/utils/erc20_wrapper.ts
index 53e9791bc..9351b1e3d 100644
--- a/packages/contracts/test/utils/erc20_wrapper.ts
+++ b/packages/contracts/test/utils/erc20_wrapper.ts
@@ -138,6 +138,14 @@ export class ERC20Wrapper {
         });
         return balancesByOwner;
     }
+    public addDummyTokenContract(dummy: DummyERC20TokenContract): void {
+        if (!_.isUndefined(this._dummyTokenContracts)) {
+            this._dummyTokenContracts.push(dummy);
+        }
+    }
+    public addTokenOwnerAddress(address: string): void {
+        this._tokenOwnerAddresses.push(address);
+    }
     public getTokenOwnerAddresses(): string[] {
         return this._tokenOwnerAddresses;
     }
diff --git a/packages/contracts/test/utils/forwarder_wrapper.ts b/packages/contracts/test/utils/forwarder_wrapper.ts
new file mode 100644
index 000000000..d227420ee
--- /dev/null
+++ b/packages/contracts/test/utils/forwarder_wrapper.ts
@@ -0,0 +1,220 @@
+import { assetProxyUtils } from '@0xproject/order-utils';
+import { AssetProxyId, SignedOrder } from '@0xproject/types';
+import { BigNumber } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import { Provider, TransactionReceiptWithDecodedLogs, TxDataPayable } from 'ethereum-types';
+import * as _ from 'lodash';
+
+import { ForwarderContract } from '../../generated_contract_wrappers/forwarder';
+
+import { constants } from './constants';
+import { formatters } from './formatters';
+import { LogDecoder } from './log_decoder';
+import { MarketSellOrders } from './types';
+
+const DEFAULT_FEE_PROPORTION = 0;
+const PERCENTAGE_DENOMINATOR = 10000;
+const ZERO_AMOUNT = new BigNumber(0);
+const INSUFFICENT_ORDERS_FOR_MAKER_AMOUNT = 'Unable to satisfy makerAssetFillAmount with provided orders';
+
+export class ForwarderWrapper {
+    private _web3Wrapper: Web3Wrapper;
+    private _forwarderContract: ForwarderContract;
+    private _logDecoder: LogDecoder;
+    private _zrxAddress: string;
+    private static _createOptimizedSellOrders(signedOrders: SignedOrder[]): MarketSellOrders {
+        const marketSellOrders = formatters.createMarketSellOrders(signedOrders, ZERO_AMOUNT);
+        const assetDataId = assetProxyUtils.decodeAssetDataId(signedOrders[0].makerAssetData);
+        // Contract will fill this in for us as all of the assetData is assumed to be the same
+        for (let i = 0; i < signedOrders.length; i++) {
+            if (i !== 0 && assetDataId === AssetProxyId.ERC20) {
+                // Forwarding contract will fill this in from the first order
+                marketSellOrders.orders[i].makerAssetData = constants.NULL_BYTES;
+            }
+            marketSellOrders.orders[i].takerAssetData = constants.NULL_BYTES;
+        }
+        return marketSellOrders;
+    }
+    private static _createOptimizedZRXSellOrders(signedOrders: SignedOrder[]): MarketSellOrders {
+        const marketSellOrders = formatters.createMarketSellOrders(signedOrders, ZERO_AMOUNT);
+        // Contract will fill this in for us as all of the assetData is assumed to be the same
+        for (let i = 0; i < signedOrders.length; i++) {
+            marketSellOrders.orders[i].makerAssetData = constants.NULL_BYTES;
+            marketSellOrders.orders[i].takerAssetData = constants.NULL_BYTES;
+        }
+        return marketSellOrders;
+    }
+    private static _calculateAdditionalFeeProportionAmount(feeProportion: number, fillAmountWei: BigNumber): BigNumber {
+        if (feeProportion > 0) {
+            // Add to the total ETH transaction to ensure all NFTs can be filled after fees
+            // 150 = 1.5% = 0.015
+            const denominator = new BigNumber(1).minus(new BigNumber(feeProportion).dividedBy(PERCENTAGE_DENOMINATOR));
+            return fillAmountWei.dividedBy(denominator).round(0, BigNumber.ROUND_FLOOR);
+        }
+        return fillAmountWei;
+    }
+    constructor(contractInstance: ForwarderContract, provider: Provider, zrxAddress: string) {
+        this._forwarderContract = contractInstance;
+        this._web3Wrapper = new Web3Wrapper(provider);
+        this._logDecoder = new LogDecoder(this._web3Wrapper, this._forwarderContract.address);
+        // this._web3Wrapper.abiDecoder.addABI(contractInstance.abi);
+        this._zrxAddress = zrxAddress;
+    }
+    public async marketBuyTokensWithEthAsync(
+        orders: SignedOrder[],
+        feeOrders: SignedOrder[],
+        makerTokenBuyAmount: BigNumber,
+        txData: TxDataPayable,
+        opts: { feeProportion?: number; feeRecipient?: string } = {},
+    ): Promise<TransactionReceiptWithDecodedLogs> {
+        const params = ForwarderWrapper._createOptimizedSellOrders(orders);
+        const feeParams = ForwarderWrapper._createOptimizedZRXSellOrders(feeOrders);
+        const feeProportion = _.isUndefined(opts.feeProportion) ? DEFAULT_FEE_PROPORTION : opts.feeProportion;
+        const feeRecipient = _.isUndefined(opts.feeRecipient) ? constants.NULL_ADDRESS : opts.feeRecipient;
+        const txHash: string = await this._forwarderContract.marketBuyTokensWithEth.sendTransactionAsync(
+            params.orders,
+            params.signatures,
+            feeParams.orders,
+            feeParams.signatures,
+            makerTokenBuyAmount,
+            feeProportion,
+            feeRecipient,
+            txData,
+        );
+        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
+        return tx;
+    }
+    public async marketSellEthForERC20Async(
+        orders: SignedOrder[],
+        feeOrders: SignedOrder[],
+        txData: TxDataPayable,
+        opts: { feeProportion?: number; feeRecipient?: string } = {},
+    ): Promise<TransactionReceiptWithDecodedLogs> {
+        const assetDataId = assetProxyUtils.decodeAssetDataId(orders[0].makerAssetData);
+        if (assetDataId !== AssetProxyId.ERC20) {
+            throw new Error('Asset type not supported by marketSellEthForERC20');
+        }
+        const params = ForwarderWrapper._createOptimizedSellOrders(orders);
+        const feeParams = ForwarderWrapper._createOptimizedZRXSellOrders(feeOrders);
+        const feeProportion = _.isUndefined(opts.feeProportion) ? DEFAULT_FEE_PROPORTION : opts.feeProportion;
+        const feeRecipient = _.isUndefined(opts.feeRecipient) ? constants.NULL_ADDRESS : opts.feeRecipient;
+        const txHash: string = await this._forwarderContract.marketSellEthForERC20.sendTransactionAsync(
+            params.orders,
+            params.signatures,
+            feeParams.orders,
+            feeParams.signatures,
+            feeProportion,
+            feeRecipient,
+            txData,
+        );
+        const tx = await this._logDecoder.getTxWithDecodedLogsAsync(txHash);
+        return tx;
+    }
+    public async calculateMarketBuyFillAmountWeiAsync(
+        orders: SignedOrder[],
+        feeOrders: SignedOrder[],
+        feeProportion: number,
+        makerAssetFillAmount: BigNumber,
+    ): Promise<BigNumber> {
+        const assetProxyId = assetProxyUtils.decodeAssetDataId(orders[0].makerAssetData);
+        switch (assetProxyId) {
+            case AssetProxyId.ERC20: {
+                const fillAmountWei = this._calculateMarketBuyERC20FillAmountAsync(
+                    orders,
+                    feeOrders,
+                    feeProportion,
+                    makerAssetFillAmount,
+                );
+                return fillAmountWei;
+            }
+            case AssetProxyId.ERC721: {
+                const fillAmountWei = await this._calculateMarketBuyERC721FillAmountAsync(
+                    orders,
+                    feeOrders,
+                    feeProportion,
+                );
+                return fillAmountWei;
+            }
+            default:
+                throw new Error(`Invalid Asset Proxy Id: ${assetProxyId}`);
+        }
+    }
+    private async _calculateMarketBuyERC20FillAmountAsync(
+        orders: SignedOrder[],
+        feeOrders: SignedOrder[],
+        feeProportion: number,
+        makerAssetFillAmount: BigNumber,
+    ): Promise<BigNumber> {
+        const makerAssetData = assetProxyUtils.decodeAssetData(orders[0].makerAssetData);
+        const makerAssetToken = makerAssetData.tokenAddress;
+        const params = formatters.createMarketBuyOrders(orders, makerAssetFillAmount);
+
+        let fillAmountWei;
+        if (makerAssetToken === this._zrxAddress) {
+            // If buying ZRX we buy the tokens and fees from the ZRX order in one step
+            const expectedBuyFeeTokensFillResults = await this._forwarderContract.calculateMarketBuyZrxResults.callAsync(
+                params.orders,
+                makerAssetFillAmount,
+            );
+            if (expectedBuyFeeTokensFillResults.makerAssetFilledAmount.lessThan(makerAssetFillAmount)) {
+                throw new Error(INSUFFICENT_ORDERS_FOR_MAKER_AMOUNT);
+            }
+            fillAmountWei = expectedBuyFeeTokensFillResults.takerAssetFilledAmount;
+        } else {
+            const expectedMarketBuyFillResults = await this._forwarderContract.calculateMarketBuyResults.callAsync(
+                params.orders,
+                makerAssetFillAmount,
+            );
+            if (expectedMarketBuyFillResults.makerAssetFilledAmount.lessThan(makerAssetFillAmount)) {
+                throw new Error(INSUFFICENT_ORDERS_FOR_MAKER_AMOUNT);
+            }
+            fillAmountWei = expectedMarketBuyFillResults.takerAssetFilledAmount;
+            const expectedFeeAmount = expectedMarketBuyFillResults.takerFeePaid;
+            if (expectedFeeAmount.greaterThan(ZERO_AMOUNT)) {
+                const expectedFeeFillFillAmountWei = await this._calculateMarketBuyERC20FillAmountAsync(
+                    feeOrders,
+                    [],
+                    DEFAULT_FEE_PROPORTION,
+                    expectedFeeAmount,
+                );
+                fillAmountWei = fillAmountWei.plus(expectedFeeFillFillAmountWei);
+            }
+        }
+        fillAmountWei = ForwarderWrapper._calculateAdditionalFeeProportionAmount(feeProportion, fillAmountWei);
+        return fillAmountWei;
+    }
+    private async _calculateMarketBuyERC721FillAmountAsync(
+        orders: SignedOrder[],
+        feeOrders: SignedOrder[],
+        feeProportion: number,
+    ): Promise<BigNumber> {
+        // Total cost when buying ERC721 is the total cost of all ERC721 orders + any fee abstraction
+        let fillAmountWei = _.reduce(
+            orders,
+            (totalAmount: BigNumber, order: SignedOrder) => {
+                return totalAmount.plus(order.takerAssetAmount);
+            },
+            ZERO_AMOUNT,
+        );
+        const totalFees = _.reduce(
+            orders,
+            (totalAmount: BigNumber, order: SignedOrder) => {
+                return totalAmount.plus(order.takerFee);
+            },
+            ZERO_AMOUNT,
+        );
+        if (totalFees.greaterThan(ZERO_AMOUNT)) {
+            // Calculate the ZRX fee abstraction cost
+            const emptyFeeOrders: SignedOrder[] = [];
+            const expectedFeeAmountWei = await this._calculateMarketBuyERC20FillAmountAsync(
+                feeOrders,
+                emptyFeeOrders,
+                DEFAULT_FEE_PROPORTION,
+                totalFees,
+            );
+            fillAmountWei = fillAmountWei.plus(expectedFeeAmountWei);
+        }
+        fillAmountWei = ForwarderWrapper._calculateAdditionalFeeProportionAmount(feeProportion, fillAmountWei);
+        return fillAmountWei;
+    }
+}
diff --git a/packages/contracts/test/utils/types.ts b/packages/contracts/test/utils/types.ts
index b792bb90a..67313b647 100644
--- a/packages/contracts/test/utils/types.ts
+++ b/packages/contracts/test/utils/types.ts
@@ -102,6 +102,7 @@ export enum ContractName {
     TestWallet = 'TestWallet',
     Authorizable = 'Authorizable',
     Whitelist = 'Whitelist',
+    Forwarder = 'Forwarder',
 }
 
 export interface SignedTransaction {
@@ -227,3 +228,10 @@ export interface FillScenario {
     makerStateScenario: TraderStateScenario;
     takerStateScenario: TraderStateScenario;
 }
+
+export interface FillResults {
+    makerAssetFilledAmount: BigNumber;
+    takerAssetFilledAmount: BigNumber;
+    makerFeePaid: BigNumber;
+    takerFeePaid: BigNumber;
+}