Publish

- @0x/contracts-asset-proxy@3.1.3
 - @0x/contracts-broker@1.0.1
 - @0x/contracts-coordinator@3.0.6
 - @0x/contracts-dev-utils@1.0.6
 - @0x/contracts-erc1155@2.0.6
 - @0x/contracts-erc20-bridge-sampler@1.2.1
 - @0x/contracts-erc20@3.0.6
 - @0x/contracts-erc721@3.0.6
 - @0x/contracts-exchange-forwarder@4.1.0
 - @0x/contracts-exchange-libs@4.2.0
 - @0x/contracts-exchange@3.1.2
 - @0x/contracts-extensions@6.0.0
 - @0x/contracts-integrations@2.2.3
 - @0x/contracts-multisig@4.0.6
 - @0x/contracts-staking@2.0.6
 - @0x/contracts-test-utils@5.1.3
 - @0x/contracts-utils@4.2.1
 - 0x.js@9.0.7
 - @0x/abi-gen@5.1.2
 - @0x/assert@3.0.5
 - @0x/asset-swapper@4.1.1
 - @0x/base-contract@6.1.2
 - @0x/connect@6.0.5
 - @0x/contract-artifacts@3.4.1
 - @0x/contract-wrappers-test@12.2.7
 - @0x/contract-wrappers@13.4.2
 - @0x/contracts-gen@2.0.6
 - @0x/dev-utils@3.1.3
 - @0x/instant@1.0.44
 - @0x/json-schemas@5.0.5
 - @0x/migrations@6.0.2
 - @0x/monorepo-scripts@1.0.49
 - @0x/order-utils@10.1.3
 - @0x/orderbook@2.1.2
 - @0x/sol-compiler@4.0.6
 - @0x/sol-coverage@4.0.6
 - @0x/sol-doc@3.1.3
 - @0x/sol-profiler@4.0.6
 - @0x/sol-trace@3.0.6
 - @0x/sol-tracing-utils@7.0.6
 - @0x/sra-spec@3.0.5
 - @0x/subproviders@6.0.6
 - @0x/utils@5.3.0
 - @0x/web3-wrapper@7.0.5

.circleci/config.yml

@@ -23,7 +23,7 @@ jobs:
             #       command: npm set prefix=/home/circleci/npm && echo 'export PATH=$HOME/circleci/npm/bin:$PATH' >> /home/circleci/.bashrc
             - run:
                   name: install-yarn
-                  command: npm install --global yarn@1.17.0
+                  command: npm install --force --global yarn@1.17.0
             - run:
                   name: yarn
                   command: yarn --frozen-lockfile --ignore-engines install || yarn --frozen-lockfile --ignore-engines install
@@ -77,7 +77,7 @@ jobs:
             - restore_cache:
                   keys:
                       - repo-{{ .Environment.CIRCLE_SHA1 }}
-            - run: yarn wsrun test:circleci @0x/contracts-multisig @0x/contracts-utils @0x/contracts-exchange-libs @0x/contracts-erc20 @0x/contracts-erc721 @0x/contracts-erc1155 @0x/contracts-asset-proxy @0x/contracts-exchange-forwarder @0x/contracts-tests @0x/contracts-staking @0x/contracts-coordinator @0x/contracts-erc20-bridge-sampler 
+            - run: yarn wsrun test:circleci @0x/contracts-multisig @0x/contracts-utils @0x/contracts-exchange-libs @0x/contracts-erc20 @0x/contracts-erc721 @0x/contracts-erc1155 @0x/contracts-asset-proxy @0x/contracts-exchange-forwarder @0x/contracts-tests @0x/contracts-staking @0x/contracts-coordinator @0x/contracts-erc20-bridge-sampler
             # TODO(dorothy-zbornak): Re-enable after updating this package for
             # 3.0. At that time, also remove exclusion from monorepo
             # package.json's test script.
@@ -193,20 +193,14 @@ jobs:
         working_directory: ~/repo
         docker:
             - image: nikolaik/python-nodejs:python3.7-nodejs8
-            - image: 0xorg/ganache-cli:4.4.0-beta.1
-              environment:
-                  VERSION: latest
-                  SNAPSHOT_NAME: 0x_ganache_snapshot-v3-beta
+            - image: 0xorg/ganache-cli:6.0.0
             - image: 0xorg/mesh:0xV3
               environment:
                   ETHEREUM_RPC_URL: 'http://localhost:8545'
-                  ETHEREUM_NETWORK_ID: '50'
                   ETHEREUM_CHAIN_ID: '1337'
-                  USE_BOOTSTRAP_LIST: 'true'
-                  VERBOSITY: 3
-                  PRIVATE_KEY_PATH: ''
-                  BLOCK_POLLING_INTERVAL: '5s'
-                  P2P_LISTEN_PORT: '60557'
+                  VERBOSITY: 5
+                  BLOCK_POLLING_INTERVAL: '50ms'
+                  ETHEREUM_RPC_MAX_REQUESTS_PER_24_HR_UTC: '1778000'
               command: |
                   sh -c "waitForGanache () { until printf 'POST /\r\nContent-Length: 26\r\n\r\n{\"method\":\"net_listening\"}' | nc localhost 8545 | grep true; do continue; done }; waitForGanache && ./mesh"
             - image: 0xorg/launch-kit-backend:v3
@@ -219,7 +213,7 @@ jobs:
                   TAKER_FEE_UNIT_AMOUNT: 0
                   MESH_ENDPOINT: 'ws://localhost:60557'
               command: |
-                  sh -c "waitForMesh () { sleep 5; }; waitForMesh && node_modules/.bin/forever ts/lib/index.js"
+                  sh -c "waitForMesh () { sleep 30; }; waitForMesh && node_modules/.bin/forever ts/lib/index.js"
         steps:
             - checkout
             - restore_cache:

.gitignore

@@ -79,6 +79,8 @@ TODO.md
 .vscode
 
 # generated contract artifacts/
+contracts/broker/generated-artifacts/
+contracts/broker/test/generated-artifacts/
 contracts/erc20-bridge-sampler/generated-artifacts/
 contracts/erc20-bridge-sampler/test/generated-artifacts/
 contracts/integrations/generated-artifacts/
@@ -113,6 +115,7 @@ packages/sol-tracing-utils/test/fixtures/artifacts/
 python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/
 
 # generated truffle contract artifacts/
+contracts/broker/build/
 contracts/erc20-bridge-sampler/build/
 contracts/staking/build/
 contracts/coordinator/build/
@@ -129,6 +132,8 @@ contracts/exchange-forwarder/build/
 contracts/dev-utils/build/
 
 # generated contract wrappers
+contracts/broker/generated-wrappers/
+contracts/broker/test/generated-wrappers/
 packages/python-contract-wrappers/generated/
 contracts/erc20-bridge-sampler/generated-wrappers/
 contracts/erc20-bridge-sampler/test/generated-wrappers/
@@ -160,33 +165,7 @@ contracts/exchange-forwarder/generated-wrappers/
 contracts/exchange-forwarder/test/generated-wrappers/
 contracts/dev-utils/generated-wrappers/
 contracts/dev-utils/test/generated-wrappers/
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/dev_utils/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc20_token/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/exchange/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/asset_proxy_owner/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/coordinator/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/coordinator_registry/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/dummy_erc20_token/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/dummy_erc721_token/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/dutch_auction/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc1155_mintable/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc1155_proxy/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc20_bridge_proxy/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc20_proxy/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc721_proxy/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc721_token/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/forwarder/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/i_asset_proxy/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/i_validator/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/i_wallet/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/multi_asset_proxy/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/order_validator/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/staking/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/staking_proxy/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/static_call_proxy/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/weth9/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/zrx_token/__init__.py
-python-packages/contract_wrappers/src/zero_ex/contract_wrappers/zrx_vault/__init__.py
+python-packages/contract_wrappers/src/zero_ex/contract_wrappers/*/__init__.py
 
 # solc-bin in sol-compiler
 packages/sol-compiler/solc_bin/

.prettierignore

@@ -1,5 +1,9 @@
 lib
 .nyc_output
+/contracts/broker/generated-wrappers
+/contracts/broker/test/generated-wrappers
+/contracts/broker/generated-artifacts
+/contracts/broker/test/generated-artifacts
 /contracts/integrations/generated-wrappers
 /contracts/integrations/test/generated-wrappers
 /contracts/integrations/generated-artifacts

CODEOWNERS

@@ -14,8 +14,8 @@ packages/abi-gen/ @feuGeneA
 packages/base-contract/ @xianny
 packages/connect/ @fragosti 
 packages/abi-gen-templates/ @feuGeneA @xianny
-packages/contract-addresses/ @albrow
-packages/contract-artifacts/ @albrow
+packages/contract-addresses/ @abandeali1
+packages/contract-artifacts/ @abandeali1
 packages/dev-utils/ @LogvinovLeon @fabioberger
 packages/devnet/ @albrow
 packages/ethereum-types/ @LogvinovLeon

contracts/asset-proxy/CHANGELOG.json

@@ -1,4 +1,67 @@
 [
+    {
+        "timestamp": 1580988106,
+        "version": "3.1.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1580811564,
+        "version": "3.1.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1579682890,
+        "version": "3.1.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "3.1.0",
+        "changes": [
+            {
+                "note": "Integration tests for DydxBridge with ERC20BridgeProxy.",
+                "pr": 2401
+            },
+            {
+                "note": "Fix `UniswapBridge` token -> token transfer call.",
+                "pr": 2412
+            },
+            {
+                "note": "Fix `KyberBridge` incorrect `minConversionRate` calculation.",
+                "pr": 2412
+            }
+        ],
+        "timestamp": 1578272714
+    },
+    {
+        "timestamp": 1576540892,
+        "version": "3.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1575931811,
+        "version": "3.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "version": "3.0.0",
         "changes": [
@@ -55,6 +118,10 @@
             {
                 "note": "Implement `KyberBridge`.",
                 "pr": 2352
+            },
+            {
+                "note": "Implement `DydxBridge`.",
+                "pr": 2365
             }
         ],
         "timestamp": 1575290197

contracts/asset-proxy/CHANGELOG.md

@@ -5,6 +5,32 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v3.1.3 - _February 6, 2020_
+
+    * Dependencies updated
+
+## v3.1.2 - _February 4, 2020_
+
+    * Dependencies updated
+
+## v3.1.1 - _January 22, 2020_
+
+    * Dependencies updated
+
+## v3.1.0 - _January 6, 2020_
+
+    * Integration tests for DydxBridge with ERC20BridgeProxy. (#2401)
+    * Fix `UniswapBridge` token -> token transfer call. (#2412)
+    * Fix `KyberBridge` incorrect `minConversionRate` calculation. (#2412)
+
+## v3.0.2 - _December 17, 2019_
+
+    * Dependencies updated
+
+## v3.0.1 - _December 9, 2019_
+
+    * Dependencies updated
+
 ## v3.0.0 - _December 2, 2019_
 
     * Implement `KyberBridge`. (#2352)
@@ -22,6 +48,7 @@ CHANGELOG
 ## v2.3.0-beta.4 - _December 2, 2019_
 
     * Implement `KyberBridge`. (#2352)
+    * Implement `DydxBridge`. (#2365)
 
 ## v2.3.0-beta.3 - _November 20, 2019_
 

contracts/asset-proxy/compiler.json

@@ -4,7 +4,7 @@
     "useDockerisedSolc": false,
     "isOfflineMode": false,
     "compilerSettings": {
-        "evmVersion": "constantinople",
+        "evmVersion": "istanbul",
         "optimizer": {
             "enabled": true,
             "runs": 1000000,

contracts/asset-proxy/contracts/src/bridges/ChaiBridge.sol

@@ -0,0 +1,75 @@
+/*
+
+  Copyright 2019 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.9;
+pragma experimental ABIEncoderV2;
+
+import "../interfaces/IERC20Bridge.sol";
+import "../interfaces/IChai.sol";
+import "@0x/contracts-utils/contracts/src/DeploymentConstants.sol";
+import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
+
+
+// solhint-disable space-after-comma
+contract ChaiBridge is
+    IERC20Bridge,
+    DeploymentConstants
+{
+    /// @dev Withdraws `amount` of `from` address's Dai from the Chai contract.
+    ///      Transfers `amount` of Dai to `to` address.
+    /// @param from Address to transfer asset from.
+    /// @param to Address to transfer asset to.
+    /// @param amount Amount of asset to transfer.
+    /// @return success The magic bytes `0x37708e9b` if successful.
+    function bridgeTransferFrom(
+        address /* tokenAddress */,
+        address from,
+        address to,
+        uint256 amount,
+        bytes calldata /* bridgeData */
+    )
+        external
+        returns (bytes4 success)
+    {
+        // Ensure that only the `ERC20BridgeProxy` can call this function.
+        require(
+            msg.sender == _getERC20BridgeProxyAddress(),
+            "ChaiBridge/ONLY_CALLABLE_BY_ERC20_BRIDGE_PROXY"
+        );
+
+        // Withdraw `from` address's Dai.
+        // NOTE: This contract must be approved to spend Chai on behalf of `from`.
+        bytes memory drawCalldata = abi.encodeWithSelector(
+            IChai(address(0)).draw.selector,
+            from,
+            amount
+        );
+
+        (bool success,) = _getChaiAddress().call(drawCalldata);
+        require(
+            success,
+            "ChaiBridge/DRAW_DAI_FAILED"
+        );
+
+        // Transfer Dai to `to`
+        // This will never fail if the `draw` call was successful
+        IERC20Token(_getDaiAddress()).transfer(to, amount);
+
+        return BRIDGE_SUCCESS;
+    }
+}

contracts/asset-proxy/contracts/src/bridges/DydxBridge.sol

