Feature/liquidity provider sandbox

contracts/zero-ex/CHANGELOG.json

@@ -5,6 +5,18 @@
             {
                 "note": "Rewrite the ZeroEx contract in Yul",
                 "pr": 23
+            },
+            {
+                "note": "Update LiquidityProviderFeature to use off-chain registry and sandbox",
+                "pr": 16
+            },
+            {
+                "note": "Update ILiquidityProvider interface",
+                "pr": 16
+            },
+            {
+                "note": "Update ProtocolFeeUnfunded event to emit order hash",
+                "pr": 16
             }
         ]
     },

contracts/zero-ex/contracts/src/errors/LibLiquidityProviderRichErrors.sol

@@ -45,19 +45,4 @@ library LibLiquidityProviderRichErrors {
             minBuyAmount
         );
     }
-
-    function NoLiquidityProviderForMarketError(
-        address xAsset,
-        address yAsset
-    )
-        internal
-        pure
-        returns (bytes memory)
-    {
-        return abi.encodeWithSelector(
-            bytes4(keccak256("NoLiquidityProviderForMarketError(address,address)")),
-            xAsset,
-            yAsset
-        );
-    }
 }

contracts/zero-ex/contracts/src/external/ILiquidityProviderSandbox.sol

@@ -0,0 +1,74 @@
+/*
+
+  Copyright 2020 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.6.5;
+pragma experimental ABIEncoderV2;
+
+
+interface ILiquidityProviderSandbox {
+
+    /// @dev Calls `sellTokenForToken` on the given `provider` contract to
+    ///      trigger a trade.
+    /// @param provider The address of the on-chain liquidity provider.
+    /// @param inputToken The token being sold.
+    /// @param outputToken The token being bought.
+    /// @param recipient The recipient of the bought tokens.
+    /// @param minBuyAmount The minimum acceptable amount of `outputToken` to buy.
+    /// @param auxiliaryData Auxiliary data supplied to the `provider` contract.
+    function executeSellTokenForToken(
+        address provider,
+        address inputToken,
+        address outputToken,
+        address recipient,
+        uint256 minBuyAmount,
+        bytes calldata auxiliaryData
+    )
+        external;
+
+    /// @dev Calls `sellEthForToken` on the given `provider` contract to
+    ///      trigger a trade.
+    /// @param provider The address of the on-chain liquidity provider.
+    /// @param outputToken The token being bought.
+    /// @param recipient The recipient of the bought tokens.
+    /// @param minBuyAmount The minimum acceptable amount of `outputToken` to buy.
+    /// @param auxiliaryData Auxiliary data supplied to the `provider` contract.
+    function executeSellEthForToken(
+        address provider,
+        address outputToken,
+        address recipient,
+        uint256 minBuyAmount,
+        bytes calldata auxiliaryData
+    )
+        external;
+
+    /// @dev Calls `sellTokenForEth` on the given `provider` contract to
+    ///      trigger a trade.
+    /// @param provider The address of the on-chain liquidity provider.
+    /// @param inputToken The token being sold.
+    /// @param recipient The recipient of the bought tokens.
+    /// @param minBuyAmount The minimum acceptable amount of ETH to buy.
+    /// @param auxiliaryData Auxiliary data supplied to the `provider` contract.
+    function executeSellTokenForEth(
+        address provider,
+        address inputToken,
+        address recipient,
+        uint256 minBuyAmount,
+        bytes calldata auxiliaryData
+    )
+        external;
+}

contracts/zero-ex/contracts/src/external/LiquidityProviderSandbox.sol

@@ -0,0 +1,139 @@
+/*
+  Copyright 2020 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.6.5;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-utils/contracts/src/v06/errors/LibRichErrorsV06.sol";
+import "@0x/contracts-utils/contracts/src/v06/errors/LibOwnableRichErrorsV06.sol";
+import "../vendor/ILiquidityProvider.sol";
+import "../vendor/v3/IERC20Bridge.sol";
+import "./ILiquidityProviderSandbox.sol";
+
+
+/// @dev A permissionless contract through which the ZeroEx contract can
+///      safely trigger a trade on an external `ILiquidityProvider` contract.
+contract LiquidityProviderSandbox is
+    ILiquidityProviderSandbox
+{
+    using LibRichErrorsV06 for bytes;
+
+    /// @dev Store the owner as an immutable.
+    address public immutable owner;
+
+    constructor(address owner_)
+        public
+    {
+        owner = owner_;
+    }
+
+    /// @dev Allows only the (immutable) owner to call a function.
+    modifier onlyOwner() virtual {
+        if (msg.sender != owner) {
+            LibOwnableRichErrorsV06.OnlyOwnerError(
+                msg.sender,
+                owner
+            ).rrevert();
+        }
+        _;
+    }
+
+    /// @dev Calls `sellTokenForToken` on the given `provider` contract to
+    ///      trigger a trade.
+    /// @param provider The address of the on-chain liquidity provider.
+    /// @param inputToken The token being sold.
+    /// @param outputToken The token being bought.
+    /// @param recipient The recipient of the bought tokens.
+    /// @param minBuyAmount The minimum acceptable amount of `outputToken` to buy.
+    /// @param auxiliaryData Auxiliary data supplied to the `provider` contract.
+    function executeSellTokenForToken(
+        address provider,
+        address inputToken,
+        address outputToken,
+        address recipient,
+        uint256 minBuyAmount,
+        bytes calldata auxiliaryData
+    )
+        external
+        onlyOwner
+        override
+    {
+        try ILiquidityProvider(provider).sellTokenForToken(
+            inputToken,
+            outputToken,
+            recipient,
+            minBuyAmount,
+            auxiliaryData
+        ) {} catch {
+            IERC20Bridge(provider).bridgeTransferFrom(
+                outputToken,
+                provider,
+                recipient,
+                minBuyAmount,
+                auxiliaryData
+            );
+        }
+    }
+
+    /// @dev Calls `sellEthForToken` on the given `provider` contract to
+    ///      trigger a trade.
+    /// @param provider The address of the on-chain liquidity provider.
+    /// @param outputToken The token being bought.
+    /// @param recipient The recipient of the bought tokens.
+    /// @param minBuyAmount The minimum acceptable amount of `outputToken` to buy.
+    /// @param auxiliaryData Auxiliary data supplied to the `provider` contract.
+    function executeSellEthForToken(
+        address provider,
+        address outputToken,
+        address recipient,
+        uint256 minBuyAmount,
+        bytes calldata auxiliaryData
+    )
+        external
+        onlyOwner
+        override
+    {
+        ILiquidityProvider(provider).sellEthForToken(
+            outputToken,
+            recipient,
+            minBuyAmount,
+            auxiliaryData
+        );
+    }
+
+    /// @dev Calls `sellTokenForEth` on the given `provider` contract to
+    ///      trigger a trade.
+    /// @param provider The address of the on-chain liquidity provider.
+    /// @param inputToken The token being sold.
+    /// @param recipient The recipient of the bought tokens.
+    /// @param minBuyAmount The minimum acceptable amount of ETH to buy.
+    /// @param auxiliaryData Auxiliary data supplied to the `provider` contract.
+    function executeSellTokenForEth(
+        address provider,
+        address inputToken,
+        address recipient,
+        uint256 minBuyAmount,
+        bytes calldata auxiliaryData
+    )
+        external
+        onlyOwner
+        override
+    {
+        ILiquidityProvider(provider).sellTokenForEth(
+            inputToken,
+            payable(recipient),
+            minBuyAmount,
+            auxiliaryData
+        );
+    }
+}

contracts/zero-ex/contracts/src/features/ILiquidityProviderFeature.sol

@@ -22,45 +22,30 @@ pragma experimental ABIEncoderV2;
 
 /// @dev Feature to swap directly with an on-chain liquidity provider.
 interface ILiquidityProviderFeature {
-    event LiquidityProviderForMarketUpdated(
-        address indexed xAsset,
-        address indexed yAsset,
-        address providerAddress
-    );
 
+    /// @dev Sells `sellAmount` of `inputToken` to the liquidity provider
+    ///      at the given `provider` address.
+    /// @param inputToken The token being sold.
+    /// @param outputToken The token being bought.
+    /// @param provider The address of the on-chain liquidity provider
+    ///        to trade with.
+    /// @param recipient The recipient of the bought tokens. If equal to
+    ///        address(0), `msg.sender` is assumed to be the recipient.
+    /// @param sellAmount The amount of `inputToken` to sell.
+    /// @param minBuyAmount The minimum acceptable amount of `outputToken` to
+    ///        buy. Reverts if this amount is not satisfied.
+    /// @param auxiliaryData Auxiliary data supplied to the `provider` contract.
+    /// @return boughtAmount The amount of `outputToken` bought.
     function sellToLiquidityProvider(
-        address makerToken,
-        address takerToken,
-        address payable recipient,
+        address inputToken,
+        address outputToken,
+        address payable provider,
+        address recipient,
         uint256 sellAmount,
-        uint256 minBuyAmount
+        uint256 minBuyAmount,
+        bytes calldata auxiliaryData
     )
         external
         payable
         returns (uint256 boughtAmount);
-
-    /// @dev Sets address of the liquidity provider for a market given
-    ///      (xAsset, yAsset).
-    /// @param xAsset First asset managed by the liquidity provider.
-    /// @param yAsset Second asset managed by the liquidity provider.
-    /// @param providerAddress Address of the liquidity provider.
-    function setLiquidityProviderForMarket(
-        address xAsset,
-        address yAsset,
-        address providerAddress
-    )
-        external;
-
-    /// @dev Returns the address of the liquidity provider for a market given
-    ///     (xAsset, yAsset), or reverts if pool does not exist.
-    /// @param xAsset First asset managed by the liquidity provider.
-    /// @param yAsset Second asset managed by the liquidity provider.
-    /// @return providerAddress Address of the liquidity provider.
-    function getLiquidityProviderForMarket(
-        address xAsset,
-        address yAsset
-    )
-        external
-        view
-        returns (address providerAddress);
 }