Add transfer simulator and reorder Exchange transfers

contracts/dev-utils/CHANGELOG.json

@@ -21,6 +21,10 @@
             {
                 "note": "Refactor `OrderValidationUtils` to calculate `fillableTakerAssetAmount`",
                 "pr": 1848
+            },
+            {
+                "note": "Add `OrderTransferSimulationUtils` contract for simulating order transfers on-chain",
+                "pr": 1868
             }
         ]
     }

contracts/dev-utils/compiler.json

@@ -22,5 +22,10 @@
             }
         }
     },
-    "contracts": ["src/DevUtils.sol", "src/LibAssetData.sol", "src/LibTransactionDecoder.sol"]
+    "contracts": [
+        "src/DevUtils.sol",
+        "src/LibAssetData.sol",
+        "src/LibTransactionDecoder.sol",
+        "src/OrderTransferSimulationUtils.sol"
+    ]
 }

contracts/dev-utils/contracts/src/DevUtils.sol

@@ -20,16 +20,19 @@ pragma solidity ^0.5.5;
 pragma experimental ABIEncoderV2;
 
 import "./OrderValidationUtils.sol";
+import "./OrderTransferSimulationUtils.sol";
 import "./LibTransactionDecoder.sol";
 
 
 // solhint-disable no-empty-blocks
 contract DevUtils is
     OrderValidationUtils,
+    OrderTransferSimulationUtils,
     LibTransactionDecoder
 {
     constructor (address _exchange)
         public
         OrderValidationUtils(_exchange)
+        OrderTransferSimulationUtils(_exchange)
     {}
 }

contracts/dev-utils/contracts/src/OrderTransferSimulationUtils.sol