@@ -0,0 +1,241 @@
+/*
+
+  Copyright 2019 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.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-utils/contracts/src/DeploymentConstants.sol";
+import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibMath.sol";
+import "../interfaces/IERC20Bridge.sol";
+import "../interfaces/IDydxBridge.sol";
+import "../interfaces/IDydx.sol";
+
+
+contract DydxBridge is
+    IERC20Bridge,
+    IDydxBridge,
+    DeploymentConstants
+{
+
+    using LibSafeMath for uint256;
+
+    /// @dev Callback for `IERC20Bridge`. Deposits or withdraws tokens from a dydx account.
+    ///      Notes:
+    ///         1. This bridge must be set as an operator of the input dydx account.
+    ///         2. This function may only be called in the context of the 0x Exchange.
+    ///         3. The maker or taker of the 0x order must be the dydx account owner.
+    ///         4. Deposits into dydx are made from the `from` address.
+    ///         5. Withdrawals from dydx are made to the `to` address.
+    ///         6. Calling this function must always withdraw at least `amount`,
+    ///            otherwise the `ERC20Bridge` will revert.
+    /// @param from The sender of the tokens and owner of the dydx account.
+    /// @param to The recipient of the tokens.
+    /// @param amount Minimum amount of `toTokenAddress` tokens to deposit or withdraw.
+    /// @param encodedBridgeData An abi-encoded `BridgeData` struct.
+    /// @return success The magic bytes if successful.
+    function bridgeTransferFrom(
+        address,
+        address from,
+        address to,
+        uint256 amount,
+        bytes calldata encodedBridgeData
+    )
+        external
+        returns (bytes4 success)
+    {
+        // Ensure that only the `ERC20BridgeProxy` can call this function.
+        require(
+            msg.sender == _getERC20BridgeProxyAddress(),
+            "DydxBridge/ONLY_CALLABLE_BY_ERC20_BRIDGE_PROXY"
+        );
+
+        // Decode bridge data.
+        (BridgeData memory bridgeData) = abi.decode(encodedBridgeData, (BridgeData));
+
+        // The dydx accounts are owned by the `from` address.
+        IDydx.AccountInfo[] memory accounts = _createAccounts(from, bridgeData);
+
+        // Create dydx actions to run on the dydx accounts.
+        IDydx.ActionArgs[] memory actions = _createActions(
+            from,
+            to,
+            amount,
+            bridgeData
+        );
+
+        // Run operation. This will revert on failure.
+        IDydx(_getDydxAddress()).operate(accounts, actions);
+        return BRIDGE_SUCCESS;
+    }
+
+    /// @dev Creates an array of accounts for dydx to operate on.
+    ///      All accounts must belong to the same owner.
+    /// @param accountOwner Owner of the dydx account.
+    /// @param bridgeData A `BridgeData` struct.
+    function _createAccounts(
+        address accountOwner,
+        BridgeData memory bridgeData
+    )
+        internal
+        returns (IDydx.AccountInfo[] memory accounts)
+    {
+        uint256[] memory accountNumbers = bridgeData.accountNumbers;
+        uint256 nAccounts = accountNumbers.length;
+        accounts = new IDydx.AccountInfo[](nAccounts);
+        for (uint256 i = 0; i < nAccounts; ++i) {
+            accounts[i] = IDydx.AccountInfo({
+                owner: accountOwner,
+                number: accountNumbers[i]
+            });
+        }
+    }
+
+    /// @dev Creates an array of actions to carry out on dydx.
+    /// @param depositFrom Deposit value from this address (owner of the dydx account).
+    /// @param withdrawTo Withdraw value to this address.
+    /// @param amount The amount of value available to operate on.
+    /// @param bridgeData A `BridgeData` struct.
+    function _createActions(
+        address depositFrom,
+        address withdrawTo,
+        uint256 amount,
+        BridgeData memory bridgeData
+    )
+        internal
+        returns (IDydx.ActionArgs[] memory actions)
+    {
+        BridgeAction[] memory bridgeActions = bridgeData.actions;
+        uint256 nBridgeActions = bridgeActions.length;
+        actions = new IDydx.ActionArgs[](nBridgeActions);
+        for (uint256 i = 0; i < nBridgeActions; ++i) {
+            // Cache current bridge action.
+            BridgeAction memory bridgeAction = bridgeActions[i];
+
+            // Scale amount, if conversion rate is set.
+            uint256 scaledAmount;
+            if (bridgeAction.conversionRateDenominator > 0) {
+                scaledAmount = LibMath.safeGetPartialAmountFloor(
+                    bridgeAction.conversionRateNumerator,
+                    bridgeAction.conversionRateDenominator,
+                    amount
+                );
+            } else {
+                scaledAmount = amount;
+            }
+
+            // Construct dydx action.
+            if (bridgeAction.actionType == BridgeActionType.Deposit) {
+                // Deposit tokens from the account owner into their dydx account.
+                actions[i] = _createDepositAction(
+                    depositFrom,
+                    scaledAmount,
+                    bridgeAction
+                );
+            } else if (bridgeAction.actionType == BridgeActionType.Withdraw) {
+                // Withdraw tokens from dydx to the `otherAccount`.
+                actions[i] = _createWithdrawAction(
+                    withdrawTo,
+                    scaledAmount,
+                    bridgeAction
+                );
+            } else {
+                // If all values in the `Action` enum are handled then this
+                // revert is unreachable: Solidity will revert when casting
+                // from `uint8` to `Action`.
+                revert("DydxBridge/UNRECOGNIZED_BRIDGE_ACTION");
+            }
+        }
+    }
+
+    /// @dev Returns a dydx `DepositAction`.
+    /// @param depositFrom Deposit tokens from this address who is also the account owner.
+    /// @param amount of tokens to deposit.
+    /// @param bridgeAction A `BridgeAction` struct.
+    /// @return depositAction The encoded dydx action.
+    function _createDepositAction(
+        address depositFrom,
+        uint256 amount,
+        BridgeAction memory bridgeAction
+    )
+        internal
+        pure
+        returns (
+            IDydx.ActionArgs memory depositAction
+        )
+    {
+        // Create dydx amount.
+        IDydx.AssetAmount memory dydxAmount = IDydx.AssetAmount({
+            sign: true,                                 // true if positive.
+            denomination: IDydx.AssetDenomination.Wei,  // Wei => actual token amount held in account.
+            ref: IDydx.AssetReference.Delta,                // Delta => a relative amount.
+            value: amount                               // amount to deposit.
+        });
+
+        // Create dydx deposit action.
+        depositAction = IDydx.ActionArgs({
+            actionType: IDydx.ActionType.Deposit,           // deposit tokens.
+            amount: dydxAmount,                             // amount to deposit.
+            accountId: bridgeAction.accountId,              // index in the `accounts` when calling `operate`.
+            primaryMarketId: bridgeAction.marketId,         // indicates which token to deposit.
+            otherAddress: depositFrom,                      // deposit from the account owner.
+            // unused parameters
+            secondaryMarketId: 0,
+            otherAccountId: 0,
+            data: hex''
+        });
+    }
+
+    /// @dev Returns a dydx `WithdrawAction`.
+    /// @param withdrawTo Withdraw tokens to this address.
+    /// @param amount of tokens to withdraw.
+    /// @param bridgeAction A `BridgeAction` struct.
+    /// @return withdrawAction The encoded dydx action.
+    function _createWithdrawAction(
+        address withdrawTo,
+        uint256 amount,
+        BridgeAction memory bridgeAction
+    )
+        internal
+        pure
+        returns (
+            IDydx.ActionArgs memory withdrawAction
+        )
+    {
+        // Create dydx amount.
+        IDydx.AssetAmount memory amountToWithdraw = IDydx.AssetAmount({
+            sign: false,                                    // false if negative.
+            denomination: IDydx.AssetDenomination.Wei,      // Wei => actual token amount held in account.
+            ref: IDydx.AssetReference.Delta,                // Delta => a relative amount.
+            value: amount                                   // amount to withdraw.
+        });
+
+        // Create withdraw action.
+        withdrawAction = IDydx.ActionArgs({
+            actionType: IDydx.ActionType.Withdraw,          // withdraw tokens.
+            amount: amountToWithdraw,                       // amount to withdraw.
+            accountId: bridgeAction.accountId,              // index in the `accounts` when calling `operate`.
+            primaryMarketId: bridgeAction.marketId,         // indicates which token to withdraw.
+            otherAddress: withdrawTo,                       // withdraw tokens to this address.
+            // unused parameters
+            secondaryMarketId: 0,
+            otherAccountId: 0,
+            data: hex''
+        });
+    }
+}

contracts/asset-proxy/contracts/src/bridges/Eth2DaiBridge.sol

@@ -55,7 +55,7 @@ contract Eth2DaiBridge is
         // Decode the bridge data to get the `fromTokenAddress`.
         (address fromTokenAddress) = abi.decode(bridgeData, (address));
 
-        IEth2Dai exchange = _getEth2DaiContract();
+        IEth2Dai exchange = IEth2Dai(_getEth2DaiAddress());
         // Grant an allowance to the exchange to spend `fromTokenAddress` token.
         LibERC20Token.approve(fromTokenAddress, address(exchange), uint256(-1));
 
@@ -84,14 +84,4 @@ contract Eth2DaiBridge is
     {
         return LEGACY_WALLET_MAGIC_VALUE;
     }
-
-    /// @dev Overridable way to get the eth2dai contract.
-    /// @return exchange The Eth2Dai exchange contract.
-    function _getEth2DaiContract()
-        internal
-        view
-        returns (IEth2Dai exchange)
-    {
-        return IEth2Dai(_getEth2DaiAddress());
-    }
 }

contracts/asset-proxy/contracts/src/bridges/KyberBridge.sol

@@ -24,6 +24,7 @@ import "@0x/contracts-erc20/contracts/src/interfaces/IEtherToken.sol";
 import "@0x/contracts-erc20/contracts/src/LibERC20Token.sol";
 import "@0x/contracts-exchange-libs/contracts/src/IWallet.sol";
 import "@0x/contracts-utils/contracts/src/DeploymentConstants.sol";
+import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
 import "../interfaces/IERC20Bridge.sol";
 import "../interfaces/IKyberNetworkProxy.sol";
 
@@ -34,6 +35,8 @@ contract KyberBridge is
     IWallet,
     DeploymentConstants
 {
+    using LibSafeMath for uint256;
+
     // @dev Structure used internally to get around stack limits.
     struct TradeState {
         IKyberNetworkProxy kyber;
@@ -41,6 +44,7 @@ contract KyberBridge is
         address fromTokenAddress;
         uint256 fromTokenBalance;
         uint256 payableAmount;
+        uint256 conversionRate;
     }
 
     /// @dev Kyber ETH pseudo-address.
@@ -77,15 +81,27 @@ contract KyberBridge is
         returns (bytes4 success)
     {
         TradeState memory state;
-        state.kyber = _getKyberContract();
-        state.weth = _getWETHContract();
+        state.kyber = IKyberNetworkProxy(_getKyberNetworkProxyAddress());
+        state.weth = IEtherToken(_getWethAddress());
         // Decode the bridge data to get the `fromTokenAddress`.
         (state.fromTokenAddress) = abi.decode(bridgeData, (address));
+        // Query the balance of "from" tokens.
         state.fromTokenBalance = IERC20Token(state.fromTokenAddress).balanceOf(address(this));
         if (state.fromTokenBalance == 0) {
             // Return failure if no input tokens.
             return BRIDGE_FAILED;
         }
+        // Compute the conversion rate, expressed in 18 decimals.
+        // The sequential notation is to get around stack limits.
+        state.conversionRate = KYBER_RATE_BASE;
+        state.conversionRate = state.conversionRate.safeMul(amount);
+        state.conversionRate = state.conversionRate.safeMul(
+            10 ** uint256(LibERC20Token.decimals(state.fromTokenAddress))
+        );
+        state.conversionRate = state.conversionRate.safeDiv(state.fromTokenBalance);
+        state.conversionRate = state.conversionRate.safeDiv(
+            10 ** uint256(LibERC20Token.decimals(toTokenAddress))
+        );
         if (state.fromTokenAddress == toTokenAddress) {
             // Just transfer the tokens if they're the same.
             LibERC20Token.transfer(state.fromTokenAddress, to, state.fromTokenBalance);
@@ -118,7 +134,7 @@ contract KyberBridge is
             uint256(-1),
             // Compute the minimum conversion rate, which is expressed in units with
             // 18 decimal places.
-            (KYBER_RATE_BASE * amount) / state.fromTokenBalance,
+            state.conversionRate,
             // No affiliate address.
             address(0)
         );
@@ -143,24 +159,4 @@ contract KyberBridge is
     {
         return LEGACY_WALLET_MAGIC_VALUE;
     }
-
-    /// @dev Overridable way to get the `KyberNetworkProxy` contract.
-    /// @return kyber The `IKyberNetworkProxy` contract.
-    function _getKyberContract()
-        internal
-        view
-        returns (IKyberNetworkProxy kyber)
-    {
-        return IKyberNetworkProxy(_getKyberNetworkProxyAddress());
-    }
-
-    /// @dev Overridable way to get the WETH contract.
-    /// @return weth The WETH contract.
-    function _getWETHContract()
-        internal
-        view
-        returns (IEtherToken weth)
-    {
-        return IEtherToken(_getWETHAddress());
-    }
 }

contracts/asset-proxy/contracts/src/bridges/UniswapBridge.sol

@@ -88,7 +88,7 @@ contract UniswapBridge is
         // Get our balance of `fromTokenAddress` token.
         state.fromTokenBalance = IERC20Token(fromTokenAddress).balanceOf(address(this));
         // Get the weth contract.
-        state.weth = getWethContract();
+        state.weth = IEtherToken(_getWethAddress());
 
         // Convert from WETH to a token.
         if (fromTokenAddress == address(state.weth)) {
@@ -134,8 +134,8 @@ contract UniswapBridge is
                 state.fromTokenBalance,
                 // Minimum buy amount.
                 amount,
-                // No minimum intermediate ETH buy amount.
-                0,
+                // Must buy at least 1 intermediate ETH.
+                1,
                 // Expires after this block.
                 block.timestamp,
                 // Recipient is `to`.
@@ -161,26 +161,6 @@ contract UniswapBridge is
         return LEGACY_WALLET_MAGIC_VALUE;
     }
 
-    /// @dev Overridable way to get the weth contract.
-    /// @return token The WETH contract.
-    function getWethContract()
-        public
-        view
-        returns (IEtherToken token)
-    {
-        return IEtherToken(_getWETHAddress());
-    }
-
-    /// @dev Overridable way to get the uniswap exchange factory contract.
-    /// @return factory The exchange factory contract.
-    function getUniswapExchangeFactoryContract()
-        public
-        view
-        returns (IUniswapExchangeFactory factory)
-    {
-        return IUniswapExchangeFactory(_getUniswapExchangeFactoryAddress());
-    }
-
     /// @dev Grants an unlimited allowance to the exchange for its token
     ///      on behalf of this contract.
     /// @param exchange The Uniswap token exchange.
@@ -207,11 +187,12 @@ contract UniswapBridge is
     {
         address exchangeTokenAddress = fromTokenAddress;
         // Whichever isn't WETH is the exchange token.
-        if (fromTokenAddress == address(getWethContract())) {
+        if (fromTokenAddress == _getWethAddress()) {
             exchangeTokenAddress = toTokenAddress;
         }
         exchange = IUniswapExchange(
-            getUniswapExchangeFactoryContract().getExchange(exchangeTokenAddress)
+            IUniswapExchangeFactory(_getUniswapExchangeFactoryAddress())
+            .getExchange(exchangeTokenAddress)
         );
         require(address(exchange) != address(0), "NO_UNISWAP_EXCHANGE_FOR_TOKEN");
         return exchange;

contracts/asset-proxy/contracts/src/interfaces/IChai.sol

@@ -0,0 +1,66 @@
+/*
+
+  Copyright 2019 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.9;
+
+import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
+
+
+contract PotLike {
+    function chi() external returns (uint256);
+    function rho() external returns (uint256);
+    function drip() external returns (uint256);
+    function join(uint256) external;
+    function exit(uint256) external;
+}
+
+
+// The actual Chai contract can be found here: https://github.com/dapphub/chai
+contract IChai is
+    IERC20Token
+{
+    /// @dev Withdraws Dai owned by `src`
+    /// @param src Address that owns Dai.
+    /// @param wad Amount of Dai to withdraw.
+    function draw(
+        address src,
+        uint256 wad
+    )
+        external;
+
+    /// @dev Queries Dai balance of Chai holder.
+    /// @param usr Address of Chai holder.
+    /// @return Dai balance.
+    function dai(address usr)
+        external
+        returns (uint256);
+
+    /// @dev Queries the Pot contract used by the Chai contract.
+    function pot()
+        external
+        returns (PotLike);
+
+    /// @dev Deposits Dai in exchange for Chai
+    /// @param dst Address to receive Chai.
+    /// @param wad Amount of Dai to deposit.
+    function join(
+        address dst,
+        uint256 wad
+    )
+        external;
+}

contracts/asset-proxy/contracts/src/interfaces/IDydx.sol

@@ -0,0 +1,89 @@
+/*
+
+  Copyright 2019 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.9;
+pragma experimental ABIEncoderV2;
+
+
+interface IDydx {
+
+    /// @dev Represents the unique key that specifies an account
+    struct AccountInfo {
+        address owner;  // The address that owns the account
+        uint256 number; // A nonce that allows a single address to control many accounts
+    }
+
+    enum ActionType {
+        Deposit,   // supply tokens
+        Withdraw,  // borrow tokens
+        Transfer,  // transfer balance between accounts
+        Buy,       // buy an amount of some token (externally)
+        Sell,      // sell an amount of some token (externally)
+        Trade,     // trade tokens against another account
+        Liquidate, // liquidate an undercollateralized or expiring account
+        Vaporize,  // use excess tokens to zero-out a completely negative account
+        Call       // send arbitrary data to an address
+    }
+
+    /// @dev Arguments that are passed to Solo in an ordered list as part of a single operation.
+    /// Each ActionArgs has an actionType which specifies which action struct that this data will be
+    /// parsed into before being processed.
+    struct ActionArgs {
+        ActionType actionType;
+        uint256 accountId;
+        AssetAmount amount;
+        uint256 primaryMarketId;
+        uint256 secondaryMarketId;
+        address otherAddress;
+        uint256 otherAccountId;
+        bytes data;
+    }
+
+    enum AssetDenomination {
+        Wei, // the amount is denominated in wei
+        Par  // the amount is denominated in par
+    }
+
+    enum AssetReference {
+        Delta, // the amount is given as a delta from the current value
+        Target // the amount is given as an exact number to end up at
+    }
+
+    struct AssetAmount {
+        bool sign; // true if positive
+        AssetDenomination denomination;
+        AssetReference ref;
+        uint256 value;
+    }
+
+    /// @dev The main entry-point to Solo that allows users and contracts to manage accounts.
+    ///      Take one or more actions on one or more accounts. The msg.sender must be the owner or
+    ///      operator of all accounts except for those being liquidated, vaporized, or traded with.
+    ///      One call to operate() is considered a singular "operation". Account collateralization is
+    ///      ensured only after the completion of the entire operation.
+    /// @param  accounts  A list of all accounts that will be used in this operation. Cannot contain
+    ///                   duplicates. In each action, the relevant account will be referred-to by its
+    ///                   index in the list.
+    /// @param  actions   An ordered list of all actions that will be taken in this operation. The
+    ///                   actions will be processed in order.
+    function operate(
+        AccountInfo[] calldata accounts,
+        ActionArgs[] calldata actions
+    )
+        external;
+}

contracts/asset-proxy/contracts/src/interfaces/IDydxBridge.sol

@@ -0,0 +1,42 @@
+/*
+
+  Copyright 2019 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.9;
+
+
+interface IDydxBridge {
+
+    /// @dev This is the subset of `IDydx.ActionType` that are supported by the bridge.
+    enum BridgeActionType {
+        Deposit,                    // Deposit tokens into dydx account.
+        Withdraw                    // Withdraw tokens from dydx account.
+    }
+
+    struct BridgeAction {
+        BridgeActionType actionType;            // Action to run on dydx account.
+        uint256 accountId;                      // Index in `BridgeData.accountNumbers` for this action.
+        uint256 marketId;                       // Market to operate on.
+        uint256 conversionRateNumerator;        // Optional. If set, transfer amount is scaled by (conversionRateNumerator/conversionRateDenominator).
+        uint256 conversionRateDenominator;      // Optional. If set, transfer amount is scaled by (conversionRateNumerator/conversionRateDenominator).
+    }
+
+    struct BridgeData {
+        uint256[] accountNumbers;               // Account number used to identify the owner's specific account.
+        BridgeAction[] actions;                 // Actions to carry out on the owner's accounts.
+    }
+}

contracts/asset-proxy/contracts/test/TestChaiBridge.sol

@@ -0,0 +1,80 @@
+/*
+
+  Copyright 2019 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.9;
+pragma experimental ABIEncoderV2;
+
+import "../src/bridges/ChaiBridge.sol";
+import "@0x/contracts-erc20/contracts/src/ERC20Token.sol";
+
+
+contract TestChaiDai is
+    ERC20Token
+{
+    address private constant ALWAYS_REVERT_ADDRESS = address(1);
+
+    function draw(
+        address from,
+        uint256 amount
+    )
+        external
+    {
+        if (from == ALWAYS_REVERT_ADDRESS) {
+            revert();
+        }
+        balances[msg.sender] += amount;
+    }
+}
+
+
+contract TestChaiBridge is
+    ChaiBridge
+{
+    address public testChaiDai;
+    address private constant ALWAYS_REVERT_ADDRESS = address(1);
+
+    constructor()
+        public
+    {
+        testChaiDai = address(new TestChaiDai());
+    }
+
+    function _getDaiAddress()
+        internal
+        view
+        returns (address)
+    {
+        return testChaiDai;
+    }
+
+    function _getChaiAddress()
+        internal
+        view
+        returns (address)
+    {
+        return testChaiDai;
+    }
+
+    function _getERC20BridgeProxyAddress()
+        internal
+        view
+        returns (address)
+    {
+        return msg.sender == ALWAYS_REVERT_ADDRESS ? address(0) : msg.sender;
+    }
+}

contracts/asset-proxy/contracts/test/TestDydxBridge.sol

@@ -0,0 +1,191 @@
+/*
+
+  Copyright 2019 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.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
+import "../src/bridges/DydxBridge.sol";
+
+
+contract TestDydxBridgeToken {
+
+    uint256 private constant INIT_HOLDER_BALANCE = 10 * 10**18; // 10 tokens
+    mapping (address => uint256) private _balances;
+
+    /// @dev Sets initial balance of token holders.
+    constructor(address[] memory holders)
+        public
+    {
+        for (uint256 i = 0; i != holders.length; ++i) {
+            _balances[holders[i]] = INIT_HOLDER_BALANCE;
+        }
+        _balances[msg.sender] = INIT_HOLDER_BALANCE;
+    }
+
+    /// @dev Basic transferFrom implementation.
+    function transferFrom(address from, address to, uint256 amount)
+        external
+        returns (bool)
+    {
+        if (_balances[from] < amount || _balances[to] + amount < _balances[to]) {
+            return false;
+        }
+        _balances[from] -= amount;
+        _balances[to] += amount;
+        return true;
+    }
+
+    /// @dev Returns balance of `holder`.
+    function balanceOf(address holder)
+        external
+        view
+        returns (uint256)
+    {
+        return _balances[holder];
+    }
+}
+
+
+// solhint-disable space-after-comma
+contract TestDydxBridge is
+    IDydx,
+    DydxBridge
+{
+
+    address private constant ALWAYS_REVERT_ADDRESS = address(1);
+    address private _testTokenAddress;
+    bool private _shouldRevertOnOperate;
+
+    event OperateAccount(
+        address owner,
+        uint256 number
+    );
+
+    event OperateAction(
+        ActionType actionType,
+        uint256 accountId,
+        bool amountSign,
+        AssetDenomination amountDenomination,
+        AssetReference amountRef,
+        uint256 amountValue,
+        uint256 primaryMarketId,
+        uint256 secondaryMarketId,
+        address otherAddress,
+        uint256 otherAccountId,
+        bytes data
+    );
+
+    constructor(address[] memory holders)
+        public
+    {
+        // Deploy a test token. This represents the asset being deposited/withdrawn from dydx.
+        _testTokenAddress = address(new TestDydxBridgeToken(holders));
+    }
+
+    /// @dev Simulates `operate` in dydx contract.
+    ///      Emits events so that arguments can be validated client-side.
+    function operate(
+        AccountInfo[] calldata accounts,
+        ActionArgs[] calldata actions
+    )
+        external
+    {
+        if (_shouldRevertOnOperate) {
+            revert("TestDydxBridge/SHOULD_REVERT_ON_OPERATE");
+        }
+
+        for (uint i = 0; i < accounts.length; ++i) {
+            emit OperateAccount(
+                accounts[i].owner,
+                accounts[i].number
+            );
+        }
+
+        for (uint i = 0; i < actions.length; ++i) {
+            emit OperateAction(
+                actions[i].actionType,
+                actions[i].accountId,
+                actions[i].amount.sign,
+                actions[i].amount.denomination,
+                actions[i].amount.ref,
+                actions[i].amount.value,
+                actions[i].primaryMarketId,
+                actions[i].secondaryMarketId,
+                actions[i].otherAddress,
+                actions[i].otherAccountId,
+                actions[i].data
+            );
+
+            if (actions[i].actionType == IDydx.ActionType.Withdraw) {
+                require(
+                    IERC20Token(_testTokenAddress).transferFrom(
+                        address(this),
+                        actions[i].otherAddress,
+                        actions[i].amount.value
+                    ),
+                    "TestDydxBridge/WITHDRAW_FAILED"
+                );
+            } else if (actions[i].actionType == IDydx.ActionType.Deposit) {
+                require(
+                    IERC20Token(_testTokenAddress).transferFrom(
+                        actions[i].otherAddress,
+                        address(this),
+                        actions[i].amount.value
+                    ),
+                    "TestDydxBridge/DEPOSIT_FAILED"
+                );
+            } else {
+                revert("TestDydxBridge/UNSUPPORTED_ACTION");
+            }
+        }
+    }
+
+    /// @dev If `true` then subsequent calls to `operate` will revert.
+    function setRevertOnOperate(bool shouldRevert)
+        external
+    {
+        _shouldRevertOnOperate = shouldRevert;
+    }
+
+    /// @dev Returns test token.
+    function getTestToken()
+        external
+        returns (address)
+    {
+        return _testTokenAddress;
+    }
+
+    /// @dev overrides `_getDydxAddress()` from `DeploymentConstants` to return this address.
+    function _getDydxAddress()
+        internal
+        view
+        returns (address)
+    {
+        return address(this);
+    }
+
+    /// @dev overrides `_getERC20BridgeProxyAddress()` from `DeploymentConstants` for testing.
+    function _getERC20BridgeProxyAddress()
+        internal
+        view
+        returns (address)
+    {
+        return msg.sender == ALWAYS_REVERT_ADDRESS ? address(0) : msg.sender;
+    }
+}

contracts/asset-proxy/contracts/test/TestEth2DaiBridge.sol

@@ -192,11 +192,11 @@ contract TestEth2DaiBridge is
     }
 
     // @dev This contract will double as the Eth2Dai contract.
-    function _getEth2DaiContract()
+    function _getEth2DaiAddress()
         internal
         view
-        returns (IEth2Dai)
+        returns (address)
     {
-        return IEth2Dai(address(this));
+        return address(this);
     }
 }

contracts/asset-proxy/contracts/test/TestKyberBridge.sol

@@ -67,9 +67,11 @@ interface ITestContract {
 /// @dev A minimalist ERC20/WETH token.
 contract TestToken {
 
+    uint8 public decimals;
     ITestContract private _testContract;
 
-    constructor() public {
+    constructor(uint8 decimals_) public {
+        decimals = decimals_;
         _testContract = ITestContract(msg.sender);
     }
 
@@ -165,7 +167,7 @@ contract TestKyberBridge is
     uint256 private _nextFillAmount;
 
     constructor() public {
-        weth = IEtherToken(address(new TestToken()));
+        weth = IEtherToken(address(new TestToken(18)));
     }
 
     /// @dev Implementation of `IKyberNetworkProxy.trade()`
@@ -195,11 +197,11 @@ contract TestKyberBridge is
         return _nextFillAmount;
     }
 
-    function createToken()
+    function createToken(uint8 decimals)
         external
         returns (address tokenAddress)
     {
-        return address(new TestToken());
+        return address(new TestToken(decimals));
     }
 
     function setNextFillAmount(uint256 amount)
@@ -303,20 +305,20 @@ contract TestKyberBridge is
     }
 
     // @dev overridden to point to this contract.
-    function _getKyberContract()
+    function _getKyberNetworkProxyAddress()
         internal
         view
-        returns (IKyberNetworkProxy kyber)
+        returns (address)
     {
-        return IKyberNetworkProxy(address(this));
+        return address(this);
     }
 
     // @dev overridden to point to test WETH.
-    function _getWETHContract()
+    function _getWethAddress()
         internal
         view
-        returns (IEtherToken weth_)
+        returns (address)
     {
-        return weth;
+        return address(weth);
     }
 }

contracts/asset-proxy/contracts/test/TestUniswapBridge.sol

@@ -413,20 +413,20 @@ contract TestUniswapBridge is
     }
 
     // @dev Use `wethToken`.
-    function getWethContract()
-        public
+    function _getWethAddress()
+        internal
         view
-        returns (IEtherToken)
+        returns (address)
     {
-        return IEtherToken(address(wethToken));
+        return address(wethToken);
     }
 
     // @dev This contract will double as the Uniswap contract.
-    function getUniswapExchangeFactoryContract()
-        public
+    function _getUniswapExchangeFactoryAddress()
+        internal
         view
-        returns (IUniswapExchangeFactory)
+        returns (address)
     {
-        return IUniswapExchangeFactory(address(this));
+        return address(this);
     }
 }

contracts/asset-proxy/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-asset-proxy",
-    "version": "3.0.0",
+    "version": "3.1.3",
     "engines": {
         "node": ">=6.12"
     },
@@ -38,8 +38,7 @@
         "docs:json": "typedoc --excludePrivate --excludeExternals --excludeProtected --ignoreCompilerErrors --target ES5 --tsconfig typedoc-tsconfig.json --json $JSON_FILE_PATH $PROJECT_FILES"
     },
     "config": {
-        "publicInterfaceContracts": "ERC1155Proxy,ERC20Proxy,ERC721Proxy,MultiAssetProxy,StaticCallProxy,ERC20BridgeProxy,Eth2DaiBridge,IAssetData,IAssetProxy,UniswapBridge,KyberBridge,TestStaticCallTarget",
-        "abis": "./test/generated-artifacts/@(ERC1155Proxy|ERC20BridgeProxy|ERC20Proxy|ERC721Proxy|Eth2DaiBridge|IAssetData|IAssetProxy|IAssetProxyDispatcher|IAuthorizable|IERC20Bridge|IEth2Dai|IKyberNetworkProxy|IUniswapExchange|IUniswapExchangeFactory|KyberBridge|MixinAssetProxyDispatcher|MixinAuthorizable|MultiAssetProxy|Ownable|StaticCallProxy|TestERC20Bridge|TestEth2DaiBridge|TestKyberBridge|TestStaticCallTarget|TestUniswapBridge|UniswapBridge).json",
+        "abis": "./test/generated-artifacts/@(ChaiBridge|DydxBridge|ERC1155Proxy|ERC20BridgeProxy|ERC20Proxy|ERC721Proxy|Eth2DaiBridge|IAssetData|IAssetProxy|IAssetProxyDispatcher|IAuthorizable|IChai|IDydx|IDydxBridge|IERC20Bridge|IEth2Dai|IKyberNetworkProxy|IUniswapExchange|IUniswapExchangeFactory|KyberBridge|MixinAssetProxyDispatcher|MixinAuthorizable|MultiAssetProxy|Ownable|StaticCallProxy|TestChaiBridge|TestDydxBridge|TestERC20Bridge|TestEth2DaiBridge|TestKyberBridge|TestStaticCallTarget|TestUniswapBridge|UniswapBridge).json",
         "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually."
     },
     "repository": {
@@ -52,15 +51,15 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/protocol/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^5.0.0",
-        "@0x/contracts-gen": "^2.0.0",
-        "@0x/contracts-test-utils": "^4.0.0",
-        "@0x/contracts-utils": "^4.0.0",
-        "@0x/dev-utils": "^3.0.0",
-        "@0x/sol-compiler": "^4.0.0",
+        "@0x/abi-gen": "^5.1.2",
+        "@0x/contracts-gen": "^2.0.6",
+        "@0x/contracts-test-utils": "^5.1.3",
+        "@0x/contracts-utils": "^4.2.1",
+        "@0x/dev-utils": "^3.1.3",
+        "@0x/sol-compiler": "^4.0.6",
         "@0x/ts-doc-gen": "^0.0.22",
         "@0x/tslint-config": "^4.0.0",
-        "@0x/types": "^3.0.0",
+        "@0x/types": "^3.1.1",
         "@types/lodash": "4.14.104",
         "@types/mocha": "^5.2.7",
         "@types/node": "*",
@@ -80,15 +79,16 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^6.0.0",
-        "@0x/contracts-dev-utils": "^1.0.0",
-        "@0x/contracts-erc1155": "^2.0.0",
-        "@0x/contracts-erc20": "^3.0.0",
-        "@0x/contracts-erc721": "^3.0.0",
-        "@0x/order-utils": "^9.0.0",
-        "@0x/typescript-typings": "^5.0.0",
-        "@0x/utils": "^5.0.0",
-        "@0x/web3-wrapper": "^7.0.0",
+        "@0x/base-contract": "^6.1.2",
+        "@0x/contracts-dev-utils": "^1.0.6",
+        "@0x/contracts-erc1155": "^2.0.6",
+        "@0x/contracts-erc20": "^3.0.6",
+        "@0x/contracts-erc721": "^3.0.6",
+        "@0x/contracts-exchange-libs": "^4.2.0",
+        "@0x/order-utils": "^10.1.3",
+        "@0x/typescript-typings": "^5.0.1",
+        "@0x/utils": "^5.3.0",
+        "@0x/web3-wrapper": "^7.0.5",
         "ethereum-types": "^3.0.0",
         "lodash": "^4.17.11"
     },

contracts/asset-proxy/src/artifacts.ts

@@ -5,6 +5,8 @@
  */
 import { ContractArtifact } from 'ethereum-types';
 
+import * as ChaiBridge from '../generated-artifacts/ChaiBridge.json';
+import * as DydxBridge from '../generated-artifacts/DydxBridge.json';
 import * as ERC1155Proxy from '../generated-artifacts/ERC1155Proxy.json';
 import * as ERC20BridgeProxy from '../generated-artifacts/ERC20BridgeProxy.json';
 import * as ERC20Proxy from '../generated-artifacts/ERC20Proxy.json';
@@ -12,22 +14,62 @@ import * as ERC721Proxy from '../generated-artifacts/ERC721Proxy.json';
 import * as Eth2DaiBridge from '../generated-artifacts/Eth2DaiBridge.json';
 import * as IAssetData from '../generated-artifacts/IAssetData.json';
 import * as IAssetProxy from '../generated-artifacts/IAssetProxy.json';
+import * as IAssetProxyDispatcher from '../generated-artifacts/IAssetProxyDispatcher.json';
+import * as IAuthorizable from '../generated-artifacts/IAuthorizable.json';
+import * as IChai from '../generated-artifacts/IChai.json';
+import * as IDydx from '../generated-artifacts/IDydx.json';
+import * as IDydxBridge from '../generated-artifacts/IDydxBridge.json';
+import * as IERC20Bridge from '../generated-artifacts/IERC20Bridge.json';
+import * as IEth2Dai from '../generated-artifacts/IEth2Dai.json';
+import * as IKyberNetworkProxy from '../generated-artifacts/IKyberNetworkProxy.json';
+import * as IUniswapExchange from '../generated-artifacts/IUniswapExchange.json';
+import * as IUniswapExchangeFactory from '../generated-artifacts/IUniswapExchangeFactory.json';
 import * as KyberBridge from '../generated-artifacts/KyberBridge.json';
+import * as MixinAssetProxyDispatcher from '../generated-artifacts/MixinAssetProxyDispatcher.json';
+import * as MixinAuthorizable from '../generated-artifacts/MixinAuthorizable.json';
 import * as MultiAssetProxy from '../generated-artifacts/MultiAssetProxy.json';
+import * as Ownable from '../generated-artifacts/Ownable.json';
 import * as StaticCallProxy from '../generated-artifacts/StaticCallProxy.json';
+import * as TestChaiBridge from '../generated-artifacts/TestChaiBridge.json';
+import * as TestDydxBridge from '../generated-artifacts/TestDydxBridge.json';
+import * as TestERC20Bridge from '../generated-artifacts/TestERC20Bridge.json';
+import * as TestEth2DaiBridge from '../generated-artifacts/TestEth2DaiBridge.json';
+import * as TestKyberBridge from '../generated-artifacts/TestKyberBridge.json';
 import * as TestStaticCallTarget from '../generated-artifacts/TestStaticCallTarget.json';
+import * as TestUniswapBridge from '../generated-artifacts/TestUniswapBridge.json';
 import * as UniswapBridge from '../generated-artifacts/UniswapBridge.json';
 export const artifacts = {
+    MixinAssetProxyDispatcher: MixinAssetProxyDispatcher as ContractArtifact,
+    MixinAuthorizable: MixinAuthorizable as ContractArtifact,
+    Ownable: Ownable as ContractArtifact,
     ERC1155Proxy: ERC1155Proxy as ContractArtifact,
+    ERC20BridgeProxy: ERC20BridgeProxy as ContractArtifact,
     ERC20Proxy: ERC20Proxy as ContractArtifact,
     ERC721Proxy: ERC721Proxy as ContractArtifact,
     MultiAssetProxy: MultiAssetProxy as ContractArtifact,
     StaticCallProxy: StaticCallProxy as ContractArtifact,
-    ERC20BridgeProxy: ERC20BridgeProxy as ContractArtifact,
+    ChaiBridge: ChaiBridge as ContractArtifact,
+    DydxBridge: DydxBridge as ContractArtifact,
     Eth2DaiBridge: Eth2DaiBridge as ContractArtifact,
+    KyberBridge: KyberBridge as ContractArtifact,
+    UniswapBridge: UniswapBridge as ContractArtifact,
     IAssetData: IAssetData as ContractArtifact,
     IAssetProxy: IAssetProxy as ContractArtifact,
-    UniswapBridge: UniswapBridge as ContractArtifact,
-    KyberBridge: KyberBridge as ContractArtifact,
+    IAssetProxyDispatcher: IAssetProxyDispatcher as ContractArtifact,
+    IAuthorizable: IAuthorizable as ContractArtifact,
+    IChai: IChai as ContractArtifact,
+    IDydx: IDydx as ContractArtifact,
+    IDydxBridge: IDydxBridge as ContractArtifact,
+    IERC20Bridge: IERC20Bridge as ContractArtifact,
+    IEth2Dai: IEth2Dai as ContractArtifact,
+    IKyberNetworkProxy: IKyberNetworkProxy as ContractArtifact,
+    IUniswapExchange: IUniswapExchange as ContractArtifact,
+    IUniswapExchangeFactory: IUniswapExchangeFactory as ContractArtifact,
+    TestChaiBridge: TestChaiBridge as ContractArtifact,
+    TestDydxBridge: TestDydxBridge as ContractArtifact,
+    TestERC20Bridge: TestERC20Bridge as ContractArtifact,
+    TestEth2DaiBridge: TestEth2DaiBridge as ContractArtifact,
+    TestKyberBridge: TestKyberBridge as ContractArtifact,
     TestStaticCallTarget: TestStaticCallTarget as ContractArtifact,
+    TestUniswapBridge: TestUniswapBridge as ContractArtifact,
 };

contracts/asset-proxy/src/dydx_bridge_encoder.ts

@@ -0,0 +1,40 @@
+import { AbiEncoder, BigNumber } from '@0x/utils';
+
+export enum DydxBridgeActionType {
+    Deposit,
+    Withdraw,
+}
+
+export interface DydxBrigeAction {
+    actionType: DydxBridgeActionType;
+    accountId: BigNumber;
+    marketId: BigNumber;
+    conversionRateNumerator: BigNumber;
+    conversionRateDenominator: BigNumber;
+}
+
+export interface DydxBridgeData {
+    accountNumbers: BigNumber[];
+    actions: DydxBrigeAction[];
+}
+
+export const dydxBridgeDataEncoder = AbiEncoder.create([
+    {
+        name: 'bridgeData',
+        type: 'tuple',
+        components: [
+            { name: 'accountNumbers', type: 'uint256[]' },
+            {
+                name: 'actions',
+                type: 'tuple[]',
+                components: [
+                    { name: 'actionType', type: 'uint8' },
+                    { name: 'accountId', type: 'uint256' },
+                    { name: 'marketId', type: 'uint256' },
+                    { name: 'conversionRateNumerator', type: 'uint256' },
+                    { name: 'conversionRateDenominator', type: 'uint256' },
+                ],
+            },
+        ],
+    },
+]);

contracts/asset-proxy/src/erc1155_proxy_wrapper.ts

@@ -60,7 +60,7 @@ export class ERC1155ProxyWrapper {
                 txDefaults,
                 artifacts,
             );
-            const erc1155Wrapper = new Erc1155Wrapper(erc1155Contract, this._provider, this._contractOwnerAddress);
+            const erc1155Wrapper = new Erc1155Wrapper(erc1155Contract, this._contractOwnerAddress);
             this._dummyTokenWrappers.push(erc1155Wrapper);
         }
         return this._dummyTokenWrappers;

contracts/asset-proxy/src/index.ts

@@ -5,12 +5,17 @@ export {
     ERC20ProxyContract,
     ERC721ProxyContract,
     Eth2DaiBridgeContract,
+    DydxBridgeContract,
+    TestDydxBridgeContract,
     IAssetDataContract,
     IAssetProxyContract,
     MultiAssetProxyContract,
     StaticCallProxyContract,
     TestStaticCallTargetContract,
     UniswapBridgeContract,
+    KyberBridgeContract,
+    ChaiBridgeContract,
+    IChaiContract,
 } from './wrappers';
 
 export { ERC20Wrapper } from './erc20_wrapper';
@@ -62,3 +67,4 @@ export {
     TupleDataItem,
     StateMutability,
 } from 'ethereum-types';
+export * from './dydx_bridge_encoder';

contracts/asset-proxy/src/wrappers.ts

@@ -3,6 +3,8 @@
  * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
  * -----------------------------------------------------------------------------
  */
+export * from '../generated-wrappers/chai_bridge';
+export * from '../generated-wrappers/dydx_bridge';
 export * from '../generated-wrappers/erc1155_proxy';
 export * from '../generated-wrappers/erc20_bridge_proxy';
 export * from '../generated-wrappers/erc20_proxy';
@@ -10,8 +12,27 @@ export * from '../generated-wrappers/erc721_proxy';
 export * from '../generated-wrappers/eth2_dai_bridge';
 export * from '../generated-wrappers/i_asset_data';
 export * from '../generated-wrappers/i_asset_proxy';
+export * from '../generated-wrappers/i_asset_proxy_dispatcher';
+export * from '../generated-wrappers/i_authorizable';
+export * from '../generated-wrappers/i_chai';
+export * from '../generated-wrappers/i_dydx';
+export * from '../generated-wrappers/i_dydx_bridge';
+export * from '../generated-wrappers/i_erc20_bridge';
+export * from '../generated-wrappers/i_eth2_dai';
+export * from '../generated-wrappers/i_kyber_network_proxy';
+export * from '../generated-wrappers/i_uniswap_exchange';
+export * from '../generated-wrappers/i_uniswap_exchange_factory';
 export * from '../generated-wrappers/kyber_bridge';
+export * from '../generated-wrappers/mixin_asset_proxy_dispatcher';
+export * from '../generated-wrappers/mixin_authorizable';
 export * from '../generated-wrappers/multi_asset_proxy';
+export * from '../generated-wrappers/ownable';
 export * from '../generated-wrappers/static_call_proxy';
+export * from '../generated-wrappers/test_chai_bridge';
+export * from '../generated-wrappers/test_dydx_bridge';
+export * from '../generated-wrappers/test_erc20_bridge';
+export * from '../generated-wrappers/test_eth2_dai_bridge';
+export * from '../generated-wrappers/test_kyber_bridge';
 export * from '../generated-wrappers/test_static_call_target';
+export * from '../generated-wrappers/test_uniswap_bridge';
 export * from '../generated-wrappers/uniswap_bridge';

