aboutsummaryrefslogtreecommitdiffstats
path: root/packages/contracts/src/2.0.0
diff options
context:
space:
mode:
authorJacob Evans <dekz@dekz.net>2018-07-06 14:29:56 +0800
committerGitHub <noreply@github.com>2018-07-06 14:29:56 +0800
commit03b3d74748a6328ac9637ca4e176a316ca347704 (patch)
treee7d98700e0a5b957048f50c5b5d2c5dfba5216a1 /packages/contracts/src/2.0.0
parentd975c0cef34d126ce30202610671a6f8dca6b6c0 (diff)
parent0557d6a9bfc07b8d360970ffbcf582f8a26943cb (diff)
downloaddexon-sol-tools-03b3d74748a6328ac9637ca4e176a316ca347704.tar
dexon-sol-tools-03b3d74748a6328ac9637ca4e176a316ca347704.tar.gz
dexon-sol-tools-03b3d74748a6328ac9637ca4e176a316ca347704.tar.bz2
dexon-sol-tools-03b3d74748a6328ac9637ca4e176a316ca347704.tar.lz
dexon-sol-tools-03b3d74748a6328ac9637ca4e176a316ca347704.tar.xz
dexon-sol-tools-03b3d74748a6328ac9637ca4e176a316ca347704.tar.zst
dexon-sol-tools-03b3d74748a6328ac9637ca4e176a316ca347704.zip
Merge pull request #522 from 0xProject/feature/contracts/forwarder
Forwarding contract
Diffstat (limited to 'packages/contracts/src/2.0.0')
-rw-r--r--packages/contracts/src/2.0.0/forwarder/Forwarder.sol81
-rw-r--r--packages/contracts/src/2.0.0/forwarder/MixinConstants.sol49
-rw-r--r--packages/contracts/src/2.0.0/forwarder/MixinERC20.sol68
-rw-r--r--packages/contracts/src/2.0.0/forwarder/MixinERC721.sol64
-rw-r--r--packages/contracts/src/2.0.0/forwarder/MixinErrorMessages.sol33
-rw-r--r--packages/contracts/src/2.0.0/forwarder/MixinExpectedResults.sol158
-rw-r--r--packages/contracts/src/2.0.0/forwarder/MixinMarketBuyTokens.sol258
-rw-r--r--packages/contracts/src/2.0.0/forwarder/MixinMarketBuyZrx.sol80
-rw-r--r--packages/contracts/src/2.0.0/forwarder/MixinMarketSellTokens.sol196
-rw-r--r--packages/contracts/src/2.0.0/forwarder/MixinWethFees.sol114
-rw-r--r--packages/contracts/src/2.0.0/protocol/Exchange/MixinExchangeCore.sol2
11 files changed, 1102 insertions, 1 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;
+ }
+}
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 5ab7aa63f..9e63dc1c0 100644
--- a/packages/contracts/src/2.0.0/protocol/Exchange/MixinExchangeCore.sol
+++ b/packages/contracts/src/2.0.0/protocol/Exchange/MixinExchangeCore.sol
@@ -397,7 +397,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.