Merge pull request #522 from 0xProject/feature/contracts/forwarder

Forwarding contract

10 files changed, 1101 insertions, 0 deletions

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;
+    }
+}