contracts/asset-proxy/test/artifacts.ts

@@ -5,6 +5,8 @@
  */
 import { ContractArtifact } from 'ethereum-types';
 
+import * as ChaiBridge from '../test/generated-artifacts/ChaiBridge.json';
+import * as DydxBridge from '../test/generated-artifacts/DydxBridge.json';
 import * as ERC1155Proxy from '../test/generated-artifacts/ERC1155Proxy.json';
 import * as ERC20BridgeProxy from '../test/generated-artifacts/ERC20BridgeProxy.json';
 import * as ERC20Proxy from '../test/generated-artifacts/ERC20Proxy.json';
@@ -14,6 +16,9 @@ import * as IAssetData from '../test/generated-artifacts/IAssetData.json';
 import * as IAssetProxy from '../test/generated-artifacts/IAssetProxy.json';
 import * as IAssetProxyDispatcher from '../test/generated-artifacts/IAssetProxyDispatcher.json';
 import * as IAuthorizable from '../test/generated-artifacts/IAuthorizable.json';
+import * as IChai from '../test/generated-artifacts/IChai.json';
+import * as IDydx from '../test/generated-artifacts/IDydx.json';
+import * as IDydxBridge from '../test/generated-artifacts/IDydxBridge.json';
 import * as IERC20Bridge from '../test/generated-artifacts/IERC20Bridge.json';
 import * as IEth2Dai from '../test/generated-artifacts/IEth2Dai.json';
 import * as IKyberNetworkProxy from '../test/generated-artifacts/IKyberNetworkProxy.json';
@@ -25,6 +30,8 @@ import * as MixinAuthorizable from '../test/generated-artifacts/MixinAuthorizabl
 import * as MultiAssetProxy from '../test/generated-artifacts/MultiAssetProxy.json';
 import * as Ownable from '../test/generated-artifacts/Ownable.json';
 import * as StaticCallProxy from '../test/generated-artifacts/StaticCallProxy.json';
+import * as TestChaiBridge from '../test/generated-artifacts/TestChaiBridge.json';
+import * as TestDydxBridge from '../test/generated-artifacts/TestDydxBridge.json';
 import * as TestERC20Bridge from '../test/generated-artifacts/TestERC20Bridge.json';
 import * as TestEth2DaiBridge from '../test/generated-artifacts/TestEth2DaiBridge.json';
 import * as TestKyberBridge from '../test/generated-artifacts/TestKyberBridge.json';
@@ -41,6 +48,8 @@ export const artifacts = {
     ERC721Proxy: ERC721Proxy as ContractArtifact,
     MultiAssetProxy: MultiAssetProxy as ContractArtifact,
     StaticCallProxy: StaticCallProxy as ContractArtifact,
+    ChaiBridge: ChaiBridge as ContractArtifact,
+    DydxBridge: DydxBridge as ContractArtifact,
     Eth2DaiBridge: Eth2DaiBridge as ContractArtifact,
     KyberBridge: KyberBridge as ContractArtifact,
     UniswapBridge: UniswapBridge as ContractArtifact,
@@ -48,11 +57,16 @@ export const artifacts = {
     IAssetProxy: IAssetProxy as ContractArtifact,
     IAssetProxyDispatcher: IAssetProxyDispatcher as ContractArtifact,
     IAuthorizable: IAuthorizable as ContractArtifact,
+    IChai: IChai as ContractArtifact,
+    IDydx: IDydx as ContractArtifact,
+    IDydxBridge: IDydxBridge as ContractArtifact,
     IERC20Bridge: IERC20Bridge as ContractArtifact,
     IEth2Dai: IEth2Dai as ContractArtifact,
     IKyberNetworkProxy: IKyberNetworkProxy as ContractArtifact,
     IUniswapExchange: IUniswapExchange as ContractArtifact,
     IUniswapExchangeFactory: IUniswapExchangeFactory as ContractArtifact,
+    TestChaiBridge: TestChaiBridge as ContractArtifact,
+    TestDydxBridge: TestDydxBridge as ContractArtifact,
     TestERC20Bridge: TestERC20Bridge as ContractArtifact,
     TestEth2DaiBridge: TestEth2DaiBridge as ContractArtifact,
     TestKyberBridge: TestKyberBridge as ContractArtifact,

contracts/asset-proxy/test/chai_bridge.ts

@@ -0,0 +1,60 @@
+import { ERC20TokenContract } from '@0x/contracts-erc20';
+import { blockchainTests, constants, expect, randomAddress } from '@0x/contracts-test-utils';
+import { AssetProxyId, RevertReason } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+
+import { artifacts } from './artifacts';
+import { TestChaiBridgeContract } from './wrappers';
+
+blockchainTests.resets('ChaiBridge unit tests', env => {
+    let chaiBridgeContract: TestChaiBridgeContract;
+    let testDaiContract: ERC20TokenContract;
+    let fromAddress: string;
+    let toAddress: string;
+
+    const alwaysRevertAddress = '0x0000000000000000000000000000000000000001';
+    const amount = new BigNumber(1);
+
+    before(async () => {
+        [fromAddress, toAddress] = await env.getAccountAddressesAsync();
+        chaiBridgeContract = await TestChaiBridgeContract.deployFrom0xArtifactAsync(
+            artifacts.TestChaiBridge,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+        );
+        const testChaiDaiAddress = await chaiBridgeContract.testChaiDai().callAsync();
+        testDaiContract = new ERC20TokenContract(testChaiDaiAddress, env.provider, env.txDefaults);
+    });
+
+    describe('bridgeTransferFrom()', () => {
+        it('fails if not called by ERC20BridgeProxy', async () => {
+            return expect(
+                chaiBridgeContract
+                    .bridgeTransferFrom(randomAddress(), fromAddress, toAddress, amount, constants.NULL_BYTES)
+                    .awaitTransactionSuccessAsync({ from: alwaysRevertAddress }),
+            ).to.revertWith(RevertReason.ChaiBridgeOnlyCallableByErc20BridgeProxy);
+        });
+        it('returns magic bytes upon success', async () => {
+            const magicBytes = await chaiBridgeContract
+                .bridgeTransferFrom(randomAddress(), fromAddress, toAddress, amount, constants.NULL_BYTES)
+                .callAsync();
+            expect(magicBytes).to.eq(AssetProxyId.ERC20Bridge);
+        });
+        it('should increase the Dai balance of `toAddress` by `amount` if successful', async () => {
+            const initialBalance = await testDaiContract.balanceOf(toAddress).callAsync();
+            await chaiBridgeContract
+                .bridgeTransferFrom(randomAddress(), fromAddress, toAddress, amount, constants.NULL_BYTES)
+                .awaitTransactionSuccessAsync();
+            const endBalance = await testDaiContract.balanceOf(toAddress).callAsync();
+            expect(endBalance).to.bignumber.eq(initialBalance.plus(amount));
+        });
+        it('fails if the `chai.draw` call fails', async () => {
+            return expect(
+                chaiBridgeContract
+                    .bridgeTransferFrom(randomAddress(), alwaysRevertAddress, toAddress, amount, constants.NULL_BYTES)
+                    .awaitTransactionSuccessAsync(),
+            ).to.revertWith(RevertReason.ChaiBridgeDrawDaiFailed);
+        });
+    });
+});

contracts/asset-proxy/test/dydx_bridge.ts

@@ -0,0 +1,399 @@
+import { LibMathRevertErrors } from '@0x/contracts-exchange-libs';
+import { blockchainTests, constants, expect, verifyEventsFromLogs } from '@0x/contracts-test-utils';
+import { AssetProxyId, RevertReason } from '@0x/types';
+import { BigNumber } from '@0x/utils';
+import * as _ from 'lodash';
+
+import { DydxBridgeActionType, DydxBridgeData, dydxBridgeDataEncoder } from '../src/dydx_bridge_encoder';
+import { ERC20BridgeProxyContract, IAssetDataContract } from '../src/wrappers';
+
+import { artifacts } from './artifacts';
+import { TestDydxBridgeContract, TestDydxBridgeEvents } from './wrappers';
+
+blockchainTests.resets('DydxBridge unit tests', env => {
+    const defaultAccountNumber = new BigNumber(1);
+    const marketId = new BigNumber(2);
+    const defaultAmount = new BigNumber(4);
+    const notAuthorized = '0x0000000000000000000000000000000000000001';
+    const defaultDepositAction = {
+        actionType: DydxBridgeActionType.Deposit,
+        accountId: constants.ZERO_AMOUNT,
+        marketId,
+        conversionRateNumerator: constants.ZERO_AMOUNT,
+        conversionRateDenominator: constants.ZERO_AMOUNT,
+    };
+    const defaultWithdrawAction = {
+        actionType: DydxBridgeActionType.Withdraw,
+        accountId: constants.ZERO_AMOUNT,
+        marketId,
+        conversionRateNumerator: constants.ZERO_AMOUNT,
+        conversionRateDenominator: constants.ZERO_AMOUNT,
+    };
+    let testContract: TestDydxBridgeContract;
+    let testProxyContract: ERC20BridgeProxyContract;
+    let assetDataEncoder: IAssetDataContract;
+    let owner: string;
+    let authorized: string;
+    let accountOwner: string;
+    let receiver: string;
+
+    before(async () => {
+        // Get accounts
+        const accounts = await env.web3Wrapper.getAvailableAddressesAsync();
+        [owner, authorized, accountOwner, receiver] = accounts;
+
+        // Deploy dydx bridge
+        testContract = await TestDydxBridgeContract.deployFrom0xArtifactAsync(
+            artifacts.TestDydxBridge,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+            [accountOwner, receiver],
+        );
+
+        // Deploy test erc20 bridge proxy
+        testProxyContract = await ERC20BridgeProxyContract.deployFrom0xArtifactAsync(
+            artifacts.ERC20BridgeProxy,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+        );
+        await testProxyContract.addAuthorizedAddress(authorized).awaitTransactionSuccessAsync({ from: owner });
+
+        // Setup asset data encoder
+        assetDataEncoder = new IAssetDataContract(constants.NULL_ADDRESS, env.provider);
+    });
+
+    describe('bridgeTransferFrom()', () => {
+        const callBridgeTransferFrom = async (
+            from: string,
+            to: string,
+            amount: BigNumber,
+            bridgeData: DydxBridgeData,
+            sender: string,
+        ): Promise<string> => {
+            const returnValue = await testContract
+                .bridgeTransferFrom(
+                    constants.NULL_ADDRESS,
+                    from,
+                    to,
+                    amount,
+                    dydxBridgeDataEncoder.encode({ bridgeData }),
+                )
+                .callAsync({ from: sender });
+            return returnValue;
+        };
+        const executeBridgeTransferFromAndVerifyEvents = async (
+            from: string,
+            to: string,
+            amount: BigNumber,
+            bridgeData: DydxBridgeData,
+            sender: string,
+        ): Promise<void> => {
+            // Execute transaction.
+            const txReceipt = await testContract
+                .bridgeTransferFrom(
+                    constants.NULL_ADDRESS,
+                    from,
+                    to,
+                    amount,
+                    dydxBridgeDataEncoder.encode({ bridgeData }),
+                )
+                .awaitTransactionSuccessAsync({ from: sender });
+
+            // Verify `OperateAccount` event.
+            const expectedOperateAccountEvents = [];
+            for (const accountNumber of bridgeData.accountNumbers) {
+                expectedOperateAccountEvents.push({
+                    owner: accountOwner,
+                    number: accountNumber,
+                });
+            }
+            verifyEventsFromLogs(txReceipt.logs, expectedOperateAccountEvents, TestDydxBridgeEvents.OperateAccount);
+
+            // Verify `OperateAction` event.
+            const weiDenomination = 0;
+            const deltaAmountRef = 0;
+            const expectedOperateActionEvents = [];
+            for (const action of bridgeData.actions) {
+                expectedOperateActionEvents.push({
+                    actionType: action.actionType as number,
+                    accountId: action.accountId,
+                    amountSign: action.actionType === DydxBridgeActionType.Deposit ? true : false,
+                    amountDenomination: weiDenomination,
+                    amountRef: deltaAmountRef,
+                    amountValue: action.conversionRateDenominator.gt(0)
+                        ? amount
+                              .times(action.conversionRateNumerator)
+                              .dividedToIntegerBy(action.conversionRateDenominator)
+                        : amount,
+                    primaryMarketId: marketId,
+                    secondaryMarketId: constants.ZERO_AMOUNT,
+                    otherAddress: action.actionType === DydxBridgeActionType.Deposit ? from : to,
+                    otherAccountId: constants.ZERO_AMOUNT,
+                    data: '0x',
+                });
+            }
+            verifyEventsFromLogs(txReceipt.logs, expectedOperateActionEvents, TestDydxBridgeEvents.OperateAction);
+        };
+        it('succeeds when calling with zero amount', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultDepositAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                constants.ZERO_AMOUNT,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling with no accounts', async () => {
+            const bridgeData = {
+                accountNumbers: [],
+                actions: [defaultDepositAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling with no actions', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling `operate` with the `deposit` action and a single account', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultDepositAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling `operate` with the `deposit` action and multiple accounts', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber, defaultAccountNumber.plus(1)],
+                actions: [defaultDepositAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling `operate` with the `withdraw` action and a single account', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultWithdrawAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling `operate` with the `withdraw` action and multiple accounts', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber, defaultAccountNumber.plus(1)],
+                actions: [defaultWithdrawAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling `operate` with the `deposit` action and multiple accounts', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber, defaultAccountNumber.plus(1)],
+                actions: [defaultWithdrawAction, defaultDepositAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when calling `operate` with multiple actions under a single account', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultWithdrawAction, defaultDepositAction],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when scaling the `amount` to deposit', async () => {
+            const conversionRateNumerator = new BigNumber(1);
+            const conversionRateDenominator = new BigNumber(2);
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [
+                    defaultWithdrawAction,
+                    {
+                        ...defaultDepositAction,
+                        conversionRateNumerator,
+                        conversionRateDenominator,
+                    },
+                ],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('succeeds when scaling the `amount` to withdraw', async () => {
+            const conversionRateNumerator = new BigNumber(1);
+            const conversionRateDenominator = new BigNumber(2);
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [
+                    defaultDepositAction,
+                    {
+                        ...defaultWithdrawAction,
+                        conversionRateNumerator,
+                        conversionRateDenominator,
+                    },
+                ],
+            };
+            await executeBridgeTransferFromAndVerifyEvents(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+        });
+        it('reverts if not called by the ERC20 Bridge Proxy', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultDepositAction],
+            };
+            const callBridgeTransferFromPromise = callBridgeTransferFrom(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                notAuthorized,
+            );
+            const expectedError = RevertReason.DydxBridgeOnlyCallableByErc20BridgeProxy;
+            return expect(callBridgeTransferFromPromise).to.revertWith(expectedError);
+        });
+        it('should return magic bytes if call succeeds', async () => {
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultDepositAction],
+            };
+            const returnValue = await callBridgeTransferFrom(
+                accountOwner,
+                receiver,
+                defaultAmount,
+                bridgeData,
+                authorized,
+            );
+            expect(returnValue).to.equal(AssetProxyId.ERC20Bridge);
+        });
+        it('should revert when `Operate` reverts', async () => {
+            // Set revert flag.
+            await testContract.setRevertOnOperate(true).awaitTransactionSuccessAsync();
+
+            // Execute transfer.
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [defaultDepositAction],
+            };
+            const tx = callBridgeTransferFrom(accountOwner, receiver, defaultAmount, bridgeData, authorized);
+            const expectedError = 'TestDydxBridge/SHOULD_REVERT_ON_OPERATE';
+            return expect(tx).to.revertWith(expectedError);
+        });
+        it('should revert when there is a rounding error', async () => {
+            // Setup a rounding error
+            const conversionRateNumerator = new BigNumber(5318);
+            const conversionRateDenominator = new BigNumber(47958);
+            const amount = new BigNumber(9000);
+            const bridgeData = {
+                accountNumbers: [defaultAccountNumber],
+                actions: [
+                    defaultDepositAction,
+                    {
+                        ...defaultWithdrawAction,
+                        conversionRateNumerator,
+                        conversionRateDenominator,
+                    },
+                ],
+            };
+
+            // Execute transfer and assert error.
+            const tx = callBridgeTransferFrom(accountOwner, receiver, amount, bridgeData, authorized);
+            const expectedError = new LibMathRevertErrors.RoundingError(
+                conversionRateNumerator,
+                conversionRateDenominator,
+                amount,
+            );
+            return expect(tx).to.revertWith(expectedError);
+        });
+    });
+
+    describe('ERC20BridgeProxy.transferFrom()', () => {
+        const bridgeData = {
+            accountNumbers: [defaultAccountNumber],
+            actions: [defaultWithdrawAction],
+        };
+        let assetData: string;
+
+        before(async () => {
+            const testTokenAddress = await testContract.getTestToken().callAsync();
+            assetData = assetDataEncoder
+                .ERC20Bridge(testTokenAddress, testContract.address, dydxBridgeDataEncoder.encode({ bridgeData }))
+                .getABIEncodedTransactionData();
+        });
+
+        it('should succeed if `bridgeTransferFrom` succeeds', async () => {
+            await testProxyContract
+                .transferFrom(assetData, accountOwner, receiver, defaultAmount)
+                .awaitTransactionSuccessAsync({ from: authorized });
+        });
+        it('should revert if `bridgeTransferFrom` reverts', async () => {
+            // Set revert flag.
+            await testContract.setRevertOnOperate(true).awaitTransactionSuccessAsync();
+            const tx = testProxyContract
+                .transferFrom(assetData, accountOwner, receiver, defaultAmount)
+                .awaitTransactionSuccessAsync({ from: authorized });
+            const expectedError = 'TestDydxBridge/SHOULD_REVERT_ON_OPERATE';
+            return expect(tx).to.revertWith(expectedError);
+        });
+    });
+});

contracts/asset-proxy/test/erc20bridge_proxy.ts

@@ -3,15 +3,12 @@ import {
     constants,
     expect,
     getRandomInteger,
-    hexLeftPad,
-    hexRightPad,
-    hexSlice,
     Numberish,
     randomAddress,
 } from '@0x/contracts-test-utils';
 import { AuthorizableRevertErrors } from '@0x/contracts-utils';
 import { AssetProxyId } from '@0x/types';
-import { AbiEncoder, BigNumber, StringRevertError } from '@0x/utils';
+import { AbiEncoder, BigNumber, hexUtils, StringRevertError } from '@0x/utils';
 import { DecodedLogs } from 'ethereum-types';
 import * as _ from 'lodash';
 
@@ -21,7 +18,7 @@ import { ERC20BridgeProxyContract, TestERC20BridgeContract } from './wrappers';
 
 blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
     const PROXY_ID = AssetProxyId.ERC20Bridge;
-    const BRIDGE_SUCCESS_RETURN_DATA = hexRightPad(PROXY_ID);
+    const BRIDGE_SUCCESS_RETURN_DATA = hexUtils.rightPad(PROXY_ID);
     let owner: string;
     let badCaller: string;
     let assetProxy: ERC20BridgeProxyContract;
@@ -173,7 +170,7 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
 
         it('fails if asset data is truncated', async () => {
             const opts = createTransferFromOpts();
-            const truncatedAssetData = hexSlice(encodeAssetData(opts.assetData), 0, -1);
+            const truncatedAssetData = hexUtils.slice(encodeAssetData(opts.assetData), 0, -1);
             const tx = assetProxy
                 .transferFrom(truncatedAssetData, opts.from, opts.to, new BigNumber(opts.amount))
                 .awaitTransactionSuccessAsync();
@@ -197,7 +194,7 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
             const tx = transferFromAsync({
                 assetData: createAssetData({
                     bridgeData: createBridgeData({
-                        returnData: hexLeftPad('0x1'),
+                        returnData: hexUtils.leftPad('0x1'),
                     }),
                 }),
             });
@@ -210,7 +207,7 @@ blockchainTests.resets('ERC20BridgeProxy unit tests', env => {
             const tx = transferFromAsync({
                 assetData: createAssetData({
                     bridgeData: createBridgeData({
-                        returnData: hexRightPad('0x1'),
+                        returnData: hexUtils.rightPad('0x1'),
                     }),
                 }),
             });

contracts/asset-proxy/test/eth2dai_bridge.ts

@@ -4,13 +4,11 @@ import {
     expect,
     filterLogsToArguments,
     getRandomInteger,
-    hexLeftPad,
-    hexRandom,
     Numberish,
     randomAddress,
 } from '@0x/contracts-test-utils';
 import { AssetProxyId } from '@0x/types';
-import { BigNumber, RawRevertError } from '@0x/utils';
+import { BigNumber, hexUtils, RawRevertError } from '@0x/utils';
 import { DecodedLogs } from 'ethereum-types';
 import * as _ from 'lodash';
 
@@ -39,7 +37,9 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
     describe('isValidSignature()', () => {
         it('returns success bytes', async () => {
             const LEGACY_WALLET_MAGIC_VALUE = '0xb0671381';
-            const result = await testContract.isValidSignature(hexRandom(), hexRandom(_.random(0, 32))).callAsync();
+            const result = await testContract
+                .isValidSignature(hexUtils.random(), hexUtils.random(_.random(0, 32)))
+                .callAsync();
             expect(result).to.eq(LEGACY_WALLET_MAGIC_VALUE);
         });
     });
@@ -71,7 +71,7 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
                 fillAmount: getRandomInteger(1, 100e18),
                 fromTokenBalance: getRandomInteger(1, 100e18),
                 toTokentransferRevertReason: '',
-                toTokenTransferReturnData: hexLeftPad(1),
+                toTokenTransferReturnData: hexUtils.leftPad(1),
                 ...opts,
             };
         }
@@ -111,7 +111,7 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
                 _opts.toAddress,
                 new BigNumber(_opts.amount),
                 // ABI-encode the "from" token address as the bridge data.
-                hexLeftPad(_opts.fromTokenAddress as string),
+                hexUtils.leftPad(_opts.fromTokenAddress as string),
             );
             const result = await bridgeTransferFromFn.callAsync();
             const { logs } = await bridgeTransferFromFn.awaitTransactionSuccessAsync();
@@ -179,13 +179,13 @@ blockchainTests.resets('Eth2DaiBridge unit tests', env => {
         });
 
         it('fails if `toTokenAddress.transfer()` returns false', async () => {
-            const opts = createWithdrawToOpts({ toTokenTransferReturnData: hexLeftPad(0) });
+            const opts = createWithdrawToOpts({ toTokenTransferReturnData: hexUtils.leftPad(0) });
             const tx = withdrawToAsync(opts);
-            return expect(tx).to.revertWith(new RawRevertError(hexLeftPad(0)));
+            return expect(tx).to.revertWith(new RawRevertError(hexUtils.leftPad(0)));
         });
 
         it('succeeds if `toTokenAddress.transfer()` returns true', async () => {
-            await withdrawToAsync({ toTokenTransferReturnData: hexLeftPad(1) });
+            await withdrawToAsync({ toTokenTransferReturnData: hexUtils.leftPad(1) });
         });
     });
 });

contracts/asset-proxy/test/kyber_bridge.ts

@@ -3,13 +3,12 @@ import {
     constants,
     expect,
     getRandomInteger,
-    hexLeftPad,
-    hexRandom,
+    getRandomPortion,
     randomAddress,
     verifyEventsFromLogs,
 } from '@0x/contracts-test-utils';
 import { AssetProxyId } from '@0x/types';
-import { BigNumber } from '@0x/utils';
+import { BigNumber, hexUtils } from '@0x/utils';
 import { DecodedLogs } from 'ethereum-types';
 import * as _ from 'lodash';
 