@@ -0,0 +1,152 @@
+/*
+
+  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.5.5;
+pragma experimental ABIEncoderV2;
+
+
+import "@0x/contracts-exchange/contracts/src/interfaces/IExchange.sol";
+import "@0x/contracts-exchange/contracts/src/libs/LibExchangeRichErrorDecoder.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
+import "@0x/contracts-utils/contracts/src/LibBytes.sol";
+
+
+contract OrderTransferSimulationUtils is
+    LibExchangeRichErrorDecoder
+{
+    using LibBytes for bytes;
+
+    enum OrderTransferResults {
+        TakerAssetDataFailed,     // Transfer of takerAsset failed
+        MakerAssetDataFailed,     // Transfer of makerAsset failed
+        TakerFeeAssetDataFailed,  // Transfer of takerFeeAsset failed
+        MakerFeeAssetDataFailed,  // Transfer of makerFeeAsset failed
+        TransfersSuccessful       // All transfers in the order were successful
+    }
+
+    // simulateDispatchTransferFromCalls(bytes[],address[],address[],uint256[])
+    bytes4 constant internal _SIMULATE_DISPATCH_TRANSFER_FROM_CALLS_SELECTOR = 0xb04fbddd;
+
+    // keccak256(abi.encodeWithSignature("Error(string)", "TRANSFERS_SUCCESSFUL"));
+    bytes32 constant internal _TRANSFERS_SUCCESSFUL_RESULT_HASH = 0xf43f26ea5a94b478394a975e856464913dc1a8a1ca70939d974aa7c238aa0ce0;
+
+    // solhint-disable var-name-mixedcase
+    IExchange internal _EXCHANGE;
+    // solhint-enable var-name-mixedcase
+
+    constructor (address _exchange)
+        public
+    {
+        _EXCHANGE = IExchange(_exchange);
+    }
+
+    /// @dev Simulates all of the transfers within an order and returns the index of the first failed transfer.
+    /// @param order The order to simulate transfers for.
+    /// @param takerAddress The address of the taker that will fill the order.
+    /// @param takerAssetFillAmount The amount of takerAsset that the taker wished to fill.
+    /// @return The index of the first failed transfer (or 4 if all transfers are successful).
+    function getSimulatedOrderTransferResults(
+        LibOrder.Order memory order,
+        address takerAddress,
+        uint256 takerAssetFillAmount
+    )
+        public
+        returns (OrderTransferResults orderTransferResults)
+    {
+        // Create input arrays
+        bytes[] memory assetData = new bytes[](4);
+        address[] memory fromAddresses = new address[](4);
+        address[] memory toAddresses = new address[](4);
+        uint256[] memory amounts = new uint256[](4);
+
+        // Transfer `takerAsset` from taker to maker
+        assetData[0] = order.takerAssetData;
+        fromAddresses[0] = takerAddress;
+        toAddresses[0] = order.makerAddress;
+        amounts[0] = order.takerAssetAmount;
+
+        // Transfer `makerAsset` from maker to taker
+        assetData[1] = order.makerAssetData;
+        fromAddresses[1] = order.makerAddress;
+        toAddresses[1] = takerAddress;
+        amounts[1] = order.makerAssetAmount;
+
+        // Transfer `takerFeeAsset` from taker to feeRecipient
+        assetData[2] = order.takerFeeAssetData;
+        fromAddresses[2] = takerAddress;
+        toAddresses[2] = order.feeRecipientAddress;
+        amounts[2] = order.takerFee;
+
+        // Transfer `makerFeeAsset` from maker to feeRecipient
+        assetData[3] = order.makerFeeAssetData;
+        fromAddresses[3] = order.makerAddress;
+        toAddresses[3] = order.feeRecipientAddress;
+        amounts[3] = order.makerFee;
+
+        // Encode data for `simulateDispatchTransferFromCalls(assetData, fromAddresses, toAddresses, amounts)`
+        bytes memory simulateDispatchTransferFromCallsData = abi.encodeWithSelector(
+            _SIMULATE_DISPATCH_TRANSFER_FROM_CALLS_SELECTOR,
+            assetData,
+            fromAddresses,
+            toAddresses,
+            amounts
+        );
+
+        // Perform call and catch revert
+        (, bytes memory returnData) = address(_EXCHANGE).call(simulateDispatchTransferFromCallsData);
+
+        bytes4 selector = returnData.readBytes4(0);
+        if (selector == ASSET_PROXY_DISPATCH_ERROR_SELECTOR) {
+            // Decode AssetProxyDispatchError and return index of failed transfer
+            (, bytes32 failedTransferIndex,) = decodeAssetProxyDispatchError(returnData);
+            return OrderTransferResults(uint8(uint256(failedTransferIndex)));
+        } else if (selector == ASSET_PROXY_TRANSFER_ERROR_SELECTOR) {
+            // Decode AssetProxyTransferError and return index of failed transfer
+            (bytes32 failedTransferIndex, ,) = decodeAssetProxyTransferError(returnData);
+            return OrderTransferResults(uint8(uint256(failedTransferIndex)));
+        } else if (keccak256(returnData) == _TRANSFERS_SUCCESSFUL_RESULT_HASH) {
+            // All transfers were successful
+            return OrderTransferResults.TransfersSuccessful;
+        }
+    }
+
+    /// @dev Simulates all of the transfers for each given order and returns the indices of each first failed transfer.
+    /// @param orders Array of orders to individually simulate transfers for.
+    /// @param takerAddresses Array of addresses of takers that will fill each order.
+    /// @param takerAssetFillAmounts Array of amounts of takerAsset that will be filled for each order.
+    /// @return The indices of the first failed transfer (or 4 if all transfers are successful) for each order.
+    function getSimulatedOrdersTransferResults(
+        LibOrder.Order[] memory orders,
+        address[] memory takerAddresses,
+        uint256[] memory takerAssetFillAmounts
+    )
+        public
+        returns (OrderTransferResults[] memory orderTransferResults)
+    {
+        uint256 length = orders.length;
+        orderTransferResults = new OrderTransferResults[](length);
+        for (uint256 i = 0; i != length; i++) {
+            orderTransferResults[i] = getSimulatedOrderTransferResults(
+                orders[i],
+                takerAddresses[i],
+                takerAssetFillAmounts[i]
+            );
+        }
+        return orderTransferResults;
+    }
+}

contracts/dev-utils/package.json

@@ -34,7 +34,7 @@
         "lint-contracts": "solhint -c ../.solhint.json contracts/**/**/**/**/*.sol"
     },
     "config": {
-        "abis": "./generated-artifacts/@(DevUtils|LibAssetData|LibTransactionDecoder).json",
+        "abis": "./generated-artifacts/@(DevUtils|LibAssetData|LibTransactionDecoder|OrderTransferSimulationUtils).json",
         "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually."
     },
     "repository": {

contracts/dev-utils/src/artifacts.ts

@@ -8,8 +8,10 @@ import { ContractArtifact } from 'ethereum-types';
 import * as DevUtils from '../generated-artifacts/DevUtils.json';
 import * as LibAssetData from '../generated-artifacts/LibAssetData.json';
 import * as LibTransactionDecoder from '../generated-artifacts/LibTransactionDecoder.json';
+import * as OrderTransferSimulationUtils from '../generated-artifacts/OrderTransferSimulationUtils.json';
 export const artifacts = {
     DevUtils: DevUtils as ContractArtifact,
-    LibTransactionDecoder: LibTransactionDecoder as ContractArtifact,
     LibAssetData: LibAssetData as ContractArtifact,
+    LibTransactionDecoder: LibTransactionDecoder as ContractArtifact,
+    OrderTransferSimulationUtils: OrderTransferSimulationUtils as ContractArtifact,
 };

contracts/dev-utils/src/wrappers.ts

@@ -6,3 +6,4 @@
 export * from '../generated-wrappers/dev_utils';
 export * from '../generated-wrappers/lib_asset_data';
 export * from '../generated-wrappers/lib_transaction_decoder';
+export * from '../generated-wrappers/order_transfer_simulation_utils';

contracts/dev-utils/test/order_validation_utils.ts

@@ -20,7 +20,7 @@ import {
 } from '@0x/contracts-test-utils';
 import { BlockchainLifecycle } from '@0x/dev-utils';
 import { assetDataUtils, orderHashUtils } from '@0x/order-utils';
-import { SignedOrder } from '@0x/types';
+import { OrderTransferResults, SignedOrder } from '@0x/types';
 import { BigNumber, providerUtils } from '@0x/utils';
 import * as chai from 'chai';
 
@@ -30,7 +30,7 @@ chaiSetup.configure();
 const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
 
-describe('OrderValidationUtils', () => {
+describe('OrderValidationUtils/OrderTransferSimulatorUtils', () => {
     let makerAddress: string;
     let takerAddress: string;
     let owner: string;
@@ -412,6 +412,7 @@ describe('OrderValidationUtils', () => {
     });
     describe('getOrderRelevantStates', async () => {
         it('should return the correct information for multiple orders', async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync();
             await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount);
             await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
                 from: makerAddress,
@@ -443,5 +444,149 @@ describe('OrderValidationUtils', () => {
             expect(isValidSignature[1]).to.equal(false);
         });
     });
+    describe('getSimulatedOrderTransferResults', () => {
+        beforeEach(async () => {
+            signedOrder = await orderFactory.newSignedOrderAsync();
+        });
+        it('should return TakerAssetDataFailed if the takerAsset transfer fails', async () => {
+            const orderTransferResults = await devUtils.getSimulatedOrderTransferResults.callAsync(
+                signedOrder,
+                takerAddress,
+                signedOrder.takerAssetAmount,
+            );
+            expect(orderTransferResults).to.equal(OrderTransferResults.TakerAssetDataFailed);
+        });
+        it('should return MakerAssetDataFailed if the makerAsset transfer fails', async () => {
+            await erc20Token2.setBalance.awaitTransactionSuccessAsync(takerAddress, signedOrder.takerAssetAmount, {
+                from: owner,
+            });
+            await erc20Token2.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.takerAssetAmount, {
+                from: takerAddress,
+            });
+            const orderTransferResults = await devUtils.getSimulatedOrderTransferResults.callAsync(
+                signedOrder,
+                takerAddress,
+                signedOrder.takerAssetAmount,
+            );
+            expect(orderTransferResults).to.equal(OrderTransferResults.MakerAssetDataFailed);
+        });
+        it('should return TakerFeeAssetDataFailed if the takerFeeAsset transfer fails', async () => {
+            await erc20Token2.setBalance.awaitTransactionSuccessAsync(takerAddress, signedOrder.takerAssetAmount, {
+                from: owner,
+            });
+            await erc20Token2.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.takerAssetAmount, {
+                from: takerAddress,
+            });
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount, {
+                from: owner,
+            });
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            const orderTransferResults = await devUtils.getSimulatedOrderTransferResults.callAsync(
+                signedOrder,
+                takerAddress,
+                signedOrder.takerAssetAmount,
+            );
+            expect(orderTransferResults).to.equal(OrderTransferResults.TakerFeeAssetDataFailed);
+        });
+        it('should return MakerFeeAssetDataFailed if the makerFeeAsset transfer fails', async () => {
+            await erc20Token2.setBalance.awaitTransactionSuccessAsync(takerAddress, signedOrder.takerAssetAmount, {
+                from: owner,
+            });
+            await erc20Token2.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.takerAssetAmount, {
+                from: takerAddress,
+            });
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount, {
+                from: owner,
+            });
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            await feeErc20Token.setBalance.awaitTransactionSuccessAsync(takerAddress, signedOrder.takerFee, {
+                from: owner,
+            });
+            await feeErc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.takerFee, {
+                from: takerAddress,
+            });
+            const orderTransferResults = await devUtils.getSimulatedOrderTransferResults.callAsync(
+                signedOrder,
+                takerAddress,
+                signedOrder.takerAssetAmount,
+            );
+            expect(orderTransferResults).to.equal(OrderTransferResults.MakerFeeAssetDataFailed);
+        });
+        it('should return TransfersSuccessful if all transfers succeed', async () => {
+            await erc20Token2.setBalance.awaitTransactionSuccessAsync(takerAddress, signedOrder.takerAssetAmount, {
+                from: owner,
+            });
+            await erc20Token2.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.takerAssetAmount, {
+                from: takerAddress,
+            });
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount, {
+                from: owner,
+            });
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            await feeErc20Token.setBalance.awaitTransactionSuccessAsync(takerAddress, signedOrder.takerFee, {
+                from: owner,
+            });
+            await feeErc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.takerFee, {
+                from: takerAddress,
+            });
+            await feeErc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerFee, {
+                from: owner,
+            });
+            await feeErc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerFee, {
+                from: makerAddress,
+            });
+            const orderTransferResults = await devUtils.getSimulatedOrderTransferResults.callAsync(
+                signedOrder,
+                takerAddress,
+                signedOrder.takerAssetAmount,
+            );
+            expect(orderTransferResults).to.equal(OrderTransferResults.TransfersSuccessful);
+        });
+    });
+    describe('getSimulatedOrdersTransferResults', async () => {
+        it('should simulate the transfers of each order independently from one another', async () => {
+            // Set balances and allowances to exactly enough to fill a single order
+            await erc20Token2.setBalance.awaitTransactionSuccessAsync(takerAddress, signedOrder.takerAssetAmount, {
+                from: owner,
+            });
+            await erc20Token2.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.takerAssetAmount, {
+                from: takerAddress,
+            });
+            await erc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerAssetAmount, {
+                from: owner,
+            });
+            await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerAssetAmount, {
+                from: makerAddress,
+            });
+            await feeErc20Token.setBalance.awaitTransactionSuccessAsync(takerAddress, signedOrder.takerFee, {
+                from: owner,
+            });
+            await feeErc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.takerFee, {
+                from: takerAddress,
+            });
+            await feeErc20Token.setBalance.awaitTransactionSuccessAsync(makerAddress, signedOrder.makerFee, {
+                from: owner,
+            });
+            await feeErc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, signedOrder.makerFee, {
+                from: makerAddress,
+            });
+            const [
+                orderTransferResults1,
+                orderTransferResults2,
+            ] = await devUtils.getSimulatedOrdersTransferResults.callAsync(
+                [signedOrder, signedOrder],
+                [takerAddress, takerAddress],
+                [signedOrder.takerAssetAmount, signedOrder.takerAssetAmount],
+            );
+            expect(orderTransferResults1).to.equal(OrderTransferResults.TransfersSuccessful);
+            expect(orderTransferResults2).to.equal(OrderTransferResults.TransfersSuccessful);
+        });
+    });
 });
 // tslint:disable:max-file-line-count