@@ -19,6 +18,12 @@ import { TestKyberBridgeContract, TestKyberBridgeEvents } from './wrappers';
 
 blockchainTests.resets('KyberBridge unit tests', env => {
     const KYBER_ETH_ADDRESS = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+    const FROM_TOKEN_DECIMALS = 6;
+    const TO_TOKEN_DECIMALS = 18;
+    const FROM_TOKEN_BASE = new BigNumber(10).pow(FROM_TOKEN_DECIMALS);
+    const TO_TOKEN_BASE = new BigNumber(10).pow(TO_TOKEN_DECIMALS);
+    const WETH_BASE = new BigNumber(10).pow(18);
+    const KYBER_RATE_BASE = WETH_BASE;
     let testContract: TestKyberBridgeContract;
 
     before(async () => {
@@ -33,7 +38,9 @@ blockchainTests.resets('KyberBridge unit tests', env => {
     describe('isValidSignature()', () => {
         it('returns success bytes', async () => {
             const LEGACY_WALLET_MAGIC_VALUE = '0xb0671381';
-            const result = await testContract.isValidSignature(hexRandom(), hexRandom(_.random(0, 32))).callAsync();
+            const result = await testContract
+                .isValidSignature(hexUtils.random(), hexUtils.random(_.random(0, 32)))
+                .callAsync();
             expect(result).to.eq(LEGACY_WALLET_MAGIC_VALUE);
         });
     });
@@ -45,10 +52,10 @@ blockchainTests.resets('KyberBridge unit tests', env => {
 
         before(async () => {
             wethAddress = await testContract.weth().callAsync();
-            fromTokenAddress = await testContract.createToken().callAsync();
-            await testContract.createToken().awaitTransactionSuccessAsync();
-            toTokenAddress = await testContract.createToken().callAsync();
-            await testContract.createToken().awaitTransactionSuccessAsync();
+            fromTokenAddress = await testContract.createToken(FROM_TOKEN_DECIMALS).callAsync();
+            await testContract.createToken(FROM_TOKEN_DECIMALS).awaitTransactionSuccessAsync();
+            toTokenAddress = await testContract.createToken(TO_TOKEN_DECIMALS).callAsync();
+            await testContract.createToken(TO_TOKEN_DECIMALS).awaitTransactionSuccessAsync();
         });
 
         const STATIC_KYBER_TRADE_ARGS = {
@@ -75,13 +82,14 @@ blockchainTests.resets('KyberBridge unit tests', env => {
         }
 
         function createTransferFromOpts(opts?: Partial<TransferFromOpts>): TransferFromOpts {
+            const amount = getRandomInteger(1, TO_TOKEN_BASE.times(100));
             return {
                 fromTokenAddress,
                 toTokenAddress,
+                amount,
                 toAddress: randomAddress(),
-                amount: getRandomInteger(1, 10e18),
-                fillAmount: getRandomInteger(1, 10e18),
-                fromTokenBalance: getRandomInteger(1, 10e18),
+                fillAmount: getRandomPortion(amount),
+                fromTokenBalance: getRandomInteger(1, FROM_TOKEN_BASE.times(100)),
                 ...opts,
             };
         }
@@ -107,7 +115,7 @@ blockchainTests.resets('KyberBridge unit tests', env => {
                 // Transfer amount.
                 _opts.amount,
                 // ABI-encode the input token address as the bridge data.
-                hexLeftPad(_opts.fromTokenAddress),
+                hexUtils.leftPad(_opts.fromTokenAddress),
             );
             const result = await bridgeTransferFromFn.callAsync();
             const { logs } = await bridgeTransferFromFn.awaitTransactionSuccessAsync();
@@ -119,9 +127,12 @@ blockchainTests.resets('KyberBridge unit tests', env => {
         }
 
         function getMinimumConversionRate(opts: TransferFromOpts): BigNumber {
+            const fromBase = opts.fromTokenAddress === wethAddress ? WETH_BASE : FROM_TOKEN_BASE;
+            const toBase = opts.toTokenAddress === wethAddress ? WETH_BASE : TO_TOKEN_BASE;
             return opts.amount
-                .times(constants.ONE_ETHER)
-                .div(opts.fromTokenBalance)
+                .div(toBase)
+                .div(opts.fromTokenBalance.div(fromBase))
+                .times(KYBER_RATE_BASE)
                 .integerValue(BigNumber.ROUND_DOWN);
         }
 

contracts/asset-proxy/test/uniswap_bridge.ts

@@ -5,13 +5,11 @@ import {
     filterLogs,
     filterLogsToArguments,
     getRandomInteger,
-    hexLeftPad,
-    hexRandom,
     Numberish,
     randomAddress,
 } from '@0x/contracts-test-utils';
 import { AssetProxyId } from '@0x/types';
-import { BigNumber } from '@0x/utils';
+import { BigNumber, hexUtils } from '@0x/utils';
 import { DecodedLogs } from 'ethereum-types';
 import * as _ from 'lodash';
 
@@ -46,7 +44,9 @@ blockchainTests.resets('UniswapBridge unit tests', env => {
     describe('isValidSignature()', () => {
         it('returns success bytes', async () => {
             const LEGACY_WALLET_MAGIC_VALUE = '0xb0671381';
-            const result = await testContract.isValidSignature(hexRandom(), hexRandom(_.random(0, 32))).callAsync();
+            const result = await testContract
+                .isValidSignature(hexUtils.random(), hexUtils.random(_.random(0, 32)))
+                .callAsync();
             expect(result).to.eq(LEGACY_WALLET_MAGIC_VALUE);
         });
     });
@@ -126,7 +126,7 @@ blockchainTests.resets('UniswapBridge unit tests', env => {
                 // The amount to transfer to "to"
                 new BigNumber(_opts.amount),
                 // ABI-encoded "from" token address.
-                hexLeftPad(_opts.fromTokenAddress),
+                hexUtils.leftPad(_opts.fromTokenAddress),
             );
             const result = await bridgeTransferFromFn.callAsync();
             const receipt = await bridgeTransferFromFn.awaitTransactionSuccessAsync();
@@ -176,7 +176,7 @@ blockchainTests.resets('UniswapBridge unit tests', env => {
                 expect(calls[0].exchange).to.eq(exchangeAddress);
                 expect(calls[0].tokensSold).to.bignumber.eq(opts.fromTokenBalance);
                 expect(calls[0].minTokensBought).to.bignumber.eq(opts.amount);
-                expect(calls[0].minEthBought).to.bignumber.eq(0);
+                expect(calls[0].minEthBought).to.bignumber.eq(1);
                 expect(calls[0].deadline).to.bignumber.eq(blockTime);
                 expect(calls[0].recipient).to.eq(opts.toAddress);
                 expect(calls[0].toTokenAddress).to.eq(opts.toTokenAddress);
@@ -208,7 +208,7 @@ blockchainTests.resets('UniswapBridge unit tests', env => {
                         randomAddress(),
                         randomAddress(),
                         getRandomInteger(1, 1e18),
-                        hexLeftPad(randomAddress()),
+                        hexUtils.leftPad(randomAddress()),
                     )
                     .awaitTransactionSuccessAsync();
                 return expect(tx).to.eventually.be.rejectedWith('NO_UNISWAP_EXCHANGE_FOR_TOKEN');
@@ -282,7 +282,7 @@ blockchainTests.resets('UniswapBridge unit tests', env => {
                         randomAddress(),
                         randomAddress(),
                         getRandomInteger(1, 1e18),
-                        hexLeftPad(wethTokenAddress),
+                        hexUtils.leftPad(wethTokenAddress),
                     )
                     .awaitTransactionSuccessAsync();
                 return expect(tx).to.eventually.be.rejectedWith('NO_UNISWAP_EXCHANGE_FOR_TOKEN');
@@ -342,7 +342,7 @@ blockchainTests.resets('UniswapBridge unit tests', env => {
                         randomAddress(),
                         randomAddress(),
                         getRandomInteger(1, 1e18),
-                        hexLeftPad(randomAddress()),
+                        hexUtils.leftPad(randomAddress()),
                     )
                     .awaitTransactionSuccessAsync();
                 return expect(tx).to.eventually.be.rejectedWith('NO_UNISWAP_EXCHANGE_FOR_TOKEN');

contracts/asset-proxy/test/wrappers.ts

@@ -3,6 +3,8 @@
  * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
  * -----------------------------------------------------------------------------
  */
+export * from '../test/generated-wrappers/chai_bridge';
+export * from '../test/generated-wrappers/dydx_bridge';
 export * from '../test/generated-wrappers/erc1155_proxy';
 export * from '../test/generated-wrappers/erc20_bridge_proxy';
 export * from '../test/generated-wrappers/erc20_proxy';
@@ -12,6 +14,9 @@ export * from '../test/generated-wrappers/i_asset_data';
 export * from '../test/generated-wrappers/i_asset_proxy';
 export * from '../test/generated-wrappers/i_asset_proxy_dispatcher';
 export * from '../test/generated-wrappers/i_authorizable';
+export * from '../test/generated-wrappers/i_chai';
+export * from '../test/generated-wrappers/i_dydx';
+export * from '../test/generated-wrappers/i_dydx_bridge';
 export * from '../test/generated-wrappers/i_erc20_bridge';
 export * from '../test/generated-wrappers/i_eth2_dai';
 export * from '../test/generated-wrappers/i_kyber_network_proxy';
@@ -23,6 +28,8 @@ export * from '../test/generated-wrappers/mixin_authorizable';
 export * from '../test/generated-wrappers/multi_asset_proxy';
 export * from '../test/generated-wrappers/ownable';
 export * from '../test/generated-wrappers/static_call_proxy';
+export * from '../test/generated-wrappers/test_chai_bridge';
+export * from '../test/generated-wrappers/test_dydx_bridge';
 export * from '../test/generated-wrappers/test_erc20_bridge';
 export * from '../test/generated-wrappers/test_eth2_dai_bridge';
 export * from '../test/generated-wrappers/test_kyber_bridge';

contracts/asset-proxy/truffle-config.js

@@ -84,7 +84,7 @@ module.exports = {
         solc: {
             version: '0.5.9',
             settings: {
-                evmVersion: 'constantinople',
+                evmVersion: 'istanbul',
                 optimizer: {
                     enabled: true,
                     runs: 1000000,

contracts/asset-proxy/tsconfig.json

@@ -3,6 +3,8 @@
     "compilerOptions": { "outDir": "lib", "rootDir": ".", "resolveJsonModule": true },
     "include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*"],
     "files": [
+        "generated-artifacts/ChaiBridge.json",
+        "generated-artifacts/DydxBridge.json",
         "generated-artifacts/ERC1155Proxy.json",
         "generated-artifacts/ERC20BridgeProxy.json",
         "generated-artifacts/ERC20Proxy.json",
@@ -10,11 +12,32 @@
         "generated-artifacts/Eth2DaiBridge.json",
         "generated-artifacts/IAssetData.json",
         "generated-artifacts/IAssetProxy.json",
+        "generated-artifacts/IAssetProxyDispatcher.json",
+        "generated-artifacts/IAuthorizable.json",
+        "generated-artifacts/IChai.json",
+        "generated-artifacts/IDydx.json",
+        "generated-artifacts/IDydxBridge.json",
+        "generated-artifacts/IERC20Bridge.json",
+        "generated-artifacts/IEth2Dai.json",
+        "generated-artifacts/IKyberNetworkProxy.json",
+        "generated-artifacts/IUniswapExchange.json",
+        "generated-artifacts/IUniswapExchangeFactory.json",
         "generated-artifacts/KyberBridge.json",
+        "generated-artifacts/MixinAssetProxyDispatcher.json",
+        "generated-artifacts/MixinAuthorizable.json",
         "generated-artifacts/MultiAssetProxy.json",
+        "generated-artifacts/Ownable.json",
         "generated-artifacts/StaticCallProxy.json",
+        "generated-artifacts/TestChaiBridge.json",
+        "generated-artifacts/TestDydxBridge.json",
+        "generated-artifacts/TestERC20Bridge.json",
+        "generated-artifacts/TestEth2DaiBridge.json",
+        "generated-artifacts/TestKyberBridge.json",
         "generated-artifacts/TestStaticCallTarget.json",
+        "generated-artifacts/TestUniswapBridge.json",
         "generated-artifacts/UniswapBridge.json",
+        "test/generated-artifacts/ChaiBridge.json",
+        "test/generated-artifacts/DydxBridge.json",
         "test/generated-artifacts/ERC1155Proxy.json",
         "test/generated-artifacts/ERC20BridgeProxy.json",
         "test/generated-artifacts/ERC20Proxy.json",
@@ -24,6 +47,9 @@
         "test/generated-artifacts/IAssetProxy.json",
         "test/generated-artifacts/IAssetProxyDispatcher.json",
         "test/generated-artifacts/IAuthorizable.json",
+        "test/generated-artifacts/IChai.json",
+        "test/generated-artifacts/IDydx.json",
+        "test/generated-artifacts/IDydxBridge.json",
         "test/generated-artifacts/IERC20Bridge.json",
         "test/generated-artifacts/IEth2Dai.json",
         "test/generated-artifacts/IKyberNetworkProxy.json",
@@ -35,6 +61,8 @@
         "test/generated-artifacts/MultiAssetProxy.json",
         "test/generated-artifacts/Ownable.json",
         "test/generated-artifacts/StaticCallProxy.json",
+        "test/generated-artifacts/TestChaiBridge.json",
+        "test/generated-artifacts/TestDydxBridge.json",
         "test/generated-artifacts/TestERC20Bridge.json",
         "test/generated-artifacts/TestEth2DaiBridge.json",
         "test/generated-artifacts/TestKyberBridge.json",

contracts/broker/.npmignore

@@ -0,0 +1,10 @@
+# Blacklist all files
+.*
+*
+# Whitelist lib
+!lib/**/*
+# Whitelist Solidity contracts
+!contracts/src/**/*
+# Blacklist tests in lib
+/lib/test/*
+# Package specific ignore

contracts/broker/CHANGELOG.json

@@ -0,0 +1,20 @@
+[
+    {
+        "timestamp": 1580988106,
+        "version": "1.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "1.0.0",
+        "changes": [
+            {
+                "note": "Created package",
+                "pr": "2455"
+            }
+        ]
+    }
+]

contracts/broker/CHANGELOG.md

@@ -0,0 +1,14 @@
+<!--
+changelogUtils.file is auto-generated using the monorepo-scripts package. Don't edit directly.
+Edit the package's CHANGELOG.json file only.
+-->
+
+CHANGELOG
+
+## v1.0.1 - _February 6, 2020_
+
+    * Dependencies updated
+
+## v1.0.0 - _Invalid date_
+
+    * Created package (#2455)

contracts/broker/DEPLOYS.json

@@ -0,0 +1 @@
+[]

contracts/broker/README.md

@@ -1,6 +1,18 @@
-## Tests
+## Broker
 
-This package implements unit tests against 0x's smart contracts. Its primary purpose is to help avoid circular dependencies between the contract packages.
+This package contains the implementation of the [`Broker` contract](https://github.com/0xProject/ZEIPs/issues/75). This contract serves as an entry-point to the 0x Exchange for the filling of property-based orders. Addresses of the deployed contracts can be found in this 0x [guide](https://0x.org/docs/guides/0x-cheat-sheet) or the [DEPLOYS](./DEPLOYS.json) file within this package.
+
+## Installation
+
+**Install**
+
+```bash
+npm install @0x/contracts-broker --save
+```
+
+## Bug bounty
+
+A bug bounty for the 3.0 contracts is ongoing! Instructions can be found [here](https://0x.org/docs/guides/bug-bounty-program).
 
 ## Contributing
 
@@ -29,39 +41,21 @@ yarn install
 To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
 
 ```bash
-PKG=@0x/contracts-tests yarn build
+PKG=@0x/contracts-broker yarn build
 ```
 
 Or continuously rebuild on change:
 
 ```bash
-PKG=@0x/contracts-tests yarn watch
+PKG=@0x/contracts-broker yarn watch
 ```
 
-If imports are rebuilt in their source packages, they do not need to be rebuilt here.
-
-Example:
-
-```
-// contracts/tests/test/some-new/some_new_test.ts
-import { SomeNewContract } from '@0x/contracts-some-new';
-
-describe('should do its thing', () => {
-    const contractInstance = new SomeNewContract();
-    expect(contractInstance.someTruthyFunction.callAsync()).to.be.true();
-})
-```
-
-Run `yarn watch` from `contracts/some-new`, and then running `yarn test` from this package should test the new changes.
-
 ### Clean
 
 ```bash
 yarn clean
 ```
 
-Since the purpose of this package is to test other packages, make sure you are running `yarn clean` as necessary in the imported packages as well.
-
 ### Lint
 
 ```bash
@@ -73,3 +67,7 @@ yarn lint
 ```bash
 yarn test
 ```
+
+#### Testing options
+
+Contracts testing options like coverage, profiling, revert traces or backing node choosing - are described [here](../TESTING.md).

contracts/broker/compiler.json

@@ -4,7 +4,7 @@
     "useDockerisedSolc": false,
     "isOfflineMode": false,
     "compilerSettings": {
-        "evmVersion": "constantinople",
+        "evmVersion": "istanbul",
         "optimizer": {
             "enabled": true,
             "runs": 1000000,

contracts/broker/contracts/src/Broker.sol

@@ -0,0 +1,314 @@
+/*
+
+  Copyright 2019 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.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-asset-proxy/contracts/src/interfaces/IAssetData.sol";
+import "@0x/contracts-erc20/contracts/src/interfaces/IEtherToken.sol";
+import "@0x/contracts-erc721/contracts/src/interfaces/IERC721Token.sol";
+import "@0x/contracts-exchange/contracts/src/interfaces/IExchange.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibFillResults.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
+import "@0x/contracts-extensions/contracts/src/LibAssetDataTransfer.sol";
+import "@0x/contracts-extensions/contracts/src/MixinWethUtils.sol";
+import "@0x/contracts-utils/contracts/src/LibBytes.sol";
+import "@0x/contracts-utils/contracts/src/LibRichErrors.sol";
+import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
+import "./interfaces/IBroker.sol";
+import "./interfaces/IPropertyValidator.sol";
+import "./libs/LibBrokerRichErrors.sol";
+
+
+// solhint-disable space-after-comma, var-name-mixedcase
+contract Broker is
+    IBroker,
+    MixinWethUtils
+{
+    // Contract addresses
+
+    // Address of the 0x Exchange contract
+    address internal EXCHANGE;
+    // Address of the 0x ERC1155 Asset Proxy contract
+    address internal ERC1155_PROXY;
+
+    // The following storage variables are used to cache data for the duration of the transcation.
+    // They should always cleared at the end of the transaction.
+
+    // Token IDs specified by the taker to be used to fill property-based orders.
+    uint256[] internal _cachedTokenIds;
+    // An index to the above array keeping track of which assets have been transferred.
+    uint256 internal _cacheIndex;
+    // The address that called `brokerTrade` or `batchBrokerTrade`. Assets will be transferred to
+    // and from this address as the effectual taker of the orders.
+    address internal _sender;
+
+    using LibSafeMath for uint256;
+    using LibBytes for bytes;
+    using LibAssetDataTransfer for bytes;
+
+    /// @param exchange Address of the 0x Exchange contract.
+    /// @param exchange Address of the Wrapped Ether contract.
+    /// @param exchange Address of the 0x ERC1155 Asset Proxy contract.
+    constructor (
+        address exchange,
+        address weth
+    )
+        public
+        MixinWethUtils(
+            exchange,
+            weth
+        )
+    {
+        EXCHANGE = exchange;
+        ERC1155_PROXY = IExchange(EXCHANGE).getAssetProxy(IAssetData(address(0)).ERC1155Assets.selector);
+    }
+
+    /// @dev The Broker implements the ERC1155 transfer function to be compatible with the ERC1155 asset proxy
+    /// @param from Since the Broker serves as the taker of the order, this should equal `address(this)`
+    /// @param to This should be the maker of the order.
+    /// @param amounts Should be an array of just one `uint256`, specifying the amount of the brokered assets to transfer.
+    /// @param data Encodes the validator contract address and any auxiliary data it needs for property validation.
+    function safeBatchTransferFrom(
+        address from,
+        address to,
+        uint256[] calldata /* ids */,
+        uint256[] calldata amounts,
+        bytes calldata data
+    )
+        external
+    {
+        // Only the ERC1155 asset proxy contract should be calling this function.
+        if (msg.sender != ERC1155_PROXY) {
+            LibRichErrors.rrevert(LibBrokerRichErrors.OnlyERC1155ProxyError(
+                msg.sender
+            ));
+        }
+        // Only `takerAssetData` should be using Broker assets
+        if (from != address(this)) {
+            LibRichErrors.rrevert(
+                LibBrokerRichErrors.InvalidFromAddressError(from)
+            );
+        }
+        // Only one asset amount should be specified.
+        if (amounts.length != 1) {
+            LibRichErrors.rrevert(
+                LibBrokerRichErrors.AmountsLengthMustEqualOneError(amounts.length)
+            );
+        }
+
+        uint256 cacheIndex = _cacheIndex;
+        uint256 remainingAmount = amounts[0];
+
+        // Verify that there are enough broker assets to transfer
+        if (_cachedTokenIds.length.safeSub(cacheIndex) < remainingAmount) {
+            LibRichErrors.rrevert(
+                LibBrokerRichErrors.TooFewBrokerAssetsProvidedError(_cachedTokenIds.length)
+            );
+        }
+
+        // Decode validator and params from `data`
+        (address tokenAddress, address validator, bytes memory propertyData) = abi.decode(
+            data,
+            (address, address, bytes)
+        );
+
+        while (remainingAmount != 0) {
+            uint256 tokenId = _cachedTokenIds[cacheIndex];
+            cacheIndex++;
+
+            // Validate asset properties
+            IPropertyValidator(validator).checkBrokerAsset(
+                tokenId,
+                propertyData
+            );
+
+            // Perform the transfer
+            IERC721Token(tokenAddress).transferFrom(
+                _sender,
+                to,
+                tokenId
+            );
+
+            remainingAmount--;
+        }
+        // Update cache index in storage
+        _cacheIndex = cacheIndex;
+    }
+
+    /// @dev Fills a single property-based order by the given amount using the given assets.
+    ///      Pays protocol fees using either the ETH supplied by the taker to the transaction or
+    ///      WETH acquired from the maker during settlement. The final WETH balance is sent to the taker.
+    /// @param brokeredTokenIds Token IDs specified by the taker to be used to fill the orders.
+    /// @param order The property-based order to fill. The format of a property-based order is the
+    ///        same as that of a normal order, except the takerAssetData. Instaed of specifying a
+    ///        specific ERC721 asset, the takerAssetData should be ERC1155 assetData where the
+    ///        underlying tokenAddress is this contract's address and the desired properties are
+    ///        encoded in the extra data field. Also note that takerFees must be denominated in
+    ///        WETH (or zero).
+    /// @param takerAssetFillAmount The amount to fill the order by.
+    /// @param signature The maker's signature of the given order.
+    /// @param fillFunctionSelector The selector for either `fillOrder` or `fillOrKillOrder`.
+    /// @param ethFeeAmounts Amounts of ETH, denominated in Wei, that are paid to corresponding feeRecipients.
+    /// @param feeRecipients Addresses that will receive ETH when orders are filled.
+    /// @return fillResults Amounts filled and fees paid by the maker and taker.
+    function brokerTrade(
+        uint256[] memory brokeredTokenIds,
+        LibOrder.Order memory order,
+        uint256 takerAssetFillAmount,
+        bytes memory signature,
+        bytes4 fillFunctionSelector,
+        uint256[] memory ethFeeAmounts,
+        address payable[] memory feeRecipients
+    )
+        public
+        payable
+        returns (LibFillResults.FillResults memory fillResults)
+    {
+        // Cache the taker-supplied asset data
+        _cachedTokenIds = brokeredTokenIds;
+        // Cache the sender's address
+        _sender = msg.sender;
+
+        // Sanity-check the provided function selector
+        if (
+            fillFunctionSelector != IExchange(address(0)).fillOrder.selector &&
+            fillFunctionSelector != IExchange(address(0)).fillOrKillOrder.selector
+        ) {
+            LibBrokerRichErrors.InvalidFunctionSelectorError(fillFunctionSelector);
+        }
+
+        // Pay ETH affiliate fees to all feeRecipient addresses
+        _transferEthFeesAndWrapRemaining(ethFeeAmounts, feeRecipients);
+
+        // Perform the fill
+        bytes memory fillCalldata = abi.encodeWithSelector(
+            fillFunctionSelector,
+            order,
+            takerAssetFillAmount,
+            signature
+        );
+        // solhint-disable-next-line avoid-call-value
+        (bool didSucceed, bytes memory returnData) = EXCHANGE.call(fillCalldata);
+        if (didSucceed) {
+            fillResults = abi.decode(returnData, (LibFillResults.FillResults));
+        } else {
+            // Re-throw error
+            LibRichErrors.rrevert(returnData);
+        }
+
+        // Transfer maker asset to taker
+        if (!order.makerAssetData.equals(WETH_ASSET_DATA)) {
+            order.makerAssetData.transferOut(fillResults.makerAssetFilledAmount);
+        }
+
+        // Refund remaining ETH to msg.sender.
+        _unwrapAndTransferEth(WETH.balanceOf(address(this)));
+
+        _clearStorage();
+
+        return fillResults;
+    }
+
+    /// @dev Fills multiple property-based orders by the given amounts using the given assets.
+    ///      Pays protocol fees using either the ETH supplied by the taker to the transaction or
+    ///      WETH acquired from the maker during settlement. The final WETH balance is sent to the taker.
+    /// @param brokeredTokenIds Token IDs specified by the taker to be used to fill the orders.
+    /// @param orders The property-based orders to fill. The format of a property-based order is the
+    ///        same as that of a normal order, except the takerAssetData. Instaed of specifying a
+    ///        specific ERC721 asset, the takerAssetData should be ERC1155 assetData where the
+    ///        underlying tokenAddress is this contract's address and the desired properties are
+    ///        encoded in the extra data field. Also note that takerFees must be denominated in
+    ///        WETH (or zero).
+    /// @param takerAssetFillAmounts The amounts to fill the orders by.
+    /// @param signatures The makers' signatures for the given orders.
+    /// @param batchFillFunctionSelector The selector for either `batchFillOrders`,
+    ///        `batchFillOrKillOrders`, or `batchFillOrdersNoThrow`.
+    /// @param ethFeeAmounts Amounts of ETH, denominated in Wei, that are paid to corresponding feeRecipients.
+    /// @param feeRecipients Addresses that will receive ETH when orders are filled.
+    /// @return fillResults Amounts filled and fees paid by the makers and taker.
+    function batchBrokerTrade(
+        uint256[] memory brokeredTokenIds,
+        LibOrder.Order[] memory orders,
+        uint256[] memory takerAssetFillAmounts,
+        bytes[] memory signatures,
+        bytes4 batchFillFunctionSelector,
+        uint256[] memory ethFeeAmounts,
+        address payable[] memory feeRecipients
+    )
+        public
+        payable
+        returns (LibFillResults.FillResults[] memory fillResults)
+    {
+        // Cache the taker-supplied asset data
+        _cachedTokenIds = brokeredTokenIds;
+        // Cache the sender's address
+        _sender = msg.sender;
+
+        // Sanity-check the provided function selector
+        if (
+            batchFillFunctionSelector != IExchange(address(0)).batchFillOrders.selector &&
+            batchFillFunctionSelector != IExchange(address(0)).batchFillOrKillOrders.selector &&
+            batchFillFunctionSelector != IExchange(address(0)).batchFillOrdersNoThrow.selector
+        ) {
+            LibBrokerRichErrors.InvalidFunctionSelectorError(batchFillFunctionSelector);
+        }
+
+        // Pay ETH affiliate fees to all feeRecipient addresses
+        _transferEthFeesAndWrapRemaining(ethFeeAmounts, feeRecipients);
+
+        // Perform the batch fill
+        bytes memory batchFillCalldata = abi.encodeWithSelector(
+            batchFillFunctionSelector,
+            orders,
+            takerAssetFillAmounts,
+            signatures
+        );
+        // solhint-disable-next-line avoid-call-value
+        (bool didSucceed, bytes memory returnData) = EXCHANGE.call(batchFillCalldata);
+        if (didSucceed) {
+            // solhint-disable-next-line indent
+            fillResults = abi.decode(returnData, (LibFillResults.FillResults[]));
+        } else {
+            // Re-throw error
+            LibRichErrors.rrevert(returnData);
+        }
+
+        // Transfer maker assets to taker
+        for (uint256 i = 0; i < orders.length; i++) {
+            if (!orders[i].makerAssetData.equals(WETH_ASSET_DATA)) {
+                orders[i].makerAssetData.transferOut(fillResults[i].makerAssetFilledAmount);
+            }
+        }
+
+        // Refund remaining ETH to msg.sender.
+        _unwrapAndTransferEth(WETH.balanceOf(address(this)));
+
+        _clearStorage();
+
+        return fillResults;
+    }
+
+    function _clearStorage()
+        private
+    {
+        delete _cachedTokenIds;
+        _cacheIndex = 0;
+        _sender = address(0);
+    }
+}

contracts/broker/contracts/src/interfaces/IBroker.sol

@@ -0,0 +1,101 @@
+/*
+
+  Copyright 2019 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.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-exchange-libs/contracts/src/LibFillResults.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
+
+
+// solhint-disable space-after-comma
+interface IBroker {
+
+    /// @dev Fills a single property-based order by the given amount using the given assets.
+    ///      Pays protocol fees using either the ETH supplied by the taker to the transaction or
+    ///      WETH acquired from the maker during settlement. The final WETH balance is sent to the taker.
+    /// @param brokeredTokenIds Token IDs specified by the taker to be used to fill the orders.
+    /// @param order The property-based order to fill. The format of a property-based order is the
+    ///        same as that of a normal order, except the takerAssetData. Instaed of specifying a
+    ///        specific ERC721 asset, the takerAssetData should be ERC1155 assetData where the
+    ///        underlying tokenAddress is this contract's address and the desired properties are
+    ///        encoded in the extra data field. Also note that takerFees must be denominated in
+    ///        WETH (or zero).
+    /// @param takerAssetFillAmount The amount to fill the order by.
+    /// @param signature The maker's signature of the given order.
+    /// @param fillFunctionSelector The selector for either `fillOrder` or `fillOrKillOrder`.
+    /// @param ethFeeAmounts Amounts of ETH, denominated in Wei, that are paid to corresponding feeRecipients.
+    /// @param feeRecipients Addresses that will receive ETH when orders are filled.
+    /// @return fillResults Amounts filled and fees paid by the maker and taker.
+    function brokerTrade(
+        uint256[] calldata brokeredTokenIds,
+        LibOrder.Order calldata order,
+        uint256 takerAssetFillAmount,
+        bytes calldata signature,
+        bytes4 fillFunctionSelector,
+        uint256[] calldata ethFeeAmounts,
+        address payable[] calldata feeRecipients
+    )
+        external
+        payable
+        returns (LibFillResults.FillResults memory fillResults);
+
+    /// @dev Fills multiple property-based orders by the given amounts using the given assets.
+    ///      Pays protocol fees using either the ETH supplied by the taker to the transaction or
+    ///      WETH acquired from the maker during settlement. The final WETH balance is sent to the taker.
+    /// @param brokeredTokenIds Token IDs specified by the taker to be used to fill the orders.
+    /// @param orders The property-based orders to fill. The format of a property-based order is the
+    ///        same as that of a normal order, except the takerAssetData. Instaed of specifying a
+    ///        specific ERC721 asset, the takerAssetData should be ERC1155 assetData where the
+    ///        underlying tokenAddress is this contract's address and the desired properties are
+    ///        encoded in the extra data field. Also note that takerFees must be denominated in
+    ///        WETH (or zero).
+    /// @param takerAssetFillAmounts The amounts to fill the orders by.
+    /// @param signatures The makers' signatures for the given orders.
+    /// @param batchFillFunctionSelector The selector for either `batchFillOrders`,
+    ///        `batchFillOrKillOrders`, or `batchFillOrdersNoThrow`.
+    /// @param ethFeeAmounts Amounts of ETH, denominated in Wei, that are paid to corresponding feeRecipients.
+    /// @param feeRecipients Addresses that will receive ETH when orders are filled.
+    /// @return fillResults Amounts filled and fees paid by the makers and taker.
+    function batchBrokerTrade(
+        uint256[] calldata brokeredTokenIds,
+        LibOrder.Order[] calldata orders,
+        uint256[] calldata takerAssetFillAmounts,
+        bytes[] calldata signatures,
+        bytes4 batchFillFunctionSelector,
+        uint256[] calldata ethFeeAmounts,
+        address payable[] calldata feeRecipients
+    )
+        external
+        payable
+        returns (LibFillResults.FillResults[] memory fillResults);
+
+    /// @dev The Broker implements the ERC1155 transfer function to be compatible with the ERC1155 asset proxy
+    /// @param from Since the Broker serves as the taker of the order, this should equal `address(this)`
+    /// @param to This should be the maker of the order.
+    /// @param amounts Should be an array of just one `uint256`, specifying the amount of the brokered assets to transfer.
+    /// @param data Encodes the validator contract address and any auxiliary data it needs for property validation.
+    function safeBatchTransferFrom(
+        address from,
+        address to,
+        uint256[] calldata /* ids */,
+        uint256[] calldata amounts,
+        bytes calldata data
+    )
+        external;
+}

contracts/broker/contracts/src/interfaces/IGodsUnchained.sol

@@ -19,20 +19,15 @@
 pragma solidity ^0.5.9;
 pragma experimental ABIEncoderV2;
 
-import "@0x/contracts-utils/contracts/src/Ownable.sol";
-import "./libs/LibConstants.sol";
-import "./MixinMatchOrders.sol";
-import "./MixinAssets.sol";
 
+interface IGodsUnchained {
 
-// solhint-disable no-empty-blocks
-contract OrderMatcher is
-    MixinMatchOrders,
-    MixinAssets
-{
-    constructor (address _exchange)
-        public
-        LibConstants(_exchange)
-        Ownable()
-    {}
+    /// @dev Returns the proto and quality for a particular card given its token id
+    /// @param tokenId The id of the card to query.
+    /// @return proto The proto of the given card.
+    /// @return quality The quality of the given card
+    function getDetails(uint256 tokenId)
+        external
+        view
+        returns (uint16 proto, uint8 quality);
 }

contracts/broker/contracts/src/interfaces/IPropertyValidator.sol

@@ -17,15 +17,19 @@
 */
 
 pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
 
 
-contract IThresholdAsset {
+interface IPropertyValidator {
 
-    /// @param _owner The address from which the balance will be retrieved
-    /// @return Balance of owner
-    function balanceOf(address _owner)
+    /// @dev Checks that the given asset data satisfies the properties encoded in `propertyData`.
+    ///      Should revert if the asset does not satisfy the specified properties.
+    /// @param tokenId The ERC721 tokenId of the asset to check.
+    /// @param propertyData Encoded properties or auxiliary data needed to perform the check.
+    function checkBrokerAsset(
+        uint256 tokenId,
+        bytes calldata propertyData
+    )
         external
-        view
-        returns (uint256);
-
+        view;
 }

contracts/broker/contracts/src/libs/LibBrokerRichErrors.sol

@@ -0,0 +1,109 @@
+/*
+
+  Copyright 2019 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.9;
+
+
+library LibBrokerRichErrors {
+
+    // bytes4(keccak256("InvalidFromAddressError(address)"))
+    bytes4 internal constant INVALID_FROM_ADDRESS_ERROR_SELECTOR =
+        0x906bfb3c;
+
+    // bytes4(keccak256("AmountsLengthMustEqualOneError(uint256)"))
+    bytes4 internal constant AMOUNTS_LENGTH_MUST_EQUAL_ONE_ERROR_SELECTOR =
+        0xba9be200;
+
+    // bytes4(keccak256("TooFewBrokerAssetsProvidedError(uint256)"))
+    bytes4 internal constant TOO_FEW_BROKER_ASSETS_PROVIDED_ERROR_SELECTOR =
+        0x55272586;
+
+    // bytes4(keccak256("InvalidFunctionSelectorError(bytes4)"))
+    bytes4 internal constant INVALID_FUNCTION_SELECTOR_ERROR_SELECTOR =
+        0x540943f1;
+
+    // bytes4(keccak256("OnlyERC1155ProxyError(address)"))
+    bytes4 internal constant ONLY_ERC_1155_PROXY_ERROR_SELECTOR =
+        0xccc529af;
+
+    // solhint-disable func-name-mixedcase
+    function InvalidFromAddressError(
+        address from
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            INVALID_FROM_ADDRESS_ERROR_SELECTOR,
+            from
+        );
+    }
+
+    function AmountsLengthMustEqualOneError(
+        uint256 amountsLength
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            AMOUNTS_LENGTH_MUST_EQUAL_ONE_ERROR_SELECTOR,
+            amountsLength
+        );
+    }
+
+    function TooFewBrokerAssetsProvidedError(
+        uint256 numBrokeredAssets
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            TOO_FEW_BROKER_ASSETS_PROVIDED_ERROR_SELECTOR,
+            numBrokeredAssets
+        );
+    }
+
+    function InvalidFunctionSelectorError(
+        bytes4 selector
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            INVALID_FUNCTION_SELECTOR_ERROR_SELECTOR,
+            selector
+        );
+    }
+
+    function OnlyERC1155ProxyError(
+        address sender
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            ONLY_ERC_1155_PROXY_ERROR_SELECTOR,
+            sender
+        );
+    }
+}

contracts/broker/contracts/src/validators/GodsUnchainedValidator.sol

@@ -0,0 +1,61 @@
+/*
+
+  Copyright 2019 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.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-utils/contracts/src/LibBytes.sol";
+import "../interfaces/IGodsUnchained.sol";
+import "../interfaces/IPropertyValidator.sol";
+
+
+contract GodsUnchainedValidator is
+    IPropertyValidator
+{
+    IGodsUnchained internal GODS_UNCHAINED; // solhint-disable-line var-name-mixedcase
+
+    using LibBytes for bytes;
+
+    constructor(address _godsUnchained)
+        public
+    {
+        GODS_UNCHAINED = IGodsUnchained(_godsUnchained);
+    }
+
+    /// @dev Checks that the given card (encoded as assetData) has the proto and quality encoded in `propertyData`.
+    ///      Reverts if the card doesn't match the specified proto and quality.
+    /// @param tokenId The ERC721 tokenId of the card to check.
+    /// @param propertyData Encoded proto and quality that the card is expected to have.
+    function checkBrokerAsset(
+        uint256 tokenId,
+        bytes calldata propertyData
+    )
+        external
+        view
+    {
+        (uint16 expectedProto, uint8 expectedQuality) = abi.decode(
+            propertyData,
+            (uint16, uint8)
+        );
+
+        // Validate card properties.
+        (uint16 proto, uint8 quality) = GODS_UNCHAINED.getDetails(tokenId);
+        require(proto == expectedProto, "GodsUnchainedValidator/PROTO_MISMATCH");
+        require(quality == expectedQuality, "GodsUnchainedValidator/QUALITY_MISMATCH");
+    }
+}

contracts/broker/contracts/test/TestGodsUnchained.sol

@@ -0,0 +1,55 @@
+/*
+
+  Copyright 2019 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.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc721/contracts/test/DummyERC721Token.sol";
+import "../src/interfaces/IGodsUnchained.sol";
+
+
+contract TestGodsUnchained is
+    IGodsUnchained,
+    DummyERC721Token
+{
+    mapping (uint256 => uint16) internal _protoByTokenId;
+    mapping (uint256 => uint8) internal _qualityByTokenId;
+
+    constructor (
+        string memory _name,
+        string memory _symbol
+    )
+        public
+        DummyERC721Token(_name, _symbol)
+    {} // solhint-disable-line no-empty-blocks
+
+    function setTokenProperties(uint256 tokenId, uint16 proto, uint8 quality)
+        external
+    {
+        _protoByTokenId[tokenId] = proto;
+        _qualityByTokenId[tokenId] = quality;
+    }
+
+    function getDetails(uint256 tokenId)
+        external
+        view
+        returns (uint16 proto, uint8 quality)
+    {
+        return (_protoByTokenId[tokenId], _qualityByTokenId[tokenId]);
+    }
+}

contracts/broker/package.json

@@ -1,19 +1,19 @@
 {
-    "name": "@0x/contracts-tests",
-    "private": true,
-    "version": "0.0.6",
+    "name": "@0x/contracts-broker",
+    "version": "1.0.1",
     "engines": {
         "node": ">=6.12"
     },
-    "description": "Unit tests for 0x contracts",
+    "description": "Extension of 0x protocol for property-based orders",
     "main": "lib/src/index.js",
     "directories": {
         "test": "test"
     },
     "scripts": {
-        "build": "tsc -b",
+        "build": "yarn build:contracts && yarn build:ts",
+        "build:contracts": "run-s compile contracts:gen generate_contract_wrappers contracts:copy",
+        "build:ts": "tsc -b",
         "build:ci": "yarn build",
-        "pre_build": "run-s compile contracts:gen generate_contract_wrappers contracts:copy",
         "test": "yarn run_mocha",
         "rebuild_and_test": "run-s build test",
         "test:coverage": "SOLIDITY_COVERAGE=true run-s build run_mocha coverage:report:text coverage:report:lcov",
@@ -23,9 +23,8 @@
         "compile": "sol-compiler",
         "watch": "sol-compiler -w",
         "clean": "shx rm -rf lib test/generated-artifacts test/generated-wrappers generated-artifacts generated-wrappers",
-        "generate_contract_wrappers": "abi-gen --abis  ${npm_package_config_abis} --output test/generated-wrappers --backend ethers",
+        "generate_contract_wrappers": "abi-gen --debug --abis  ${npm_package_config_abis} --output test/generated-wrappers --backend ethers",
         "lint": "tslint --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./test/generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude ./test/generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
-        "fix": "tslint --fix --format stylish --project . --exclude ./generated-wrappers/**/* --exclude ./test/generated-wrappers/**/* --exclude ./generated-artifacts/**/* --exclude ./test/generated-artifacts/**/* --exclude **/lib/**/* && yarn lint-contracts",
         "coverage:report:text": "istanbul report text",
         "coverage:report:html": "istanbul report html && open coverage/index.html",
         "profiler:report:html": "istanbul report html && open coverage/index.html",
@@ -34,11 +33,13 @@
         "contracts:gen": "contracts-gen generate",
         "contracts:copy": "contracts-gen copy",
         "lint-contracts": "solhint -c ../.solhint.json contracts/**/**/**/**/*.sol",
-        "compile:truffle": "truffle compile"
+        "compile:truffle": "truffle compile",
+        "docs:md": "ts-doc-gen --sourceDir='$PROJECT_FILES' --output=$MD_FILE_DIR --fileExtension=mdx --tsconfig=./typedoc-tsconfig.json",
+        "docs:json": "typedoc --excludePrivate --excludeExternals --excludeProtected --ignoreCompilerErrors --target ES5 --tsconfig typedoc-tsconfig.json --json $JSON_FILE_PATH $PROJECT_FILES"
     },
     "config": {
-        "abis": "./generated-artifacts/@().json",
-        "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually."
+        "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually.",
+        "abis": "./test/generated-artifacts/@(Broker|GodsUnchainedValidator|IBroker|IGodsUnchained|IPropertyValidator|LibBrokerRichErrors|TestGodsUnchained).json"
     },
     "repository": {
         "type": "git",
@@ -48,31 +49,30 @@
     "bugs": {
         "url": "https://github.com/0xProject/0x-monorepo/issues"
     },
-    "homepage": "https://github.com/0xProject/0x-monorepo/contracts/tests/README.md",
+    "homepage": "https://github.com/0xProject/0x-monorepo/contracts/extensions/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^5.0.0",
-        "@0x/base-contract": "^6.0.0",
-        "@0x/contracts-asset-proxy": "^3.0.0",
-        "@0x/contracts-dev-utils": "^1.0.0",
-        "@0x/contracts-erc1155": "^2.0.0",
-        "@0x/contracts-erc20": "^3.0.0",
-        "@0x/contracts-erc721": "^3.0.0",
-        "@0x/contracts-exchange": "^3.0.0",
-        "@0x/contracts-gen": "^2.0.0",
-        "@0x/contracts-test-utils": "^4.0.0",
-        "@0x/sol-compiler": "^4.0.0",
+        "@0x/abi-gen": "^5.1.2",
+        "@0x/contracts-asset-proxy": "^3.1.3",
+        "@0x/contracts-erc20": "^3.0.6",
+        "@0x/contracts-erc721": "^3.0.6",
+        "@0x/contracts-exchange": "^3.1.2",
+        "@0x/contracts-exchange-libs": "^4.2.0",
+        "@0x/contracts-gen": "^2.0.6",
+        "@0x/contracts-test-utils": "^5.1.3",
+        "@0x/contracts-utils": "^4.2.1",
+        "@0x/sol-compiler": "^4.0.6",
+        "@0x/ts-doc-gen": "^0.0.22",
         "@0x/tslint-config": "^4.0.0",
-        "@0x/types": "^3.0.0",
-        "@0x/typescript-typings": "^5.0.0",
-        "@0x/utils": "^5.0.0",
-        "@0x/web3-wrapper": "^7.0.0",
+        "@0x/types": "^3.1.1",
+        "@0x/web3-wrapper": "^7.0.5",
+        "@types/lodash": "4.14.104",
         "@types/mocha": "^5.2.7",
         "@types/node": "*",
         "chai": "^4.0.1",
         "chai-as-promised": "^7.1.0",
         "chai-bignumber": "^3.0.0",
         "dirty-chai": "^2.0.1",
-        "ethereum-types": "^3.0.0",
+        "lodash": "^4.17.11",
         "make-promises-safe": "^1.1.0",
         "mocha": "^6.2.0",
         "npm-run-all": "^4.1.2",
@@ -80,9 +80,17 @@
         "solhint": "^1.4.1",
         "truffle": "^5.0.32",
         "tslint": "5.11.0",
+        "typedoc": "^0.15.0",
         "typescript": "3.0.1"
     },
+    "dependencies": {
+        "@0x/base-contract": "^6.1.2",
+        "@0x/order-utils": "^10.1.3",
+        "@0x/typescript-typings": "^5.0.1",
+        "@0x/utils": "^5.3.0",
+        "ethereum-types": "^3.0.0"
+    },
     "publishConfig": {
-        "access": "private"
+        "access": "public"
     }
 }

contracts/broker/src/artifacts.ts

@@ -0,0 +1,23 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+import { ContractArtifact } from 'ethereum-types';
+
+import * as Broker from '../generated-artifacts/Broker.json';
+import * as GodsUnchainedValidator from '../generated-artifacts/GodsUnchainedValidator.json';
+import * as IBroker from '../generated-artifacts/IBroker.json';
+import * as IGodsUnchained from '../generated-artifacts/IGodsUnchained.json';
+import * as IPropertyValidator from '../generated-artifacts/IPropertyValidator.json';
+import * as LibBrokerRichErrors from '../generated-artifacts/LibBrokerRichErrors.json';
+import * as TestGodsUnchained from '../generated-artifacts/TestGodsUnchained.json';
+export const artifacts = {
+    Broker: Broker as ContractArtifact,
+    IBroker: IBroker as ContractArtifact,
+    IGodsUnchained: IGodsUnchained as ContractArtifact,
+    IPropertyValidator: IPropertyValidator as ContractArtifact,
+    LibBrokerRichErrors: LibBrokerRichErrors as ContractArtifact,
+    GodsUnchainedValidator: GodsUnchainedValidator as ContractArtifact,
+    TestGodsUnchained: TestGodsUnchained as ContractArtifact,
+};

contracts/broker/src/gods_unchained_utils.ts

@@ -0,0 +1,42 @@
+import { assetDataUtils } from '@0x/order-utils';
+import { AbiEncoder, BigNumber } from '@0x/utils';
+
+export const godsUnchainedUtils = {
+    /**
+     * Encodes the given proto and quality into the bytes format expected by the GodsUnchainedValidator.
+     */
+    encodePropertyData(proto: BigNumber, quality: BigNumber): string {
+        return AbiEncoder.create([{ name: 'proto', type: 'uint16' }, { name: 'quality', type: 'uint8' }]).encode({
+            proto,
+            quality,
+        });
+    },
+    /**
+     * Encodes the given proto and quality into ERC1155 asset data to be used as the takerAssetData
+     * of a property-based GodsUnchained order. Must also provide the addresses of the Broker,
+     * GodsUnchained, and GodsUnchainedValidator contracts. The optional bundleSize parameter specifies
+     * how many cards are expected for each "unit" of the takerAssetAmount. For example, If the
+     * takerAssetAmount is 3 and the bundleSize is 2, the taker must provide 2, 4, or 6 cards
+     * with the given proto and quality to fill the order. If an odd number is provided, the fill fails.
+     */
+    encodeBrokerAssetData(
+        brokerAddress: string,
+        godsUnchainedAddress: string,
+        validatorAddress: string,
+        proto: BigNumber,
+        quality: BigNumber,
+        bundleSize: number = 1,
+    ): string {
+        const dataEncoder = AbiEncoder.create([
+            { name: 'godsUnchainedAddress', type: 'address' },
+            { name: 'validatorAddress', type: 'address' },
+            { name: 'propertyData', type: 'bytes' },
+        ]);
+        const propertyData = AbiEncoder.create([
+            { name: 'proto', type: 'uint16' },
+            { name: 'quality', type: 'uint8' },
+        ]).encode({ proto, quality });
+        const data = dataEncoder.encode({ godsUnchainedAddress, validatorAddress, propertyData });
+        return assetDataUtils.encodeERC1155AssetData(brokerAddress, [], [new BigNumber(bundleSize)], data);
+    },
+};

contracts/broker/src/index.ts

@@ -0,0 +1,32 @@
+export { artifacts } from './artifacts';
+export { BrokerContract, GodsUnchainedValidatorContract, TestGodsUnchainedContract } from './wrappers';
+export { godsUnchainedUtils } from './gods_unchained_utils';
+export { BrokerRevertErrors } from '@0x/utils';
+export {
+    ContractArtifact,
+    ContractChains,
+    CompilerOpts,
+    StandardContractOutput,
+    CompilerSettings,
+    ContractChainData,
+    ContractAbi,
+    DevdocOutput,
+    EvmOutput,
+    CompilerSettingsMetadata,
+    OptimizerSettings,
+    OutputField,
+    ParamDescription,
+    EvmBytecodeOutput,
+    AbiDefinition,
+    FunctionAbi,
+    EventAbi,
+    RevertErrorAbi,
+    EventParameter,
+    DataItem,
+    MethodAbi,
+    ConstructorAbi,
+    FallbackAbi,
+    ConstructorStateMutability,
+    TupleDataItem,
+    StateMutability,
+} from 'ethereum-types';

contracts/broker/src/wrappers.ts

@@ -0,0 +1,12 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+export * from '../generated-wrappers/broker';
+export * from '../generated-wrappers/gods_unchained_validator';
+export * from '../generated-wrappers/i_broker';
+export * from '../generated-wrappers/i_gods_unchained';
+export * from '../generated-wrappers/i_property_validator';
+export * from '../generated-wrappers/lib_broker_rich_errors';
+export * from '../generated-wrappers/test_gods_unchained';

contracts/broker/test/artifacts.ts

@@ -0,0 +1,23 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+import { ContractArtifact } from 'ethereum-types';
+
+import * as Broker from '../test/generated-artifacts/Broker.json';
+import * as GodsUnchainedValidator from '../test/generated-artifacts/GodsUnchainedValidator.json';
+import * as IBroker from '../test/generated-artifacts/IBroker.json';
+import * as IGodsUnchained from '../test/generated-artifacts/IGodsUnchained.json';
+import * as IPropertyValidator from '../test/generated-artifacts/IPropertyValidator.json';
+import * as LibBrokerRichErrors from '../test/generated-artifacts/LibBrokerRichErrors.json';
+import * as TestGodsUnchained from '../test/generated-artifacts/TestGodsUnchained.json';
+export const artifacts = {
+    Broker: Broker as ContractArtifact,
+    IBroker: IBroker as ContractArtifact,
+    IGodsUnchained: IGodsUnchained as ContractArtifact,
+    IPropertyValidator: IPropertyValidator as ContractArtifact,
+    LibBrokerRichErrors: LibBrokerRichErrors as ContractArtifact,
+    GodsUnchainedValidator: GodsUnchainedValidator as ContractArtifact,
+    TestGodsUnchained: TestGodsUnchained as ContractArtifact,
+};

contracts/broker/test/gods_unchained_validator_test.ts

@@ -0,0 +1,56 @@
+import { blockchainTests, constants, expect, getRandomInteger } from '@0x/contracts-test-utils';
+import { BigNumber } from '@0x/utils';
+import * as _ from 'lodash';
+
+import { godsUnchainedUtils } from '../src/gods_unchained_utils';
+
+import { artifacts } from './artifacts';
+import { GodsUnchainedValidatorContract, TestGodsUnchainedContract } from './wrappers';
+
+blockchainTests.resets('GodsUnchainedValidator unit tests', env => {
+    let godsUnchained: TestGodsUnchainedContract;
+    let validator: GodsUnchainedValidatorContract;
+
+    before(async () => {
+        godsUnchained = await TestGodsUnchainedContract.deployFrom0xArtifactAsync(
+            artifacts.TestGodsUnchained,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+            'Gods Unchained Cards',
+            'GU',
+        );
+
+        validator = await GodsUnchainedValidatorContract.deployFrom0xArtifactAsync(
+            artifacts.GodsUnchainedValidator,
+            env.provider,
+            env.txDefaults,
+            artifacts,
+            godsUnchained.address,
+        );
+    });
+
+    describe('checkBrokerAsset', () => {
+        const proto = new BigNumber(42);
+        const quality = new BigNumber(7);
+        const propertyData = godsUnchainedUtils.encodePropertyData(proto, quality);
+
+        it('succeeds if assetData proto and quality match propertyData', async () => {
+            const tokenId = getRandomInteger(0, constants.MAX_UINT256);
+            await godsUnchained.setTokenProperties(tokenId, proto, quality).awaitTransactionSuccessAsync();
+            await validator.checkBrokerAsset(tokenId, propertyData).callAsync();
+        });
+        it("reverts if assetData proto doesn't match propertyData", async () => {
+            const tokenId = getRandomInteger(0, constants.MAX_UINT256);
+            await godsUnchained.setTokenProperties(tokenId, proto.plus(1), quality).awaitTransactionSuccessAsync();
+            const tx = validator.checkBrokerAsset(tokenId, propertyData).callAsync();
+            expect(tx).to.revertWith('PROTO_MISMATCH');
+        });
+        it("reverts if assetData quality doesn't match proeprtyData", async () => {
+            const tokenId = getRandomInteger(0, constants.MAX_UINT256);
+            await godsUnchained.setTokenProperties(tokenId, proto, quality.plus(1)).awaitTransactionSuccessAsync();
+            const tx = validator.checkBrokerAsset(tokenId, propertyData).callAsync();
+            expect(tx).to.revertWith('QUALITY_MISMATCH');
+        });
+    });
+});

contracts/broker/test/wrappers.ts

@@ -0,0 +1,12 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
+ * -----------------------------------------------------------------------------
+ */
+export * from '../test/generated-wrappers/broker';
+export * from '../test/generated-wrappers/gods_unchained_validator';
+export * from '../test/generated-wrappers/i_broker';
+export * from '../test/generated-wrappers/i_gods_unchained';
+export * from '../test/generated-wrappers/i_property_validator';
+export * from '../test/generated-wrappers/lib_broker_rich_errors';
+export * from '../test/generated-wrappers/test_gods_unchained';

contracts/broker/truffle-config.js

@@ -0,0 +1,96 @@
+/**
+ * Use this file to configure your truffle project. It's seeded with some
+ * common settings for different networks and features like migrations,
+ * compilation and testing. Uncomment the ones you need or modify
+ * them to suit your project as necessary.
+ *
+ * More information about configuration can be found at:
+ *
+ * truffleframework.com/docs/advanced/configuration
+ *
+ * To deploy via Infura you'll need a wallet provider (like truffle-hdwallet-provider)
+ * to sign your transactions before they're sent to a remote public node. Infura accounts
+ * are available for free at: infura.io/register.
+ *
+ * You'll also need a mnemonic - the twelve word phrase the wallet uses to generate
+ * public/private key pairs. If you're publishing your code to GitHub make sure you load this
+ * phrase from a file you've .gitignored so it doesn't accidentally become public.
+ *
+ */
+
+// const HDWalletProvider = require('truffle-hdwallet-provider');
+// const infuraKey = "fj4jll3k.....";
+//
+// const fs = require('fs');
+// const mnemonic = fs.readFileSync(".secret").toString().trim();
+
+module.exports = {
+    /**
+     * Networks define how you connect to your ethereum client and let you set the
+     * defaults web3 uses to send transactions. If you don't specify one truffle
+     * will spin up a development blockchain for you on port 9545 when you
+     * run `develop` or `test`. You can ask a truffle command to use a specific
+     * network from the command line, e.g
+     *
+     * $ truffle test --network <network-name>
+     */
+
+    networks: {
+        // Useful for testing. The `development` name is special - truffle uses it by default
+        // if it's defined here and no other network is specified at the command line.
+        // You should run a client (like ganache-cli, geth or parity) in a separate terminal
+        // tab if you use this network and you must also set the `host`, `port` and `network_id`
+        // options below to some value.
+        //
+        // development: {
+        //  host: "127.0.0.1",     // Localhost (default: none)
+        //  port: 8545,            // Standard Ethereum port (default: none)
+        //  network_id: "*",       // Any network (default: none)
+        // },
+        // Another network with more advanced options...
+        // advanced: {
+        // port: 8777,             // Custom port
+        // network_id: 1342,       // Custom network
+        // gas: 8500000,           // Gas sent with each transaction (default: ~6700000)
+        // gasPrice: 20000000000,  // 20 gwei (in wei) (default: 100 gwei)
+        // from: <address>,        // Account to send txs from (default: accounts[0])
+        // websockets: true        // Enable EventEmitter interface for web3 (default: false)
+        // },
+        // Useful for deploying to a public network.
+        // NB: It's important to wrap the provider as a function.
+        // ropsten: {
+        // provider: () => new HDWalletProvider(mnemonic, `https://ropsten.infura.io/v3/YOUR-PROJECT-ID`),
+        // network_id: 3,       // Ropsten's id
+        // gas: 5500000,        // Ropsten has a lower block limit than mainnet
+        // confirmations: 2,    // # of confs to wait between deployments. (default: 0)
+        // timeoutBlocks: 200,  // # of blocks before a deployment times out  (minimum/default: 50)
+        // skipDryRun: true     // Skip dry run before migrations? (default: false for public nets )
+        // },
+        // Useful for private networks
+        // private: {
+        // provider: () => new HDWalletProvider(mnemonic, `https://network.io`),
+        // network_id: 2111,   // This network is yours, in the cloud.
+        // production: true    // Treats this network as if it was a public net. (default: false)
+        // }
+    },
+
+    // Set default mocha options here, use special reporters etc.
+    mocha: {
+        // timeout: 100000
+    },
+
+    // Configure your compilers
+    compilers: {
+        solc: {
+            version: '0.5.9',
+            settings: {
+                evmVersion: 'istanbul',
+                optimizer: {
+                    enabled: true,
+                    runs: 1000000,
+                    details: { yul: true, deduplicate: true, cse: true, constantOptimizer: true },
+                },
+            },
+        },
+    },
+};

contracts/broker/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "extends": "../../tsconfig",
+    "compilerOptions": { "outDir": "lib", "rootDir": ".", "resolveJsonModule": true },
+    "include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*"],
+    "files": [
+        "generated-artifacts/Broker.json",
+        "generated-artifacts/GodsUnchainedValidator.json",
+        "generated-artifacts/IBroker.json",
+        "generated-artifacts/IGodsUnchained.json",
+        "generated-artifacts/IPropertyValidator.json",
+        "generated-artifacts/LibBrokerRichErrors.json",
+        "generated-artifacts/TestGodsUnchained.json",
+        "test/generated-artifacts/Broker.json",
+        "test/generated-artifacts/GodsUnchainedValidator.json",
+        "test/generated-artifacts/IBroker.json",
+        "test/generated-artifacts/IGodsUnchained.json",
+        "test/generated-artifacts/IPropertyValidator.json",
+        "test/generated-artifacts/LibBrokerRichErrors.json",
+        "test/generated-artifacts/TestGodsUnchained.json"
+    ],
+    "exclude": ["./deploy/solc/solc_bin"]
+}

contracts/broker/tslint.json

@@ -0,0 +1,6 @@
+{
+    "extends": ["@0x/tslint-config"],
+    "rules": {
+        "custom-no-magic-numbers": false
+    }
+}

contracts/broker/typedoc-tsconfig.json

@@ -0,0 +1,7 @@
+{
+    "extends": "../../typedoc-tsconfig",
+    "compilerOptions": {
+        "outDir": "lib"
+    },
+    "include": ["./src/**/*", "./test/**/*"]
+}

contracts/coordinator/CHANGELOG.json

@@ -1,4 +1,58 @@
 [
+    {
+        "timestamp": 1580988106,
+        "version": "3.0.6",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1580811564,
+        "version": "3.0.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1579682890,
+        "version": "3.0.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1578272714,
+        "version": "3.0.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1576540892,
+        "version": "3.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1575931811,
+        "version": "3.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "version": "3.0.0",
         "changes": [

contracts/coordinator/CHANGELOG.md

@@ -5,6 +5,30 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v3.0.6 - _February 6, 2020_
+
+    * Dependencies updated
+
+## v3.0.5 - _February 4, 2020_
+
+    * Dependencies updated
+
+## v3.0.4 - _January 22, 2020_
+
+    * Dependencies updated
+
+## v3.0.3 - _January 6, 2020_
+
+    * Dependencies updated
+
+## v3.0.2 - _December 17, 2019_
+
+    * Dependencies updated
+
+## v3.0.1 - _December 9, 2019_
+
+    * Dependencies updated
+
 ## v3.0.0 - _December 2, 2019_
 
     * Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils (#2330)

contracts/coordinator/compiler.json

@@ -3,7 +3,7 @@
     "contractsDir": "./contracts",
     "useDockerisedSolc": false,
     "compilerSettings": {
-        "evmVersion": "constantinople",
+        "evmVersion": "istanbul",
         "optimizer": {
             "enabled": true,
             "runs": 1000000,

contracts/coordinator/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-coordinator",
-    "version": "3.0.0",
+    "version": "3.0.6",
     "engines": {
         "node": ">=6.12"
     },
@@ -52,19 +52,19 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/extensions/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^5.0.0",
-        "@0x/contracts-asset-proxy": "^3.0.0",
-        "@0x/contracts-dev-utils": "^1.0.0",
-        "@0x/contracts-erc20": "^3.0.0",
-        "@0x/contracts-exchange": "^3.0.0",
-        "@0x/contracts-gen": "^2.0.0",
-        "@0x/contracts-test-utils": "^4.0.0",
-        "@0x/dev-utils": "^3.0.0",
-        "@0x/order-utils": "^9.0.0",
-        "@0x/sol-compiler": "^4.0.0",
+        "@0x/abi-gen": "^5.1.2",
+        "@0x/contracts-asset-proxy": "^3.1.3",
+        "@0x/contracts-dev-utils": "^1.0.6",
+        "@0x/contracts-erc20": "^3.0.6",
+        "@0x/contracts-exchange": "^3.1.2",
+        "@0x/contracts-gen": "^2.0.6",
+        "@0x/contracts-test-utils": "^5.1.3",
+        "@0x/dev-utils": "^3.1.3",
+        "@0x/order-utils": "^10.1.3",
+        "@0x/sol-compiler": "^4.0.6",
         "@0x/ts-doc-gen": "^0.0.22",
         "@0x/tslint-config": "^4.0.0",
-        "@0x/web3-wrapper": "^7.0.0",
+        "@0x/web3-wrapper": "^7.0.5",
         "@types/lodash": "4.14.104",
         "@types/mocha": "^5.2.7",
         "@types/node": "*",
@@ -84,14 +84,14 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/assert": "^3.0.0",
-        "@0x/base-contract": "^6.0.0",
-        "@0x/contract-addresses": "^4.0.0",
-        "@0x/contracts-utils": "^4.0.0",
-        "@0x/json-schemas": "^5.0.0",
-        "@0x/types": "^3.0.0",
-        "@0x/typescript-typings": "^5.0.0",
-        "@0x/utils": "^5.0.0",
+        "@0x/assert": "^3.0.5",
+        "@0x/base-contract": "^6.1.2",
+        "@0x/contract-addresses": "^4.4.0",
+        "@0x/contracts-utils": "^4.2.1",
+        "@0x/json-schemas": "^5.0.5",
+        "@0x/types": "^3.1.1",
+        "@0x/typescript-typings": "^5.0.1",
+        "@0x/utils": "^5.3.0",
         "ethereum-types": "^3.0.0",
         "http-status-codes": "^1.3.2"
     },

contracts/coordinator/src/approval_factory.ts

@@ -1,5 +1,6 @@
-import { hexConcat, signingUtils } from '@0x/contracts-test-utils';
+import { signingUtils } from '@0x/contracts-test-utils';
 import { SignatureType, SignedZeroExTransaction } from '@0x/types';
+import { hexUtils } from '@0x/utils';
 
 import { hashUtils } from './hash_utils';
 import { SignedCoordinatorApproval } from './types';
@@ -27,7 +28,7 @@ export class ApprovalFactory {
         const signedApproval = {
             txOrigin,
             transaction,
-            signature: hexConcat(signatureBuff),
+            signature: hexUtils.concat(signatureBuff),
         };
         return signedApproval;
     }

contracts/coordinator/src/hash_utils.ts

@@ -1,7 +1,6 @@
-import { hexConcat } from '@0x/contracts-test-utils';
 import { eip712Utils } from '@0x/order-utils';
 import { SignedZeroExTransaction } from '@0x/types';
-import { signTypedDataUtils } from '@0x/utils';
+import { hexUtils, signTypedDataUtils } from '@0x/utils';
 
 export const hashUtils = {
     async getApprovalHashBufferAsync(
@@ -22,7 +21,9 @@ export const hashUtils = {
         verifyingContract: string,
         txOrigin: string,
     ): Promise<string> {
-        const hashHex = hexConcat(await hashUtils.getApprovalHashBufferAsync(transaction, verifyingContract, txOrigin));
+        const hashHex = hexUtils.concat(
+            await hashUtils.getApprovalHashBufferAsync(transaction, verifyingContract, txOrigin),
+        );
         return hashHex;
     },
 };

contracts/coordinator/test/mixins.ts

@@ -4,15 +4,13 @@ import {
     constants,
     ExchangeFunctionName,
     expect,
-    hexConcat,
-    hexSlice,
     randomAddress,
     TransactionFactory,
     transactionHashUtils,
 } from '@0x/contracts-test-utils';
 import { LibBytesRevertErrors } from '@0x/contracts-utils';
 import { SignatureType, SignedOrder } from '@0x/types';
-import { BigNumber, CoordinatorRevertErrors } from '@0x/utils';
+import { BigNumber, CoordinatorRevertErrors, hexUtils } from '@0x/utils';
 
 import { ApprovalFactory } from '../src/approval_factory';
 
@@ -89,8 +87,8 @@ blockchainTests.resets('Mixins tests', env => {
         it('should revert with with the Illegal signature type', async () => {
             const data = constants.NULL_BYTES;
             const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-            transaction.signature = hexConcat(
-                hexSlice(transaction.signature, 0, transaction.signature.length - 1),
+            transaction.signature = hexUtils.concat(
+                hexUtils.slice(transaction.signature, 0, transaction.signature.length - 1),
                 SignatureType.Illegal,
             );
             const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
@@ -105,7 +103,7 @@ blockchainTests.resets('Mixins tests', env => {
         it('should revert with with the Invalid signature type', async () => {
             const data = constants.NULL_BYTES;
             const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-            transaction.signature = hexConcat(SignatureType.Invalid);
+            transaction.signature = hexUtils.concat(SignatureType.Invalid);
             const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
             expect(mixins.getSignerAddress(transactionHash, transaction.signature).callAsync()).to.revertWith(
                 new CoordinatorRevertErrors.SignatureError(
@@ -118,8 +116,8 @@ blockchainTests.resets('Mixins tests', env => {
         it('should revert with with a signature type that equals `NSignatureTypes`', async () => {
             const data = constants.NULL_BYTES;
             const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-            transaction.signature = hexConcat(
-                hexSlice(transaction.signature, 0, transaction.signature.length - 1),
+            transaction.signature = hexUtils.concat(
+                hexUtils.slice(transaction.signature, 0, transaction.signature.length - 1),
                 SignatureType.NSignatureTypes,
             );
             const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
@@ -134,8 +132,8 @@ blockchainTests.resets('Mixins tests', env => {
         it("should revert with with a signature type that isn't supported", async () => {
             const data = constants.NULL_BYTES;
             const transaction = await transactionFactory.newSignedTransactionAsync({ data });
-            transaction.signature = hexConcat(
-                hexSlice(transaction.signature, 0, transaction.signature.length - 1),
+            transaction.signature = hexUtils.concat(
+                hexUtils.slice(transaction.signature, 0, transaction.signature.length - 1),
                 SignatureType.Wallet,
             );
             const transactionHash = transactionHashUtils.getTransactionHashHex(transaction);
@@ -296,10 +294,10 @@ blockchainTests.resets('Mixins tests', env => {
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
                 const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
-                const signature = hexConcat(
-                    hexSlice(approval.signature, 0, 2),
+                const signature = hexUtils.concat(
+                    hexUtils.slice(approval.signature, 0, 2),
                     '0xFFFFFFFF',
-                    hexSlice(approval.signature, 6),
+                    hexUtils.slice(approval.signature, 6),
                 );
                 const tx = mixins
                     .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
@@ -432,10 +430,10 @@ blockchainTests.resets('Mixins tests', env => {
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
                 const approval = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
-                const signature = hexConcat(
-                    hexSlice(approval.signature, 0, 2),
+                const signature = hexUtils.concat(
+                    hexUtils.slice(approval.signature, 0, 2),
                     '0xFFFFFFFF',
-                    hexSlice(approval.signature, 6),
+                    hexUtils.slice(approval.signature, 6),
                 );
                 const tx = mixins
                     .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
@@ -454,10 +452,10 @@ blockchainTests.resets('Mixins tests', env => {
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
                 const approval1 = await approvalFactory1.newSignedApprovalAsync(transaction, transactionSignerAddress);
                 const approval2 = await approvalFactory2.newSignedApprovalAsync(transaction, transactionSignerAddress);
-                const approvalSignature2 = hexConcat(
-                    hexSlice(approval2.signature, 0, 2),
+                const approvalSignature2 = hexUtils.concat(
+                    hexUtils.slice(approval2.signature, 0, 2),
                     '0xFFFFFFFF',
-                    hexSlice(approval2.signature, 6),
+                    hexUtils.slice(approval2.signature, 6),
                 );
                 const tx = mixins
                     .assertValidCoordinatorApprovals(transaction, transactionSignerAddress, transaction.signature, [
@@ -476,10 +474,10 @@ blockchainTests.resets('Mixins tests', env => {
                 const data = exchangeDataEncoder.encodeOrdersToExchangeData(fnName, orders);
                 const transaction = await transactionFactory.newSignedTransactionAsync({ data });
                 const approval2 = await approvalFactory2.newSignedApprovalAsync(transaction, transactionSignerAddress);
-                const approvalSignature2 = hexConcat(
-                    hexSlice(approval2.signature, 0, 2),
+                const approvalSignature2 = hexUtils.concat(
+                    hexUtils.slice(approval2.signature, 0, 2),
                     '0xFFFFFFFF',
-                    hexSlice(approval2.signature, 6),
+                    hexUtils.slice(approval2.signature, 6),
                 );
                 const tx = mixins
                     .assertValidCoordinatorApprovals(transaction, approvalSignerAddress1, transaction.signature, [

contracts/coordinator/truffle-config.js

@@ -84,7 +84,7 @@ module.exports = {
         solc: {
             version: '0.5.9',
             settings: {
-                evmVersion: 'constantinople',
+                evmVersion: 'istanbul',
                 optimizer: {
                     enabled: true,
                     runs: 1000000,

contracts/dev-utils/CHANGELOG.json

@@ -1,4 +1,59 @@
 [
+    {
+        "timestamp": 1580988106,
+        "version": "1.0.6",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1580811564,
+        "version": "1.0.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1579682890,
+        "version": "1.0.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "1.0.3",
+        "changes": [
+            {
+                "note": "Fixed ERC721 duplicate token ID bug",
+                "pr": 2400
+            }
+        ],
+        "timestamp": 1578272714
+    },
+    {
+        "timestamp": 1576540892,
+        "version": "1.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1575931811,
+        "version": "1.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "version": "1.0.0",
         "changes": [

contracts/dev-utils/CHANGELOG.md

@@ -5,6 +5,30 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v1.0.6 - _February 6, 2020_
+
+    * Dependencies updated
+
+## v1.0.5 - _February 4, 2020_
+
+    * Dependencies updated
+
+## v1.0.4 - _January 22, 2020_
+
+    * Dependencies updated
+
+## v1.0.3 - _January 6, 2020_
+
+    * Fixed ERC721 duplicate token ID bug (#2400)
+
+## v1.0.2 - _December 17, 2019_
+
+    * Dependencies updated
+
+## v1.0.1 - _December 9, 2019_
+
+    * Dependencies updated
+
 ## v1.0.0 - _December 2, 2019_
 
     * Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils (#2330)

contracts/dev-utils/README.md

@@ -41,13 +41,13 @@ yarn install
 To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory:
 
 ```bash
-PKG=@0x/contracts-extensions yarn build
+PKG=@0x/contracts-dev-utils yarn build
 ```
 
 Or continuously rebuild on change:
 
 ```bash
-PKG=@0x/contracts-extensions yarn watch
+PKG=@0x/contracts-dev-utils yarn watch
 ```
 
 ### Clean

contracts/dev-utils/compiler.json

@@ -4,10 +4,10 @@
     "useDockerisedSolc": false,
     "isOfflineMode": false,
     "compilerSettings": {
-        "evmVersion": "constantinople",
+        "evmVersion": "istanbul",
         "optimizer": {
             "enabled": true,
-            "runs": 1666,
+            "runs": 5000,
             "details": { "yul": true, "deduplicate": true, "cse": true, "constantOptimizer": true }
         },
         "outputSelection": {

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

@@ -26,26 +26,33 @@ import "@0x/contracts-utils/contracts/src/LibEIP712.sol";
 import "@0x/contracts-utils/contracts/src/LibBytes.sol";
 import "./OrderValidationUtils.sol";
 import "./OrderTransferSimulationUtils.sol";
-import "./LibTransactionDecoder.sol";
 import "./EthBalanceChecker.sol";
 
 
 // solhint-disable no-empty-blocks
 contract DevUtils is
     OrderValidationUtils,
-    LibTransactionDecoder,
     LibEIP712ExchangeDomain,
-    EthBalanceChecker,
-    OrderTransferSimulationUtils
+    EthBalanceChecker
 {
-    constructor (address _exchange)
+    constructor (
+        address _exchange,
+        address _chaiBridge
+    )
         public
-        OrderValidationUtils(_exchange)
+        OrderValidationUtils(
+            _exchange,
+            _chaiBridge
+        )
         OrderTransferSimulationUtils(_exchange)
         LibEIP712ExchangeDomain(uint256(0), address(0)) // null args because because we only use constants
     {}
 
-    function getOrderHash(LibOrder.Order memory order, uint256 chainId, address exchange)
+    function getOrderHash(
+        LibOrder.Order memory order,
+        uint256 chainId,
+        address exchange
+    )
         public
         pure
         returns (bytes32 orderHash)

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

@@ -26,10 +26,14 @@ import "@0x/contracts-asset-proxy/contracts/src/interfaces/IAssetProxy.sol";
 import "@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol";
 import "@0x/contracts-erc721/contracts/src/interfaces/IERC721Token.sol";
 import "@0x/contracts-erc1155/contracts/src/interfaces/IERC1155.sol";
+import "@0x/contracts-asset-proxy/contracts/src/interfaces/IChai.sol";
+import "@0x/contracts-utils/contracts/src/DeploymentConstants.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibMath.sol";
 
 
-contract LibAssetData {
-
+contract LibAssetData is
+    DeploymentConstants
+{
     // 2^256 - 1
     uint256 constant internal _MAX_UINT256 = uint256(-1);
 
@@ -41,9 +45,13 @@ contract LibAssetData {
     address internal _ERC721_PROXY_ADDRESS;
     address internal _ERC1155_PROXY_ADDRESS;
     address internal _STATIC_CALL_PROXY_ADDRESS;
+    address internal _CHAI_BRIDGE_ADDRESS;
     // solhint-enable var-name-mixedcase
 
-    constructor (address _exchange)
+    constructor (
+        address _exchange,
+        address _chaiBridge
+    )
         public
     {
         _EXCHANGE = IExchange(_exchange);
@@ -51,6 +59,7 @@ contract LibAssetData {
         _ERC721_PROXY_ADDRESS = _EXCHANGE.getAssetProxy(IAssetData(address(0)).ERC721Token.selector);
         _ERC1155_PROXY_ADDRESS = _EXCHANGE.getAssetProxy(IAssetData(address(0)).ERC1155Assets.selector);
         _STATIC_CALL_PROXY_ADDRESS = _EXCHANGE.getAssetProxy(IAssetData(address(0)).StaticCall.selector);
+        _CHAI_BRIDGE_ADDRESS = _chaiBridge;
     }
 
     /// @dev Returns the owner's balance of the assets(s) specified in
@@ -62,7 +71,6 @@ contract LibAssetData {
     /// @return Number of assets (or asset baskets) held by owner.
     function getBalance(address ownerAddress, bytes memory assetData)
         public
-        view
         returns (uint256 balance)
     {
         // Get id of AssetProxy contract
@@ -71,16 +79,8 @@ contract LibAssetData {
         if (assetProxyId == IAssetData(address(0)).ERC20Token.selector) {
             // Get ERC20 token address
             address tokenAddress = assetData.readAddress(16);
+            balance = _erc20BalanceOf(tokenAddress, ownerAddress);
 
-            // Encode data for `balanceOf(ownerAddress)`
-            bytes memory balanceOfData = abi.encodeWithSelector(
-                IERC20Token(address(0)).balanceOf.selector,
-                ownerAddress
-            );
-
-            // Query balance
-            (bool success, bytes memory returnData) = tokenAddress.staticcall(balanceOfData);
-            balance = success && returnData.length == 32 ? returnData.readUint256(0) : 0;
         } else if (assetProxyId == IAssetData(address(0)).ERC721Token.selector) {
             // Get ERC721 token address and id
             (, address tokenAddress, uint256 tokenId) = decodeERC721AssetData(assetData);
@@ -94,12 +94,18 @@ contract LibAssetData {
             (bool success, bytes memory returnData) = tokenAddress.staticcall(ownerOfCalldata);
             address currentOwnerAddress = (success && returnData.length == 32) ? returnData.readAddress(12) : address(0);
             balance = currentOwnerAddress == ownerAddress ? 1 : 0;
+
         } else if (assetProxyId == IAssetData(address(0)).ERC1155Assets.selector) {
             // Get ERC1155 token address, array of ids, and array of values
             (, address tokenAddress, uint256[] memory tokenIds, uint256[] memory tokenValues,) = decodeERC1155AssetData(assetData);
 
             uint256 length = tokenIds.length;
             for (uint256 i = 0; i != length; i++) {
+                // Skip over the token if the corresponding value is 0.
+                if (tokenValues[i] == 0) {
+                    continue;
+                }
+
                 // Encode data for `balanceOf(ownerAddress, tokenIds[i])
                 bytes memory balanceOfData = abi.encodeWithSelector(
                     IERC1155(address(0)).balanceOf.selector,
@@ -113,10 +119,14 @@ contract LibAssetData {
 
                 // Scale total balance down by corresponding value in assetData
                 uint256 scaledBalance = totalBalance / tokenValues[i];
+                if (scaledBalance == 0) {
+                    return 0;
+                }
                 if (scaledBalance < balance || balance == 0) {
                     balance = scaledBalance;
                 }
             }
+
         } else if (assetProxyId == IAssetData(address(0)).StaticCall.selector) {
             // Encode data for `staticCallProxy.transferFrom(assetData,...)`
             bytes memory transferFromData = abi.encodeWithSelector(
@@ -132,22 +142,41 @@ contract LibAssetData {
 
             // Success means that the staticcall can be made an unlimited amount of times
             balance = success ? _MAX_UINT256 : 0;
+
+        } else if (assetProxyId == IAssetData(address(0)).ERC20Bridge.selector) {
+            // Get address of ERC20 token and bridge contract
+            (, address tokenAddress, address bridgeAddress,) = decodeERC20BridgeAssetData(assetData);
+            if (tokenAddress == _getDaiAddress() && bridgeAddress == _CHAI_BRIDGE_ADDRESS) {
+                uint256 chaiBalance = _erc20BalanceOf(_getChaiAddress(), ownerAddress);
+                // Calculate Dai balance
+                balance = _convertChaiToDaiAmount(chaiBalance);
+            }
+            // Balance will be 0 if bridge is not supported
+
         } else if (assetProxyId == IAssetData(address(0)).MultiAsset.selector) {
             // Get array of values and array of assetDatas
             (, uint256[] memory assetAmounts, bytes[] memory nestedAssetData) = decodeMultiAssetData(assetData);
 
             uint256 length = nestedAssetData.length;
             for (uint256 i = 0; i != length; i++) {
+                // Skip over the asset if the corresponding amount is 0.
+                if (assetAmounts[i] == 0) {
+                    continue;
+                }
+
                 // Query balance of individual assetData
                 uint256 totalBalance = getBalance(ownerAddress, nestedAssetData[i]);
 
                 // Scale total balance down by corresponding value in assetData
                 uint256 scaledBalance = totalBalance / assetAmounts[i];
+                if (scaledBalance == 0) {
+                    return 0;
+                }
                 if (scaledBalance < balance || balance == 0) {
                     balance = scaledBalance;
                 }
             }
-        } 
+        }
 
         // Balance will be 0 if assetProxyId is unknown
         return balance;
@@ -160,7 +189,6 @@ contract LibAssetData {
     /// corresponding to the same-indexed element in the assetData input.
     function getBatchBalances(address ownerAddress, bytes[] memory assetData)
         public
-        view
         returns (uint256[] memory balances)
     {
         uint256 length = assetData.length;
@@ -181,7 +209,6 @@ contract LibAssetData {
     /// @return Number of assets (or asset baskets) that the corresponding AssetProxy is authorized to spend.
     function getAssetProxyAllowance(address ownerAddress, bytes memory assetData)
         public
-        view
         returns (uint256 allowance)
     {
         // Get id of AssetProxy contract
@@ -193,11 +220,19 @@ contract LibAssetData {
 
             uint256 length = nestedAssetData.length;
             for (uint256 i = 0; i != length; i++) {
+                // Skip over the asset if the corresponding amount is 0.
+                if (amounts[i] == 0) {
+                    continue;
+                }
+
                 // Query allowance of individual assetData
                 uint256 totalAllowance = getAssetProxyAllowance(ownerAddress, nestedAssetData[i]);
 
                 // Scale total allowance down by corresponding value in assetData
                 uint256 scaledAllowance = totalAllowance / amounts[i];
+                if (scaledAllowance == 0) {
+                    return 0;
+                }
                 if (scaledAllowance < allowance || allowance == 0) {
                     allowance = scaledAllowance;
                 }
@@ -219,6 +254,7 @@ contract LibAssetData {
             // Query allowance
             (bool success, bytes memory returnData) = tokenAddress.staticcall(allowanceData);
             allowance = success && returnData.length == 32 ? returnData.readUint256(0) : 0;
+
         } else if (assetProxyId == IAssetData(address(0)).ERC721Token.selector) {
             // Get ERC721 token address and id
             (, address tokenAddress, uint256 tokenId) = decodeERC721AssetData(assetData);
@@ -244,6 +280,7 @@ contract LibAssetData {
                 // Allowance is 2^256 - 1 if `isApprovedForAll` returned true
                 allowance = _MAX_UINT256;
             }
+
         } else if (assetProxyId == IAssetData(address(0)).ERC1155Assets.selector) {
             // Get ERC1155 token address
             (, address tokenAddress, , , ) = decodeERC1155AssetData(assetData);
@@ -258,9 +295,26 @@ contract LibAssetData {
             // Query allowance
             (bool success, bytes memory returnData) = tokenAddress.staticcall(isApprovedForAllData);
             allowance = success && returnData.length == 32 && returnData.readUint256(0) == 1 ? _MAX_UINT256 : 0;
+
         } else if (assetProxyId == IAssetData(address(0)).StaticCall.selector) {
             // The StaticCallProxy does not require any approvals
             allowance = _MAX_UINT256;
+
+        } else if (assetProxyId == IAssetData(address(0)).ERC20Bridge.selector) {
+            // Get address of ERC20 token and bridge contract
+            (, address tokenAddress, address bridgeAddress,) = decodeERC20BridgeAssetData(assetData);
+            if (tokenAddress == _getDaiAddress() && bridgeAddress == _CHAI_BRIDGE_ADDRESS) {
+                bytes memory allowanceData = abi.encodeWithSelector(
+                    IERC20Token(address(0)).allowance.selector,
+                    ownerAddress,
+                    _CHAI_BRIDGE_ADDRESS
+                );
+                (bool success, bytes memory returnData) = _getChaiAddress().staticcall(allowanceData);
+                uint256 chaiAllowance = success && returnData.length == 32 ? returnData.readUint256(0) : 0;
+                // Dai allowance is unlimited if Chai allowance is unlimited
+                allowance = chaiAllowance == _MAX_UINT256 ? _MAX_UINT256 : _convertChaiToDaiAmount(chaiAllowance);
+            }
+            // Allowance will be 0 if bridge is not supported
         }
 
         // Allowance will be 0 if the assetProxyId is unknown
@@ -274,7 +328,6 @@ contract LibAssetData {
     /// element corresponding to the same-indexed element in the assetData input.
     function getBatchAssetProxyAllowances(address ownerAddress, bytes[] memory assetData)
         public
-        view
         returns (uint256[] memory allowances)
     {
         uint256 length = assetData.length;
@@ -292,7 +345,6 @@ contract LibAssetData {
     /// of assets (or asset baskets) that the corresponding AssetProxy is authorized to spend.
     function getBalanceAndAssetProxyAllowance(address ownerAddress, bytes memory assetData)
         public
-        view
         returns (uint256 balance, uint256 allowance)
     {
         balance = getBalance(ownerAddress, assetData);
@@ -308,7 +360,6 @@ contract LibAssetData {
     /// corresponding to the same-indexed element in the assetData input.
     function getBatchBalancesAndAssetProxyAllowances(address ownerAddress, bytes[] memory assetData)
         public
-        view
         returns (uint256[] memory balances, uint256[] memory allowances)
     {
         balances = getBatchBalances(ownerAddress, assetData);
@@ -316,7 +367,7 @@ contract LibAssetData {
         return (balances, allowances);
     }
 
-    /// @dev Decode AssetProxy identifier 
+    /// @dev Decode AssetProxy identifier
     /// @param assetData AssetProxy-compliant asset data describing an ERC-20, ERC-721, ERC1155, or MultiAsset asset.
     /// @return The AssetProxy identifier
     function decodeAssetProxyId(bytes memory assetData)
@@ -353,7 +404,7 @@ contract LibAssetData {
 
     /// @dev Decode ERC-20 asset data from the format described in the AssetProxy contract specification.
     /// @param assetData AssetProxy-compliant asset data describing an ERC-20 asset.
-    /// @return The AssetProxy identifier, and the address of the ERC-20 
+    /// @return The AssetProxy identifier, and the address of the ERC-20
     /// contract hosting this asset.
     function decodeERC20AssetData(bytes memory assetData)
         public
@@ -589,9 +640,38 @@ contract LibAssetData {
         );
     }
 
+    /// @dev Decode ERC20Bridge asset data from the format described in the AssetProxy contract specification.
+    /// @param assetData AssetProxy-compliant asset data describing an ERC20Bridge asset
+    /// @return The ERC20BridgeProxy identifier, the address of the ERC20 token to transfer, the address
+    /// of the bridge contract, and extra data to be passed to the bridge contract.
+    function decodeERC20BridgeAssetData(bytes memory assetData)
+        public
+        pure
+        returns (
+            bytes4 assetProxyId,
+            address tokenAddress,
+            address bridgeAddress,
+            bytes memory bridgeData
+        )
+    {
+        assetProxyId = assetData.readBytes4(0);
+
+        require(
+            assetProxyId == IAssetData(address(0)).ERC20Bridge.selector,
+            "WRONG_PROXY_ID"
+        );
+
+        (tokenAddress, bridgeAddress, bridgeData) = abi.decode(
+            assetData.slice(4, assetData.length),
+            (address, address, bytes)
+        );
+    }
+
+    /// @dev Reverts if assetData is not of a valid format for its given proxy id.
+    /// @param assetData AssetProxy compliant asset data.
     function revertIfInvalidAssetData(bytes memory assetData)
         public
-        pure 
+        pure
     {
         bytes4 assetProxyId = assetData.readBytes4(0);
 
@@ -605,8 +685,50 @@ contract LibAssetData {
             decodeMultiAssetData(assetData);
         } else if (assetProxyId == IAssetData(address(0)).StaticCall.selector) {
             decodeStaticCallAssetData(assetData);
+        } else if (assetProxyId == IAssetData(address(0)).ERC20Bridge.selector) {
+            decodeERC20BridgeAssetData(assetData);
         } else {
             revert("WRONG_PROXY_ID");
         }
     }
+
+    /// @dev Queries balance of an ERC20 token. Returns 0 if call was unsuccessful.
+    /// @param tokenAddress Address of ERC20 token.
+    /// @param ownerAddress Address of owner of ERC20 token.
+    /// @return balance ERC20 token balance of owner.
+    function _erc20BalanceOf(
+        address tokenAddress,
+        address ownerAddress
+    )
+        internal
+        view
+        returns (uint256 balance)
+    {
+        // Encode data for `balanceOf(ownerAddress)`
+        bytes memory balanceOfData = abi.encodeWithSelector(
+            IERC20Token(address(0)).balanceOf.selector,
+            ownerAddress
+        );
+
+        // Query balance
+        (bool success, bytes memory returnData) = tokenAddress.staticcall(balanceOfData);
+        balance = success && returnData.length == 32 ? returnData.readUint256(0) : 0;
+        return balance;
+    }
+
+    /// @dev Converts an amount of Chai into its equivalent Dai amount.
+    ///      Also accumulates Dai from DSR if called after the last time it was collected.
+    /// @param chaiAmount Amount of Chai to converts.
+    function _convertChaiToDaiAmount(uint256 chaiAmount)
+        internal
+        returns (uint256 daiAmount)
+    {
+        PotLike pot = IChai(_getChaiAddress()).pot();
+        // Accumulate savings if called after last time savings were collected
+        uint256 chiMultiplier = (now > pot.rho())
+            ? pot.drip()
+            : pot.chi();
+        daiAmount = LibMath.getPartialAmountFloor(chiMultiplier, 10**27, chaiAmount);
+        return daiAmount;
+    }
 }

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

@@ -41,6 +41,10 @@ contract OrderTransferSimulationUtils is
         TransfersSuccessful       // All transfers in the order were successful
     }
 
+    // NOTE(jalextowle): This is a random address that we use to avoid issues that addresses like `address(1)`
+    // may cause later.
+    address constant internal UNUSED_ADDRESS = address(0x377f698C4c287018D09b516F415317aEC5919332);
+
     // keccak256(abi.encodeWithSignature("Error(string)", "TRANSFERS_SUCCESSFUL"));
     bytes32 constant internal _TRANSFERS_SUCCESSFUL_RESULT_HASH = 0xf43f26ea5a94b478394a975e856464913dc1a8a1ca70939d974aa7c238aa0ce0;
 
@@ -54,6 +58,51 @@ contract OrderTransferSimulationUtils is
         _EXCHANGE = IExchange(_exchange);
     }
 
+    /// @dev Simulates the maker 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 getSimulatedOrderMakerTransferResults(
+        LibOrder.Order memory order,
+        address takerAddress,
+        uint256 takerAssetFillAmount
+    )
+        public
+        returns (OrderTransferResults orderTransferResults)
+    {
+        LibFillResults.FillResults memory fillResults = LibFillResults.calculateFillResults(
+            order,
+            takerAssetFillAmount,
+            _EXCHANGE.protocolFeeMultiplier(),
+            tx.gasprice
+        );
+
+        bytes[] memory assetData = new bytes[](2);
+        address[] memory fromAddresses = new address[](2);
+        address[] memory toAddresses = new address[](2);
+        uint256[] memory amounts = new uint256[](2);
+
+        // Transfer `makerAsset` from maker to taker
+        assetData[0] = order.makerAssetData;
+        fromAddresses[0] = order.makerAddress;
+        toAddresses[0] = takerAddress == address(0) ? UNUSED_ADDRESS : takerAddress;
+        amounts[0] = fillResults.makerAssetFilledAmount;
+
+        // Transfer `makerFeeAsset` from maker to feeRecipient
+        assetData[1] = order.makerFeeAssetData;
+        fromAddresses[1] = order.makerAddress;
+        toAddresses[1] = order.feeRecipientAddress == address(0) ? UNUSED_ADDRESS : order.feeRecipientAddress;
+        amounts[1] = fillResults.makerFeePaid;
+
+        return _simulateTransferFromCalls(
+            assetData,
+            fromAddresses,
+            toAddresses,
+            amounts
+        );
+    }
+
     /// @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.
@@ -89,21 +138,69 @@ contract OrderTransferSimulationUtils is
         // Transfer `makerAsset` from maker to taker
         assetData[1] = order.makerAssetData;
         fromAddresses[1] = order.makerAddress;
-        toAddresses[1] = takerAddress;
+        toAddresses[1] = takerAddress == address(0) ? UNUSED_ADDRESS : takerAddress;
         amounts[1] = fillResults.makerAssetFilledAmount;
 
         // Transfer `takerFeeAsset` from taker to feeRecipient
         assetData[2] = order.takerFeeAssetData;
         fromAddresses[2] = takerAddress;
-        toAddresses[2] = order.feeRecipientAddress;
+        toAddresses[2] = order.feeRecipientAddress == address(0) ? UNUSED_ADDRESS : order.feeRecipientAddress;
         amounts[2] = fillResults.takerFeePaid;
 
         // Transfer `makerFeeAsset` from maker to feeRecipient
         assetData[3] = order.makerFeeAssetData;
         fromAddresses[3] = order.makerAddress;
-        toAddresses[3] = order.feeRecipientAddress;
+        toAddresses[3] = order.feeRecipientAddress == address(0) ? UNUSED_ADDRESS : order.feeRecipientAddress;
         amounts[3] = fillResults.makerFeePaid;
 
+        return _simulateTransferFromCalls(
+            assetData,
+            fromAddresses,
+            toAddresses,
+            amounts
+        );
+    }
+
+    /// @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;
+    }
+
+    /// @dev Makes the simulation call with information about the transfers and processes
+    ///      the returndata.
+    /// @param assetData The assetdata to use to make transfers.
+    /// @param fromAddresses The addresses to transfer funds.
+    /// @param toAddresses The addresses that will receive funds
+    /// @param amounts The amounts involved in the transfer.
+    function _simulateTransferFromCalls(
+        bytes[] memory assetData,
+        address[] memory fromAddresses,
+        address[] memory toAddresses,
+        uint256[] memory amounts
+    )
+        internal
+        returns (OrderTransferResults orderTransferResults)
+    {
         // Encode data for `simulateDispatchTransferFromCalls(assetData, fromAddresses, toAddresses, amounts)`
         bytes memory simulateDispatchTransferFromCallsData = abi.encodeWithSelector(
             IExchange(address(0)).simulateDispatchTransferFromCalls.selector,
@@ -132,29 +229,4 @@ contract OrderTransferSimulationUtils is
             revert("UNKNOWN_RETURN_DATA");
         }
     }
-
-    /// @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/contracts/src/OrderValidationUtils.sol

@@ -16,7 +16,7 @@
 
 */
 
-pragma solidity ^0.5.5;
+pragma solidity ^0.5.9;
 pragma experimental ABIEncoderV2;
 
 import "@0x/contracts-exchange/contracts/src/interfaces/IExchange.sol";
@@ -25,17 +25,25 @@ import "@0x/contracts-exchange-libs/contracts/src/LibMath.sol";
 import "@0x/contracts-utils/contracts/src/LibBytes.sol";
 import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
 import "./LibAssetData.sol";
+import "./OrderTransferSimulationUtils.sol";
 
 
 contract OrderValidationUtils is
-    LibAssetData
+    LibAssetData,
+    OrderTransferSimulationUtils
 {
     using LibBytes for bytes;
     using LibSafeMath for uint256;
 
-    constructor (address _exchange)
+    constructor (
+        address _exchange,
+        address _chaiBridge
+    )
         public
-        LibAssetData(_exchange)
+        LibAssetData(
+            _exchange,
+            _chaiBridge
+        )
     {}
 
     /// @dev Fetches all order-relevant information needed to validate if the supplied order is fillable.
@@ -50,7 +58,6 @@ contract OrderValidationUtils is
     /// amount of each asset that can be filled.
     function getOrderRelevantState(LibOrder.Order memory order, bytes memory signature)
         public
-        view
         returns (
             LibOrder.OrderInfo memory orderInfo,
             uint256 fillableTakerAssetAmount,
@@ -99,7 +106,6 @@ contract OrderValidationUtils is
             } else {
                 // Get the transferable amount of the `makerFeeAsset`
                 uint256 transferableMakerFeeAssetAmount = getTransferableAssetAmount(makerAddress, order.makerFeeAssetData);
-
                 uint256 transferableMakerToTakerAmount = LibMath.getPartialAmountFloor(
                     transferableMakerAssetAmount,
                     order.makerAssetAmount,
@@ -120,6 +126,25 @@ contract OrderValidationUtils is
             transferableTakerAssetAmount
         );
 
+        // Execute the maker transfers.
+        fillableTakerAssetAmount = getSimulatedOrderMakerTransferResults(
+            order,
+            order.takerAddress,
+            fillableTakerAssetAmount
+        ) == OrderTransferResults.TransfersSuccessful ? fillableTakerAssetAmount : 0;
+
+        if (!_isAssetDataValid(order.takerAssetData)) {
+            fillableTakerAssetAmount = 0;
+        }
+
+        if (order.takerFee != 0 && !_isAssetDataValid(order.takerFeeAssetData)) {
+            fillableTakerAssetAmount = 0;
+        }
+
+        if (orderInfo.orderStatus != LibOrder.OrderStatus.FILLABLE) {
+            fillableTakerAssetAmount = 0;
+        }
+
         return (orderInfo, fillableTakerAssetAmount, isValidSignature);
     }
 
@@ -135,7 +160,6 @@ contract OrderValidationUtils is
     /// the `takerAssetData` to get the final amount of each asset that can be filled.
     function getOrderRelevantStates(LibOrder.Order[] memory orders, bytes[] memory signatures)
         public
-        view
         returns (
             LibOrder.OrderInfo[] memory ordersInfo,
             uint256[] memory fillableTakerAssetAmounts,
@@ -167,11 +191,69 @@ contract OrderValidationUtils is
     /// the individual asset amounts located within the `assetData`.
     function getTransferableAssetAmount(address ownerAddress, bytes memory assetData)
         public
-        view
         returns (uint256 transferableAssetAmount)
     {
         (uint256 balance, uint256 allowance) = getBalanceAndAssetProxyAllowance(ownerAddress, assetData);
         transferableAssetAmount = LibSafeMath.min256(balance, allowance);
         return transferableAssetAmount;
     }
+
+    /// @dev This function handles the edge cases around taker validation. This function
+    ///      currently attempts to find duplicate ERC721 token's in the taker
+    ///      multiAssetData.
+    /// @param assetData The asset data that should be validated.
+    /// @return Whether or not the order should be considered valid.
+    function _isAssetDataValid(bytes memory assetData)
+        internal
+        pure
+        returns (bool)
+    {
+        // Asset data must be composed of an asset proxy Id and a bytes segment with
+        // a length divisible by 32.
+        if (assetData.length % 32 != 4) {
+            return false;
+        }
+
+        // Only process the taker asset data if it is multiAssetData.
+        bytes4 assetProxyId = assetData.readBytes4(0);
+        if (assetProxyId != IAssetData(address(0)).MultiAsset.selector) {
+            return true;
+        }
+
+        // Get array of values and array of assetDatas
+        (, uint256[] memory assetAmounts, bytes[] memory nestedAssetData) = decodeMultiAssetData(assetData);
+
+        uint256 length = nestedAssetData.length;
+        for (uint256 i = 0; i != length; i++) {
+            // TODO(jalextowle): Implement similar validation for non-fungible ERC1155 asset data.
+            bytes4 nestedAssetProxyId = nestedAssetData[i].readBytes4(0);
+            if (nestedAssetProxyId == IAssetData(address(0)).ERC721Token.selector) {
+                if (_isAssetDataDuplicated(nestedAssetData, i)) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /// Determines whether or not asset data is duplicated later in the nested asset data.
+    /// @param nestedAssetData The asset data to scan for duplication.
+    /// @param startIdx The index where the scan should begin.
+    /// @return A boolean reflecting whether or not the starting asset data was duplicated.
+    function _isAssetDataDuplicated(
+        bytes[] memory nestedAssetData,
+        uint256 startIdx
+    )
+        internal
+        pure
+        returns (bool)
+    {
+        uint256 length = nestedAssetData.length;
+        for (uint256 i = startIdx + 1; i < length; i++) {
+            if (nestedAssetData[startIdx].equals(nestedAssetData[i])) {
+                return true;
+            }
+        }
+    }
 }

contracts/dev-utils/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-dev-utils",
-    "version": "1.0.0",
+    "version": "1.0.6",
     "engines": {
         "node": ">=6.12"
     },
@@ -8,7 +8,7 @@
     "main": "lib/src/index.js",
     "scripts": {
         "build": "yarn pre_build && tsc -b",
-        "test": "yarn assert_deployable && echo !!! Tests are run via @0x/contracts-tests !!!",
+        "test": "yarn assert_deployable && echo !!! Tests are run via @0x/contracts-integrations !!!",
         "assert_deployable": "node -e \"const bytecodeLen = (require('./generated-artifacts/DevUtils.json').compilerOutput.evm.bytecode.object.length-2)/2; assert(bytecodeLen<=0x6000,'DevUtils contract is too big to deploy, per EIP-170. '+bytecodeLen+'>'+0x6000)\"",
         "build:ci": "yarn build",
         "pre_build": "run-s compile quantify_bytecode contracts:gen generate_contract_wrappers contracts:copy",
@@ -41,10 +41,10 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/dev-utils/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^5.0.0",
-        "@0x/assert": "^3.0.0",
-        "@0x/contracts-gen": "^2.0.0",
-        "@0x/sol-compiler": "^4.0.0",
+        "@0x/abi-gen": "^5.1.2",
+        "@0x/assert": "^3.0.5",
+        "@0x/contracts-gen": "^2.0.6",
+        "@0x/sol-compiler": "^4.0.6",
         "@0x/ts-doc-gen": "^0.0.22",
         "@0x/tslint-config": "^4.0.0",
         "@types/node": "*",
@@ -59,7 +59,7 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^6.0.0"
+        "@0x/base-contract": "^6.1.2"
     },
     "publishConfig": {
         "access": "public"

contracts/dev-utils/truffle-config.js

@@ -84,7 +84,7 @@ module.exports = {
         solc: {
             version: '0.5.9',
             settings: {
-                evmVersion: 'constantinople',
+                evmVersion: 'istanbul',
                 optimizer: {
                     enabled: true,
                     runs: 1000000,

contracts/erc1155/CHANGELOG.json

@@ -1,4 +1,58 @@
 [
+    {
+        "timestamp": 1580988106,
+        "version": "2.0.6",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1580811564,
+        "version": "2.0.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1579682890,
+        "version": "2.0.4",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1578272714,
+        "version": "2.0.3",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1576540892,
+        "version": "2.0.2",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "timestamp": 1575931811,
+        "version": "2.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "version": "2.0.0",
         "changes": [

contracts/erc1155/CHANGELOG.md

@@ -5,6 +5,30 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v2.0.6 - _February 6, 2020_
+
+    * Dependencies updated
+
+## v2.0.5 - _February 4, 2020_
+
+    * Dependencies updated
+
+## v2.0.4 - _January 22, 2020_
+
+    * Dependencies updated
+
+## v2.0.3 - _January 6, 2020_
+
+    * Dependencies updated
+
+## v2.0.2 - _December 17, 2019_
+
+    * Dependencies updated
+
+## v2.0.1 - _December 9, 2019_
+
+    * Dependencies updated
+
 ## v2.0.0 - _December 2, 2019_
 
     * Drastically reduced bundle size by adding .npmignore, only exporting specific artifacts/wrappers/utils (#2330)

contracts/erc1155/compiler.json

@@ -4,7 +4,7 @@
     "useDockerisedSolc": false,
     "isOfflineMode": false,
     "compilerSettings": {
-        "evmVersion": "constantinople",
+        "evmVersion": "istanbul",
         "optimizer": {
             "enabled": true,
             "runs": 1000000,

contracts/erc1155/contracts/src/ERC1155.sol

@@ -17,6 +17,7 @@
 */
 
 pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
 
 import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
 import "@0x/contracts-utils/contracts/src/LibAddress.sol";

contracts/erc1155/contracts/src/ERC1155Mintable.sol

@@ -1,4 +1,23 @@
+/*
+
+  Copyright 2019 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.9;
+pragma experimental ABIEncoderV2;
 
 import "@0x/contracts-utils/contracts/src/LibSafeMath.sol";
 import "./ERC1155.sol";

contracts/erc1155/contracts/src/MixinNonFungibleToken.sol

@@ -17,6 +17,7 @@
 */
 
 pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
 
 
 contract MixinNonFungibleToken {
@@ -64,7 +65,7 @@ contract MixinNonFungibleToken {
         // A base type has the NF bit but does has an index.
         return (id & TYPE_NF_BIT == TYPE_NF_BIT) && (id & NF_INDEX_MASK != 0);
     }
-    
+
     /// @dev returns owner of a non-fungible token
     function ownerOf(uint256 id) public view returns (address) {
         return nfOwners[id];

contracts/erc1155/contracts/src/interfaces/IERC1155.sol

@@ -17,13 +17,14 @@
 */
 
 pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
 
 
 /// @title ERC-1155 Multi Token Standard
 /// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1155.md
 /// Note: The ERC-165 identifier for this interface is 0xd9b67a26.
 interface IERC1155 {
-    
+
     /// @dev Either TransferSingle or TransferBatch MUST emit when tokens are transferred,
     ///      including zero value transfers as well as minting or burning.
     /// Operator will always be msg.sender.

contracts/erc1155/contracts/src/interfaces/IERC1155Mintable.sol

@@ -1,4 +1,23 @@
+/*
+
+  Copyright 2019 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.9;
+pragma experimental ABIEncoderV2;
 
 import "./IERC1155.sol";
 

contracts/erc1155/contracts/src/interfaces/IERC1155Receiver.sol

@@ -17,10 +17,11 @@
 */
 
 pragma solidity ^0.5.9;
+pragma experimental ABIEncoderV2;
 
 
 interface IERC1155Receiver {
-    
+
     /// @notice Handle the receipt of a single ERC1155 token type
     /// @dev The smart contract calls this function on the recipient
     /// after a `safeTransferFrom`. This function MAY throw to revert and reject the

contracts/erc1155/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-erc1155",
-    "version": "2.0.0",
+    "version": "2.0.6",
     "engines": {
         "node": ">=6.12"
     },
@@ -52,15 +52,15 @@
     },
     "homepage": "https://github.com/0xProject/0x-monorepo/contracts/tokens/README.md",
     "devDependencies": {
-        "@0x/abi-gen": "^5.0.0",
-        "@0x/contracts-gen": "^2.0.0",
-        "@0x/contracts-utils": "^4.0.0",
-        "@0x/dev-utils": "^3.0.0",
-        "@0x/sol-compiler": "^4.0.0",
+        "@0x/abi-gen": "^5.1.2",
+        "@0x/contracts-gen": "^2.0.6",
+        "@0x/contracts-utils": "^4.2.1",
+        "@0x/dev-utils": "^3.1.3",
+        "@0x/sol-compiler": "^4.0.6",
         "@0x/ts-doc-gen": "^0.0.22",
         "@0x/tslint-config": "^4.0.0",
-        "@0x/types": "^3.0.0",
-        "@0x/typescript-typings": "^5.0.0",
+        "@0x/types": "^3.1.1",
+        "@0x/typescript-typings": "^5.0.1",
         "@types/lodash": "4.14.104",
         "@types/mocha": "^5.2.7",
         "@types/node": "*",
@@ -80,10 +80,10 @@
         "typescript": "3.0.1"
     },
     "dependencies": {
-        "@0x/base-contract": "^6.0.0",
-        "@0x/contracts-test-utils": "^4.0.0",
-        "@0x/utils": "^5.0.0",
-        "@0x/web3-wrapper": "^7.0.0",
+        "@0x/base-contract": "^6.1.2",
+        "@0x/contracts-test-utils": "^5.1.3",
+        "@0x/utils": "^5.3.0",
+        "@0x/web3-wrapper": "^7.0.5",
         "lodash": "^4.17.11"
     },
     "publishConfig": {

contracts/erc1155/src/erc1155_wrapper.ts

@@ -1,5 +1,5 @@
 import { BigNumber } from '@0x/utils';
-import { LogWithDecodedArgs, Provider, TransactionReceiptWithDecodedLogs } from 'ethereum-types';
+import { LogWithDecodedArgs, TransactionReceiptWithDecodedLogs } from 'ethereum-types';
 import * as _ from 'lodash';
 
 import { ERC1155MintableContract, ERC1155TransferSingleEventArgs } from './wrappers';
@@ -8,7 +8,7 @@ export class Erc1155Wrapper {
     private readonly _erc1155Contract: ERC1155MintableContract;
     private readonly _contractOwner: string;
 
-    constructor(contractInstance: ERC1155MintableContract, provider: Provider, contractOwner: string) {
+    constructor(contractInstance: ERC1155MintableContract, contractOwner: string) {
         this._erc1155Contract = contractInstance;
         this._contractOwner = contractOwner;
     }

contracts/erc1155/src/index.ts

@@ -5,21 +5,18 @@ export {
     IERC1155ReceiverContract,
     DummyERC1155ReceiverBatchTokenReceivedEventArgs,
     ERC1155TransferSingleEventArgs,
+    ERC1155TransferBatchEventArgs,
+    ERC1155Events,
 } from './wrappers';
 export { artifacts } from './artifacts';
 export { Erc1155Wrapper } from './erc1155_wrapper';
 export {
-    Provider,
     TransactionReceiptWithDecodedLogs,
-    JSONRPCRequestPayload,
-    JSONRPCResponsePayload,
-    JSONRPCResponseError,
-    JSONRPCErrorCallback,
     TransactionReceiptStatus,
-    ContractArtifact,
     ContractChains,
     CompilerOpts,
     StandardContractOutput,
+    ContractArtifact,
     CompilerSettings,
     ContractChainData,
     ContractAbi,

contracts/erc1155/test/erc1155_token.ts

@@ -67,7 +67,7 @@ describe('ERC1155Token', () => {
         );
         receiver = erc1155Receiver.address;
         // create wrapper & mint erc1155 tokens
-        erc1155Wrapper = new Erc1155Wrapper(erc1155Contract, provider, owner);
+        erc1155Wrapper = new Erc1155Wrapper(erc1155Contract, owner);
         fungibleToken = await erc1155Wrapper.mintFungibleTokensAsync([spender], spenderInitialFungibleBalance);
         let nonFungibleTokens: BigNumber[];
         [, nonFungibleTokens] = await erc1155Wrapper.mintNonFungibleTokensAsync([spender]);

contracts/erc1155/truffle-config.js

@@ -84,7 +84,7 @@ module.exports = {
         solc: {
             version: '0.5.9',
             settings: {
-                evmVersion: 'constantinople',
+                evmVersion: 'istanbul',
                 optimizer: {
                     enabled: true,
                     runs: 1000000,

contracts/erc20-bridge-sampler/CHANGELOG.json

@@ -1,4 +1,66 @@
 [
+    {
+        "timestamp": 1580988106,
+        "version": "1.2.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
+    {
+        "version": "1.2.0",
+        "changes": [
+            {
+                "note": "Make source IDs static on all networks, not inherited from `DeploymentConstants`.",
+                "pr": 2459
+            }
+        ],
+        "timestamp": 1580811564
+    },
+    {
+        "version": "1.1.0",
+        "changes": [
+            {
+                "note": "Add batch functions to query quotes",
+                "pr": 2427
+            },
+            {
+                "note": "Early exit if a DEX sample fails",
+                "pr": 2427
+            }
+        ],
+        "timestamp": 1579682890
+    },
+    {
+        "version": "1.0.3",
+        "changes": [
+            {
+                "note": "Add gas limits to external quote calls.",
+                "pr": 2405
+            }
+        ],
+        "timestamp": 1578272714
+    },
+    {
+        "version": "1.0.2",
+        "changes": [
+            {
+                "note": "Do not query empty/unsigned orders. Swallow revets on DEX quotes.",
+                "pr": 2395
+            }
+        ],
+        "timestamp": 1576540892
+    },
+    {
+        "timestamp": 1575931811,
+        "version": "1.0.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "version": "1.0.0",
         "changes": [

contracts/erc20-bridge-sampler/CHANGELOG.md

@@ -5,6 +5,31 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v1.2.1 - _February 6, 2020_
+
+    * Dependencies updated
+
+## v1.2.0 - _February 4, 2020_
+
+    * Make source IDs static on all networks, not inherited from `DeploymentConstants`. (#2459)
+
+## v1.1.0 - _January 22, 2020_
+
+    * Add batch functions to query quotes (#2427)
+    * Early exit if a DEX sample fails (#2427)
+
+## v1.0.3 - _January 6, 2020_
+
+    * Add gas limits to external quote calls. (#2405)
+
+## v1.0.2 - _December 17, 2019_
+
+    * Do not query empty/unsigned orders. Swallow revets on DEX quotes. (#2395)
+
+## v1.0.1 - _December 9, 2019_
+
+    * Dependencies updated
+
 ## v1.0.0 - _December 2, 2019_
 
     * Created package. (#2344)

contracts/erc20-bridge-sampler/compiler.json

@@ -4,7 +4,7 @@
     "useDockerisedSolc": false,
     "isOfflineMode": false,
     "compilerSettings": {
-        "evmVersion": "constantinople",
+        "evmVersion": "istanbul",
         "optimizer": {
             "enabled": true,
             "runs": 1000000,

contracts/erc20-bridge-sampler/contracts/src/DeploymentConstants.sol

@@ -1,92 +0,0 @@
-/*
-
-  Copyright 2019 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.9;
-pragma experimental ABIEncoderV2;
-
-import "@0x/contracts-asset-proxy/contracts/src/interfaces/IUniswapExchangeFactory.sol";
-import "@0x/contracts-exchange/contracts/src/interfaces/IExchange.sol";
-import "./IEth2Dai.sol";
-import "./IKyberNetwork.sol";
-
-
-contract DeploymentConstants {
-
-    /// @dev Address of the 0x Exchange contract.
-    address constant public EXCHANGE_ADDRESS = 0x080bf510FCbF18b91105470639e9561022937712;
-    /// @dev Address of the Eth2Dai MatchingMarket contract.
-    address constant public ETH2DAI_ADDRESS = 0x39755357759cE0d7f32dC8dC45414CCa409AE24e;
-    /// @dev Address of the UniswapExchangeFactory contract.
-    address constant public UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95;
-    /// @dev Address of the KyberNeworkProxy contract.
-    address constant public KYBER_NETWORK_PROXY_ADDRESS = 0x818E6FECD516Ecc3849DAf6845e3EC868087B755;
-    /// @dev Address of the WETH contract.
-    address constant public WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
-    /// @dev Kyber ETH pseudo-address.
-    address constant public KYBER_ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
-
-    /// @dev An overridable way to retrieve the 0x Exchange contract.
-    /// @return zeroex The 0x Exchange contract.
-    function _getExchangeContract()
-        internal
-        view
-        returns (IExchange zeroex)
-    {
-        return IExchange(EXCHANGE_ADDRESS);
-    }
-
-    /// @dev An overridable way to retrieve the Eth2Dai exchange contract.
-    /// @return eth2dai The Eth2Dai exchange contract.
-    function _getEth2DaiContract()
-        internal
-        view
-        returns (IEth2Dai eth2dai)
-    {
-        return IEth2Dai(ETH2DAI_ADDRESS);
-    }
-
-    /// @dev An overridable way to retrieve the Uniswap exchange factory contract.
-    /// @return uniswap The UniswapExchangeFactory contract.
-    function _getUniswapExchangeFactoryContract()
-        internal
-        view
-        returns (IUniswapExchangeFactory uniswap)
-    {
-        return IUniswapExchangeFactory(UNISWAP_EXCHANGE_FACTORY_ADDRESS);
-    }
-
-    /// @dev An overridable way to retrieve the Kyber network proxy contract.
-    /// @return kyber The KyberNeworkProxy contract.
-    function _getKyberNetworkContract()
-        internal
-        view
-        returns (IKyberNetwork kyber)
-    {
-        return IKyberNetwork(KYBER_NETWORK_PROXY_ADDRESS);
-    }
-
-    /// @dev An overridable way to retrieve the WETH contract address.
-    /// @return weth The WETH contract address.
-    function _getWETHAddress()
-        internal
-        view
-        returns (address weth)
-    {
-        return WETH_ADDRESS;
-    }
-}

contracts/erc20-bridge-sampler/contracts/src/ERC20BridgeSampler.sol

@@ -23,11 +23,13 @@ import "@0x/contracts-asset-proxy/contracts/src/interfaces/IUniswapExchangeFacto
 import "@0x/contracts-erc20/contracts/src/LibERC20Token.sol";
 import "@0x/contracts-exchange/contracts/src/interfaces/IExchange.sol";
 import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
+import "@0x/contracts-exchange-libs/contracts/src/LibMath.sol";
+import "@0x/contracts-utils/contracts/src/DeploymentConstants.sol";
+import "./IDevUtils.sol";
 import "./IERC20BridgeSampler.sol";
 import "./IEth2Dai.sol";
 import "./IKyberNetwork.sol";
 import "./IUniswapExchangeQuotes.sol";
-import "./DeploymentConstants.sol";
 
 
 contract ERC20BridgeSampler is
@@ -35,29 +37,105 @@ contract ERC20BridgeSampler is
     DeploymentConstants
 {
     bytes4 constant internal ERC20_PROXY_ID = 0xf47261b0; // bytes4(keccak256("ERC20Token(address)"));
+    uint256 constant internal KYBER_SAMPLE_CALL_GAS = 1500e3;
+    uint256 constant internal UNISWAP_SAMPLE_CALL_GAS = 150e3;
+    uint256 constant internal ETH2DAI_SAMPLE_CALL_GAS = 1000e3;
+    address constant private UNISWAP_SOURCE = 0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95;
+    address constant private ETH2DAI_SOURCE = 0x39755357759cE0d7f32dC8dC45414CCa409AE24e;
+    address constant private KYBER_SOURCE = 0x818E6FECD516Ecc3849DAf6845e3EC868087B755;
+
+    /// @dev Query batches of native orders and sample sell quotes on multiple DEXes at once.
+    /// @param orders Batches of Native orders to query.
+    /// @param orderSignatures Batches of Signatures for each respective order in `orders`.
+    /// @param sources Address of each DEX. Passing in an unsupported DEX will throw.
+    /// @param takerTokenAmounts Batches of Taker token sell amount for each sample.
+    /// @return ordersAndSamples How much taker asset can be filled
+    ///         by each order in `orders`. Maker amounts bought for each source at
+    ///         each taker token amount. First indexed by source index, then sample
+    ///         index.
+    function queryBatchOrdersAndSampleSells(
+        LibOrder.Order[][] memory orders,
+        bytes[][] memory orderSignatures,
+        address[] memory sources,
+        uint256[][] memory takerTokenAmounts
+    )
+        public
+        view
+        returns (
+            OrdersAndSample[] memory ordersAndSamples
+        )
+    {
+        ordersAndSamples = new OrdersAndSample[](orders.length);
+        for (uint256 i = 0; i != orders.length; i++) {
+            (
+                uint256[] memory orderFillableAssetAmounts,
+                uint256[][] memory tokenAmountsBySource
+            ) = queryOrdersAndSampleSells(orders[i], orderSignatures[i], sources, takerTokenAmounts[i]);
+            ordersAndSamples[i].orderFillableAssetAmounts = orderFillableAssetAmounts;
+            ordersAndSamples[i].tokenAmountsBySource = tokenAmountsBySource;
+        }
+    }
+
+    /// @dev Query batches of native orders and sample buy quotes on multiple DEXes at once.
+    /// @param orders Batches of Native orders to query.
+    /// @param orderSignatures Batches of Signatures for each respective order in `orders`.
+    /// @param sources Address of each DEX. Passing in an unsupported DEX will throw.
+    /// @param makerTokenAmounts Batches of Maker token sell amount for each sample.
+    /// @return ordersAndSamples How much taker asset can be filled
+    ///         by each order in `orders`. Taker amounts sold for each source at
+    ///         each maker token amount. First indexed by source index, then sample
+    ///         index.
+    function queryBatchOrdersAndSampleBuys(
+        LibOrder.Order[][] memory orders,
+        bytes[][] memory orderSignatures,
+        address[] memory sources,
+        uint256[][] memory makerTokenAmounts
+    )
+        public
+        view
+        returns (
+            OrdersAndSample[] memory ordersAndSamples
+        )
+    {
+        ordersAndSamples = new OrdersAndSample[](orders.length);
+        for (uint256 i = 0; i != orders.length; i++) {
+            (
+                uint256[] memory orderFillableAssetAmounts,
+                uint256[][] memory tokenAmountsBySource
+            ) = queryOrdersAndSampleBuys(orders[i], orderSignatures[i], sources, makerTokenAmounts[i]);
+            ordersAndSamples[i].orderFillableAssetAmounts = orderFillableAssetAmounts;
+            ordersAndSamples[i].tokenAmountsBySource = tokenAmountsBySource;
+        }
+    }
 
     /// @dev Query native orders and sample sell quotes on multiple DEXes at once.
     /// @param orders Native orders to query.
+    /// @param orderSignatures Signatures for each respective order in `orders`.
     /// @param sources Address of each DEX. Passing in an unsupported DEX will throw.
     /// @param takerTokenAmounts Taker token sell amount for each sample.
-    /// @return orderInfos `OrderInfo`s for each order in `orders`.
+    /// @return orderFillableTakerAssetAmounts How much taker asset can be filled
+    ///         by each order in `orders`.
     /// @return makerTokenAmountsBySource Maker amounts bought for each source at
     ///         each taker token amount. First indexed by source index, then sample
     ///         index.
     function queryOrdersAndSampleSells(
         LibOrder.Order[] memory orders,
+        bytes[] memory orderSignatures,
         address[] memory sources,
         uint256[] memory takerTokenAmounts
     )
         public
         view
         returns (
-            LibOrder.OrderInfo[] memory orderInfos,
+            uint256[] memory orderFillableTakerAssetAmounts,
             uint256[][] memory makerTokenAmountsBySource
         )
     {
-        require(orders.length != 0, "EMPTY_ORDERS");
-        orderInfos = queryOrders(orders);
+        require(orders.length != 0, "ERC20BridgeSampler/EMPTY_ORDERS");
+        orderFillableTakerAssetAmounts = getOrderFillableTakerAssetAmounts(
+            orders,
+            orderSignatures
+        );
         makerTokenAmountsBySource = sampleSells(
             sources,
             _assetDataToTokenAddress(orders[0].takerAssetData),
@@ -68,26 +146,32 @@ contract ERC20BridgeSampler is
 
     /// @dev Query native orders and sample buy quotes on multiple DEXes at once.
     /// @param orders Native orders to query.
+    /// @param orderSignatures Signatures for each respective order in `orders`.
     /// @param sources Address of each DEX. Passing in an unsupported DEX will throw.
     /// @param makerTokenAmounts Maker token buy amount for each sample.
-    /// @return orderInfos `OrderInfo`s for each order in `orders`.
+    /// @return orderFillableMakerAssetAmounts How much maker asset can be filled
+    ///         by each order in `orders`.
     /// @return takerTokenAmountsBySource Taker amounts sold for each source at
     ///         each maker token amount. First indexed by source index, then sample
     ///         index.
     function queryOrdersAndSampleBuys(
         LibOrder.Order[] memory orders,
+        bytes[] memory orderSignatures,
         address[] memory sources,
         uint256[] memory makerTokenAmounts
     )
         public
         view
         returns (
-            LibOrder.OrderInfo[] memory orderInfos,
+            uint256[] memory orderFillableMakerAssetAmounts,
             uint256[][] memory makerTokenAmountsBySource
         )
     {
-        require(orders.length != 0, "EMPTY_ORDERS");
-        orderInfos = queryOrders(orders);
+        require(orders.length != 0, "ERC20BridgeSampler/EMPTY_ORDERS");
+        orderFillableMakerAssetAmounts = getOrderFillableMakerAssetAmounts(
+            orders,
+            orderSignatures
+        );
         makerTokenAmountsBySource = sampleBuys(
             sources,
             _assetDataToTokenAddress(orders[0].takerAssetData),
@@ -96,18 +180,77 @@ contract ERC20BridgeSampler is
         );
     }
 
-    /// @dev Queries the status of several native orders.
+    /// @dev Queries the fillable taker asset amounts of native orders.
+    ///      Effectively ignores orders that have empty signatures or
+    /// maker/taker asset amounts (returning 0).
     /// @param orders Native orders to query.
-    /// @return orderInfos Order info for each respective order.
-    function queryOrders(LibOrder.Order[] memory orders)
+    /// @param orderSignatures Signatures for each respective order in `orders`.
+    /// @return orderFillableTakerAssetAmounts How much taker asset can be filled
+    ///         by each order in `orders`.
+    function getOrderFillableTakerAssetAmounts(
+        LibOrder.Order[] memory orders,
+        bytes[] memory orderSignatures
+    )
         public
         view
-        returns (LibOrder.OrderInfo[] memory orderInfos)
+        returns (uint256[] memory orderFillableTakerAssetAmounts)
     {
-        uint256 numOrders = orders.length;
-        orderInfos = new LibOrder.OrderInfo[](numOrders);
-        for (uint256 i = 0; i < numOrders; i++) {
-            orderInfos[i] = _getExchangeContract().getOrderInfo(orders[i]);
+        orderFillableTakerAssetAmounts = new uint256[](orders.length);
+        for (uint256 i = 0; i != orders.length; i++) {
+            // Ignore orders with no signature or empty maker/taker amounts.
+            if (orderSignatures[i].length == 0 ||
+                orders[i].makerAssetAmount == 0 ||
+                orders[i].takerAssetAmount == 0) {
+                orderFillableTakerAssetAmounts[i] = 0;
+                continue;
+            }
+            (
+                LibOrder.OrderInfo memory orderInfo,
+                uint256 fillableTakerAssetAmount,
+                bool isValidSignature
+            ) = IDevUtils(_getDevUtilsAddress()).getOrderRelevantState(
+                orders[i],
+                orderSignatures[i]
+            );
+            // The fillable amount is zero if the order is not fillable or if the
+            // signature is invalid.
+            if (orderInfo.orderStatus != LibOrder.OrderStatus.FILLABLE ||
+                !isValidSignature) {
+                orderFillableTakerAssetAmounts[i] = 0;
+            } else {
+                orderFillableTakerAssetAmounts[i] = fillableTakerAssetAmount;
+            }
+        }
+    }
+
+    /// @dev Queries the fillable taker asset amounts of native orders.
+    ///      Effectively ignores orders that have empty signatures or
+    /// @param orders Native orders to query.
+    /// @param orderSignatures Signatures for each respective order in `orders`.
+    /// @return orderFillableMakerAssetAmounts How much maker asset can be filled
+    ///         by each order in `orders`.
+    function getOrderFillableMakerAssetAmounts(
+        LibOrder.Order[] memory orders,
+        bytes[] memory orderSignatures
+    )
+        public
+        view
+        returns (uint256[] memory orderFillableMakerAssetAmounts)
+    {
+        orderFillableMakerAssetAmounts = getOrderFillableTakerAssetAmounts(
+            orders,
+            orderSignatures
+        );
+        // `orderFillableMakerAssetAmounts` now holds taker asset amounts, so
+        // convert them to maker asset amounts.
+        for (uint256 i = 0; i < orders.length; ++i) {
+            if (orderFillableMakerAssetAmounts[i] != 0) {
+                orderFillableMakerAssetAmounts[i] = LibMath.getPartialAmountCeil(
+                    orderFillableMakerAssetAmounts[i],
+                    orders[i].takerAssetAmount,
+                    orders[i].makerAssetAmount
+                );
+            }
         }
     }
 
@@ -187,18 +330,27 @@ contract ERC20BridgeSampler is
         returns (uint256[] memory makerTokenAmounts)
     {
         _assertValidPair(makerToken, takerToken);
-        address _takerToken = takerToken == _getWETHAddress() ? KYBER_ETH_ADDRESS : takerToken;
-        address _makerToken = makerToken == _getWETHAddress() ? KYBER_ETH_ADDRESS : makerToken;
+        address _takerToken = takerToken == _getWethAddress() ? KYBER_ETH_ADDRESS : takerToken;
+        address _makerToken = makerToken == _getWethAddress() ? KYBER_ETH_ADDRESS : makerToken;
         uint256 takerTokenDecimals = _getTokenDecimals(takerToken);
         uint256 makerTokenDecimals = _getTokenDecimals(makerToken);
         uint256 numSamples = takerTokenAmounts.length;
         makerTokenAmounts = new uint256[](numSamples);
         for (uint256 i = 0; i < numSamples; i++) {
-            (uint256 rate,) = _getKyberNetworkContract().getExpectedRate(
-                _takerToken,
-                _makerToken,
-                takerTokenAmounts[i]
-            );
+            (bool didSucceed, bytes memory resultData) =
+                _getKyberNetworkProxyAddress().staticcall.gas(KYBER_SAMPLE_CALL_GAS)(
+                    abi.encodeWithSelector(
+                        IKyberNetwork(0).getExpectedRate.selector,
+                        _takerToken,
+                        _makerToken,
+                        takerTokenAmounts[i]
+                    ));
+            uint256 rate = 0;
+            if (didSucceed) {
+                rate = abi.decode(resultData, (uint256));
+            } else {
+                break;
+            }
             makerTokenAmounts[i] =
                 rate *
                 takerTokenAmounts[i] *
@@ -227,11 +379,21 @@ contract ERC20BridgeSampler is
         uint256 numSamples = takerTokenAmounts.length;
         makerTokenAmounts = new uint256[](numSamples);
         for (uint256 i = 0; i < numSamples; i++) {
-            makerTokenAmounts[i] = _getEth2DaiContract().getBuyAmount(
-                makerToken,
-                takerToken,
-                takerTokenAmounts[i]
-            );
+            (bool didSucceed, bytes memory resultData) =
+                _getEth2DaiAddress().staticcall.gas(ETH2DAI_SAMPLE_CALL_GAS)(
+                    abi.encodeWithSelector(
+                        IEth2Dai(0).getBuyAmount.selector,
+                        makerToken,
+                        takerToken,
+                        takerTokenAmounts[i]
+                    ));
+            uint256 buyAmount = 0;
+            if (didSucceed) {
+                buyAmount = abi.decode(resultData, (uint256));
+            } else{
+                break;
+            }
+            makerTokenAmounts[i] = buyAmount;
         }
     }
 
@@ -254,11 +416,21 @@ contract ERC20BridgeSampler is
         uint256 numSamples = makerTokenAmounts.length;
         takerTokenAmounts = new uint256[](numSamples);
         for (uint256 i = 0; i < numSamples; i++) {
-            takerTokenAmounts[i] = _getEth2DaiContract().getPayAmount(
-                takerToken,
-                makerToken,
-                makerTokenAmounts[i]
-            );
+            (bool didSucceed, bytes memory resultData) =
+                _getEth2DaiAddress().staticcall.gas(ETH2DAI_SAMPLE_CALL_GAS)(
+                    abi.encodeWithSelector(
+                        IEth2Dai(0).getPayAmount.selector,
+                        takerToken,
+                        makerToken,
+                        makerTokenAmounts[i]
+                    ));
+            uint256 sellAmount = 0;
+            if (didSucceed) {
+                sellAmount = abi.decode(resultData, (uint256));
+            } else {
+                break;
+            }
+            takerTokenAmounts[i] = sellAmount;
         }
     }
 
@@ -280,26 +452,43 @@ contract ERC20BridgeSampler is
         _assertValidPair(makerToken, takerToken);
         uint256 numSamples = takerTokenAmounts.length;
         makerTokenAmounts = new uint256[](numSamples);
-        IUniswapExchangeQuotes takerTokenExchange = takerToken == _getWETHAddress() ?
+        IUniswapExchangeQuotes takerTokenExchange = takerToken == _getWethAddress() ?
             IUniswapExchangeQuotes(0) : _getUniswapExchange(takerToken);
-        IUniswapExchangeQuotes makerTokenExchange = makerToken == _getWETHAddress() ?
+        IUniswapExchangeQuotes makerTokenExchange = makerToken == _getWethAddress() ?
             IUniswapExchangeQuotes(0) : _getUniswapExchange(makerToken);
         for (uint256 i = 0; i < numSamples; i++) {
-            if (makerToken == _getWETHAddress()) {
-                makerTokenAmounts[i] = takerTokenExchange.getTokenToEthInputPrice(
+            bool didSucceed = true;
+            if (makerToken == _getWethAddress()) {
+                (makerTokenAmounts[i], didSucceed) = _callUniswapExchangePriceFunction(
+                    address(takerTokenExchange),
+                    takerTokenExchange.getTokenToEthInputPrice.selector,
                     takerTokenAmounts[i]
                 );
-            } else if (takerToken == _getWETHAddress()) {
-                makerTokenAmounts[i] = makerTokenExchange.getEthToTokenInputPrice(
+            } else if (takerToken == _getWethAddress()) {
+                (makerTokenAmounts[i], didSucceed) = _callUniswapExchangePriceFunction(
+                    address(makerTokenExchange),
+                    makerTokenExchange.getEthToTokenInputPrice.selector,
                     takerTokenAmounts[i]
                 );
             } else {
-                uint256 ethBought = takerTokenExchange.getTokenToEthInputPrice(
+                uint256 ethBought;
+                (ethBought, didSucceed) = _callUniswapExchangePriceFunction(
+                    address(takerTokenExchange),
+                    takerTokenExchange.getTokenToEthInputPrice.selector,
                     takerTokenAmounts[i]
                 );
-                makerTokenAmounts[i] = makerTokenExchange.getEthToTokenInputPrice(
-                    ethBought
-                );
+                if (ethBought != 0) {
+                    (makerTokenAmounts[i], didSucceed) = _callUniswapExchangePriceFunction(
+                        address(makerTokenExchange),
+                        makerTokenExchange.getEthToTokenInputPrice.selector,
+                        ethBought
+                    );
+                } else {
+                    makerTokenAmounts[i] = 0;
+                }
+            }
+            if (!didSucceed) {
+                break;
             }
         }
     }
@@ -322,26 +511,43 @@ contract ERC20BridgeSampler is
         _assertValidPair(makerToken, takerToken);
         uint256 numSamples = makerTokenAmounts.length;
         takerTokenAmounts = new uint256[](numSamples);
-        IUniswapExchangeQuotes takerTokenExchange = takerToken == _getWETHAddress() ?
+        IUniswapExchangeQuotes takerTokenExchange = takerToken == _getWethAddress() ?
             IUniswapExchangeQuotes(0) : _getUniswapExchange(takerToken);
-        IUniswapExchangeQuotes makerTokenExchange = makerToken == _getWETHAddress() ?
+        IUniswapExchangeQuotes makerTokenExchange = makerToken == _getWethAddress() ?
             IUniswapExchangeQuotes(0) : _getUniswapExchange(makerToken);
         for (uint256 i = 0; i < numSamples; i++) {
-            if (makerToken == _getWETHAddress()) {
-                takerTokenAmounts[i] = takerTokenExchange.getTokenToEthOutputPrice(
+            bool didSucceed = true;
+            if (makerToken == _getWethAddress()) {
+                (takerTokenAmounts[i], didSucceed) = _callUniswapExchangePriceFunction(
+                    address(takerTokenExchange),
+                    takerTokenExchange.getTokenToEthOutputPrice.selector,
                     makerTokenAmounts[i]
                 );
-            } else if (takerToken == _getWETHAddress()) {
-                takerTokenAmounts[i] = makerTokenExchange.getEthToTokenOutputPrice(
+            } else if (takerToken == _getWethAddress()) {
+                (takerTokenAmounts[i], didSucceed) = _callUniswapExchangePriceFunction(
+                    address(makerTokenExchange),
+                    makerTokenExchange.getEthToTokenOutputPrice.selector,
                     makerTokenAmounts[i]
                 );
             } else {
-                uint256 ethSold = makerTokenExchange.getEthToTokenOutputPrice(
+                uint256 ethSold;
+                (ethSold, didSucceed) = _callUniswapExchangePriceFunction(
+                    address(makerTokenExchange),
+                    makerTokenExchange.getEthToTokenOutputPrice.selector,
                     makerTokenAmounts[i]
                 );
-                takerTokenAmounts[i] = takerTokenExchange.getTokenToEthOutputPrice(
-                    ethSold
-                );
+                if (ethSold != 0) {
+                    (takerTokenAmounts[i], didSucceed) = _callUniswapExchangePriceFunction(
+                        address(takerTokenExchange),
+                        takerTokenExchange.getTokenToEthOutputPrice.selector,
+                        ethSold
+                    );
+                } else {
+                    takerTokenAmounts[i] = 0;
+                }
+            }
+            if (!didSucceed) {
+                break;
             }
         }
     }
@@ -357,6 +563,36 @@ contract ERC20BridgeSampler is
         return LibERC20Token.decimals(tokenAddress);
     }
 
+    /// @dev Gracefully calls a Uniswap pricing function.
+    /// @param uniswapExchangeAddress Address of an `IUniswapExchangeQuotes` exchange.
+    /// @param functionSelector Selector of the target function.
+    /// @param inputAmount Quantity parameter particular to the pricing function.
+    /// @return outputAmount The returned amount from the function call. Will be
+    ///         zero if the call fails or if `uniswapExchangeAddress` is zero.
+    function _callUniswapExchangePriceFunction(
+        address uniswapExchangeAddress,
+        bytes4 functionSelector,
+        uint256 inputAmount
+    )
+        private
+        view
+        returns (uint256 outputAmount, bool didSucceed)
+    {
+        if (uniswapExchangeAddress == address(0)) {
+            return (outputAmount, didSucceed);
+        }
+        bytes memory resultData;
+        (didSucceed, resultData) =
+            uniswapExchangeAddress.staticcall.gas(UNISWAP_SAMPLE_CALL_GAS)(
+                abi.encodeWithSelector(
+                    functionSelector,
+                    inputAmount
+                ));
+        if (didSucceed) {
+            outputAmount = abi.decode(resultData, (uint256));
+        }
+    }
+
     /// @dev Samples a supported sell source, defined by its address.
     /// @param takerToken Address of the taker token (what to sell).
     /// @param makerToken Address of the maker token (what to buy).
@@ -373,16 +609,16 @@ contract ERC20BridgeSampler is
         view
         returns (uint256[] memory makerTokenAmounts)
     {
-        if (source == address(_getEth2DaiContract())) {
+        if (source == ETH2DAI_SOURCE) {
             return sampleSellsFromEth2Dai(takerToken, makerToken, takerTokenAmounts);
         }
-        if (source == address(_getUniswapExchangeFactoryContract())) {
+        if (source == UNISWAP_SOURCE) {
             return sampleSellsFromUniswap(takerToken, makerToken, takerTokenAmounts);
         }
-        if (source == address(_getKyberNetworkContract())) {
+        if (source == KYBER_SOURCE) {
             return sampleSellsFromKyberNetwork(takerToken, makerToken, takerTokenAmounts);
         }
-        revert("UNSUPPORTED_SOURCE");
+        revert("ERC20BridgeSampler/UNSUPPORTED_SOURCE");
     }
 
     /// @dev Samples a supported buy source, defined by its address.
@@ -401,13 +637,13 @@ contract ERC20BridgeSampler is
         view
         returns (uint256[] memory takerTokenAmounts)
     {
-        if (source == address(_getEth2DaiContract())) {
+        if (source == ETH2DAI_SOURCE) {
             return sampleBuysFromEth2Dai(takerToken, makerToken, makerTokenAmounts);
         }
-        if (source == address(_getUniswapExchangeFactoryContract())) {
+        if (source == UNISWAP_SOURCE) {
             return sampleBuysFromUniswap(takerToken, makerToken, makerTokenAmounts);
         }
-        revert("UNSUPPORTED_SOURCE");
+        revert("ERC20BridgeSampler/UNSUPPORTED_SOURCE");
     }
 
     /// @dev Retrive an existing Uniswap exchange contract.
@@ -420,9 +656,9 @@ contract ERC20BridgeSampler is
         returns (IUniswapExchangeQuotes exchange)
     {
         exchange = IUniswapExchangeQuotes(
-            address(_getUniswapExchangeFactoryContract().getExchange(tokenAddress))
+            address(IUniswapExchangeFactory(_getUniswapExchangeFactoryAddress())
+            .getExchange(tokenAddress))
         );
-        require(address(exchange) != address(0), "UNSUPPORTED_UNISWAP_EXCHANGE");
     }
 
     /// @dev Extract the token address from ERC20 proxy asset data.
@@ -433,19 +669,19 @@ contract ERC20BridgeSampler is
         pure
         returns (address tokenAddress)
     {
-        require(assetData.length == 36, "INVALID_ASSET_DATA");
+        require(assetData.length == 36, "ERC20BridgeSampler/INVALID_ASSET_DATA");
         bytes4 selector;
         assembly {
             selector := and(mload(add(assetData, 0x20)), 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000)
             tokenAddress := mload(add(assetData, 0x24))
         }
-        require(selector == ERC20_PROXY_ID, "UNSUPPORTED_ASSET_PROXY");
+        require(selector == ERC20_PROXY_ID, "ERC20BridgeSampler/UNSUPPORTED_ASSET_PROXY");
     }
 
     function _assertValidPair(address makerToken, address takerToken)
         private
         pure
     {
-        require(makerToken != takerToken, "INVALID_TOKEN_PAIR");
+        require(makerToken != takerToken, "ERC20BridgeSampler/INVALID_TOKEN_PAIR");
     }
 }

contracts/erc20-bridge-sampler/contracts/src/IDevUtils.sol

@@ -0,0 +1,45 @@
+/*
+
+  Copyright 2019 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.9;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
+
+
+interface IDevUtils {
+
+    /// @dev Fetches all order-relevant information needed to validate if the supplied order is fillable.
+    /// @param order The order structure.
+    /// @param signature Signature provided by maker that proves the order's authenticity.
+    /// `0x01` can always be provided if the signature does not need to be validated.
+    /// @return The orderInfo (hash, status, and `takerAssetAmount` already filled for the given order),
+    /// fillableTakerAssetAmount (amount of the order's `takerAssetAmount` that is fillable given all on-chain state),
+    /// and isValidSignature (validity of the provided signature).
+    /// NOTE: If the `takerAssetData` encodes data for multiple assets, `fillableTakerAssetAmount` will represent a "scaled"
+    /// amount, meaning it must be multiplied by all the individual asset amounts within the `takerAssetData` to get the final
+    /// amount of each asset that can be filled.
+    function getOrderRelevantState(LibOrder.Order calldata order, bytes calldata signature)
+        external
+        view
+        returns (
+            LibOrder.OrderInfo memory orderInfo,
+            uint256 fillableTakerAssetAmount,
+            bool isValidSignature
+        );
+}

contracts/erc20-bridge-sampler/contracts/src/IERC20BridgeSampler.sol

@@ -19,59 +19,128 @@
 pragma solidity ^0.5.9;
 pragma experimental ABIEncoderV2;
 
-import "@0x/contracts-exchange/contracts/src/interfaces/IExchange.sol";
 import "@0x/contracts-exchange-libs/contracts/src/LibOrder.sol";
 
 
 interface IERC20BridgeSampler {
+    struct OrdersAndSample {
+        uint256[] orderFillableAssetAmounts;
+        uint256[][] tokenAmountsBySource;
+    }
 
-    /// @dev Query native orders and sample sell orders on multiple DEXes at once.
+    /// @dev Query batches of native orders and sample sell quotes on multiple DEXes at once.
+    /// @param orders Batches of Native orders to query.
+    /// @param orderSignatures Batches of Signatures for each respective order in `orders`.
+    /// @param sources Address of each DEX. Passing in an unsupported DEX will throw.
+    /// @param takerTokenAmounts Batches of Taker token sell amount for each sample.
+    /// @return ordersAndSamples How much taker asset can be filled
+    ///         by each order in `orders`. Maker amounts bought for each source at
+    ///         each taker token amount. First indexed by source index, then sample
+    ///         index.
+    function queryBatchOrdersAndSampleSells(
+        LibOrder.Order[][] calldata orders,
+        bytes[][] calldata orderSignatures,
+        address[] calldata sources,
+        uint256[][] calldata takerTokenAmounts
+    )
+        external
+        view
+        returns (
+            OrdersAndSample[] memory ordersAndSamples
+        );
+
+    /// @dev Query batches of native orders and sample buy quotes on multiple DEXes at once.
+    /// @param orders Batches of Native orders to query.
+    /// @param orderSignatures Batches of Signatures for each respective order in `orders`.
+    /// @param sources Address of each DEX. Passing in an unsupported DEX will throw.
+    /// @param makerTokenAmounts Batches of Maker token sell amount for each sample.
+    /// @return ordersAndSamples How much taker asset can be filled
+    ///         by each order in `orders`. Taker amounts sold for each source at
+    ///         each maker token amount. First indexed by source index, then sample
+    ///         index
+    function queryBatchOrdersAndSampleBuys(
+        LibOrder.Order[][] calldata orders,
+        bytes[][] calldata orderSignatures,
+        address[] calldata sources,
+        uint256[][] calldata makerTokenAmounts
+    )
+        external
+        view
+        returns (
+            OrdersAndSample[] memory ordersAndSamples
+        );
+
+    /// @dev Query native orders and sample sell quotes on multiple DEXes at once.
     /// @param orders Native orders to query.
-    /// @param sources Address of each DEX. Passing in an unknown DEX will throw.
-    /// @param takerTokenAmounts Taker sell amount for each sample.
-    /// @return orderInfos `OrderInfo`s for each order in `orders`.
+    /// @param orderSignatures Signatures for each respective order in `orders`.
+    /// @param sources Address of each DEX. Passing in an unsupported DEX will throw.
+    /// @param takerTokenAmounts Taker token sell amount for each sample.
+    /// @return orderFillableTakerAssetAmounts How much taker asset can be filled
+    ///         by each order in `orders`.
     /// @return makerTokenAmountsBySource Maker amounts bought for each source at
     ///         each taker token amount. First indexed by source index, then sample
     ///         index.
     function queryOrdersAndSampleSells(
         LibOrder.Order[] calldata orders,
+        bytes[] calldata orderSignatures,
         address[] calldata sources,
         uint256[] calldata takerTokenAmounts
     )
         external
         view
         returns (
-            LibOrder.OrderInfo[] memory orderInfos,
+            uint256[] memory orderFillableTakerAssetAmounts,
             uint256[][] memory makerTokenAmountsBySource
         );
 
-    /// @dev Query native orders and sample buy orders on multiple DEXes at once.
+    /// @dev Query native orders and sample buy quotes on multiple DEXes at once.
     /// @param orders Native orders to query.
-    /// @param sources Address of each DEX. Passing in an unknown DEX will throw.
-    /// @param makerTokenAmounts Maker sell amount for each sample.
-    /// @return orderInfos `OrderInfo`s for each order in `orders`.
+    /// @param orderSignatures Signatures for each respective order in `orders`.
+    /// @param sources Address of each DEX. Passing in an unsupported DEX will throw.
+    /// @param makerTokenAmounts Maker token buy amount for each sample.
+    /// @return orderFillableMakerAssetAmounts How much maker asset can be filled
+    ///         by each order in `orders`.
     /// @return takerTokenAmountsBySource Taker amounts sold for each source at
     ///         each maker token amount. First indexed by source index, then sample
     ///         index.
     function queryOrdersAndSampleBuys(
         LibOrder.Order[] calldata orders,
+        bytes[] calldata orderSignatures,
         address[] calldata sources,
         uint256[] calldata makerTokenAmounts
     )
         external
         view
         returns (
-            LibOrder.OrderInfo[] memory orderInfos,
+            uint256[] memory orderFillableMakerAssetAmounts,
             uint256[][] memory makerTokenAmountsBySource
         );
 
-    /// @dev Queries the status of several native orders.
+    /// @dev Queries the fillable taker asset amounts of native orders.
     /// @param orders Native orders to query.
-    /// @return orderInfos Order info for each respective order.
-    function queryOrders(LibOrder.Order[] calldata orders)
+    /// @param orderSignatures Signatures for each respective order in `orders`.
+    /// @return orderFillableTakerAssetAmounts How much taker asset can be filled
+    ///         by each order in `orders`.
+    function getOrderFillableTakerAssetAmounts(
+        LibOrder.Order[] calldata orders,
+        bytes[] calldata orderSignatures
+    )
         external
         view
-        returns (LibOrder.OrderInfo[] memory orderInfos);
+        returns (uint256[] memory orderFillableTakerAssetAmounts);
+
+    /// @dev Queries the fillable maker asset amounts of native orders.
+    /// @param orders Native orders to query.
+    /// @param orderSignatures Signatures for each respective order in `orders`.
+    /// @return orderFillableMakerAssetAmounts How much maker asset can be filled
+    ///         by each order in `orders`.
+    function getOrderFillableMakerAssetAmounts(
+        LibOrder.Order[] calldata orders,
+        bytes[] calldata orderSignatures
+    )
+        external
+        view
+        returns (uint256[] memory orderFillableMakerAssetAmounts);
 
     /// @dev Sample sell quotes on multiple DEXes at once.
     /// @param sources Address of each DEX. Passing in an unsupported DEX will throw.