foundry test

packages/asset-swapper/.gitignore

@@ -1,2 +1,4 @@
 **/generated-artifacts
 **/generated-wrappers
+cache
+out

packages/asset-swapper/contracts/src/ApproximateBuys.sol

@@ -20,8 +20,6 @@
 pragma solidity ^0.6;
 pragma experimental ABIEncoderV2;
 
-import "@0x/contracts-utils/contracts/src/v06/LibMathV06.sol";
-
 
 contract ApproximateBuys {
 

packages/asset-swapper/contracts/src/CompoundSampler.sol

@@ -21,7 +21,7 @@ pragma solidity ^0.6;
 pragma experimental ABIEncoderV2;
 
 import "./SamplerUtils.sol";
-import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
+import "./interfaces/IERC20TokenV06.sol";
 import "./SamplerBase.sol";
 
 // Minimal CToken interface

packages/asset-swapper/contracts/src/LibBytes.sol

@@ -0,0 +1,66 @@
+/*
+
+  Copyright 2022 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;
+
+library LibBytes {
+
+    using LibBytes for bytes;
+
+    /// @dev Reads a uint256 value from a position in a byte array.
+    /// @param b Byte array containing a uint256 value.
+    /// @param index Index in byte array of uint256 value.
+    /// @return result value from byte array.
+    function readUint256(
+        bytes memory b,
+        uint256 index
+    )
+        internal
+        pure
+        returns (uint256 result)
+    {
+        result = uint256(readBytes32(b, index));
+        return result;
+    }
+
+    /// @dev Reads a bytes32 value from a position in a byte array.
+    /// @param b Byte array containing a bytes32 value.
+    /// @param index Index in byte array of bytes32 value.
+    /// @return result bytes32 value from byte array.
+    function readBytes32(
+        bytes memory b,
+        uint256 index
+    )
+        internal
+        pure
+        returns (bytes32 result)
+    {
+        if (b.length < index + 32) {
+            revert("Invalid bytes32 index");
+        }
+
+        // Arrays are prefixed by a 256 bit length parameter
+        index += 32;
+
+        // Read the bytes32 from array memory
+        assembly {
+            result := mload(add(b, index))
+        }
+        return result;
+    }
+}

packages/asset-swapper/contracts/src/LibSafeMath.sol

@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2022 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;
+
+library LibSafeMath {
+    using LibSafeMath for uint256;
+
+    function safeMul(uint256 a, uint256 b)
+        internal
+        pure
+        returns (uint256)
+    {
+        if (a == 0) {
+            return 0;
+        }
+        uint256 c = a * b;
+        if (c / a != b) {
+            revert("SafeMath: multiplication overflow");
+        }
+        return c;
+    }
+
+    function safeDiv(uint256 a, uint256 b)
+        internal
+        pure
+        returns (uint256)
+    {
+        if (b == 0) {
+            revert("SafeMath: division by 0");
+        }
+        uint256 c = a / b;
+        return c;
+    }
+
+    function safeSub(uint256 a, uint256 b)
+        internal
+        pure
+        returns (uint256)
+    {
+        if (b > a) {
+            revert("SafeMath: subtraction underflow");
+        }
+        return a - b;
+    }
+
+    function safeAdd(uint256 a, uint256 b)
+        internal
+        pure
+        returns (uint256)
+    {
+        uint256 c = a + b;
+        if (c < a) {
+            revert("SafeMath: addition overflow");
+        }
+        return c;
+    }
+
+    function max256(uint256 a, uint256 b)
+        internal
+        pure
+        returns (uint256)
+    {
+        return a >= b ? a : b;
+    }
+
+    function min256(uint256 a, uint256 b)
+        internal
+        pure
+        returns (uint256)
+    {
+        return a < b ? a : b;
+    }
+
+    function safeMul128(uint128 a, uint128 b)
+        internal
+        pure
+        returns (uint128)
+    {
+        if (a == 0) {
+            return 0;
+        }
+        uint128 c = a * b;
+        if (c / a != b) {
+            revert("SafeMath: multiplication overflow");
+        }
+        return c;
+    }
+
+    function safeDiv128(uint128 a, uint128 b)
+        internal
+        pure
+        returns (uint128)
+    {
+        if (b == 0) {
+            revert("SafeMath: division by 0");
+        }
+        uint128 c = a / b;
+        return c;
+    }
+
+    function safeSub128(uint128 a, uint128 b)
+        internal
+        pure
+        returns (uint128)
+    {
+        if (b > a) {
+            revert("SafeMath: subtraction underflow");
+        }
+        return a - b;
+    }
+
+    function safeAdd128(uint128 a, uint128 b)
+        internal
+        pure
+        returns (uint128)
+    {
+        uint128 c = a + b;
+        if (c < a) {
+            revert("SafeMath: addition overflow");
+        }
+        return c;
+    }
+
+    function max128(uint128 a, uint128 b)
+        internal
+        pure
+        returns (uint128)
+    {
+        return a >= b ? a : b;
+    }
+
+    function min128(uint128 a, uint128 b)
+        internal
+        pure
+        returns (uint128)
+    {
+        return a < b ? a : b;
+    }
+
+    function safeDowncastToUint128(uint256 a)
+        internal
+        pure
+        returns (uint128)
+    {
+        if (a > type(uint128).max) {
+            revert("SafeMath: cannot downcast uint256 to uint128");
+        }
+        return uint128(a);
+    }
+
+    function getPartialAmountCeil(
+        uint256 numerator,
+        uint256 denominator,
+        uint256 target
+    )
+        internal
+        pure
+        returns (uint256 partialAmount)
+    {
+        // safeDiv computes `floor(a / b)`. We use the identity (a, b integer):
+        //       ceil(a / b) = floor((a + b - 1) / b)
+        // To implement `ceil(a / b)` using safeDiv.
+        partialAmount = numerator.safeMul(target)
+            .safeAdd(denominator.safeSub(1))
+            .safeDiv(denominator);
+
+        return partialAmount;
+    }
+
+    function getPartialAmountFloor(
+        uint256 numerator,
+        uint256 denominator,
+        uint256 target
+    )
+        internal
+        pure
+        returns (uint256 partialAmount)
+    {
+        partialAmount = numerator.safeMul(target).safeDiv(denominator);
+        return partialAmount;
+    }
+}

packages/asset-swapper/contracts/src/LiquidityProviderSampler.sol

@@ -20,8 +20,7 @@
 pragma solidity ^0.6;
 pragma experimental ABIEncoderV2;
 
-import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
-import "@0x/contracts-zero-ex/contracts/src/vendor/ILiquidityProvider.sol";
+import "./interfaces/ILiquidityProvider.sol";
 import "./ApproximateBuys.sol";
 import "./SamplerUtils.sol";
 import "./SamplerBase.sol";

packages/asset-swapper/contracts/src/MakerPSMSampler.sol

@@ -21,7 +21,7 @@ pragma solidity ^0.6;
 pragma experimental ABIEncoderV2;
 
 import "./SamplerUtils.sol";
-import "@0x/contracts-utils/contracts/src/v06/LibMathV06.sol";
+import "./LibSafeMath.sol";
 import "./SamplerBase.sol";
 
 interface IPSM {
@@ -84,7 +84,7 @@ contract MakerPSMSampler is
     SamplerBase,
     SamplerUtils
 {
-    using LibSafeMathV06 for uint256;
+    using LibSafeMath for uint256;
 
     /// @dev Information about which PSM module to use
     struct MakerPsmInfo {

packages/asset-swapper/contracts/src/NativeOrderSampler.sol

@@ -20,11 +20,8 @@
 pragma solidity ^0.6;
 pragma experimental ABIEncoderV2;
 
-import "@0x/contracts-erc20/contracts/src/v06/LibERC20TokenV06.sol";
-import "@0x/contracts-utils/contracts/src/v06/LibMathV06.sol";
-import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
-import "@0x/contracts-utils/contracts/src/v06/LibSafeMathV06.sol";
-
+import "./interfaces/IERC20TokenV06.sol";
+import "./LibSafeMath.sol";
 
 interface IExchange {
 
@@ -123,8 +120,8 @@ interface IExchange {
 }
 
 contract NativeOrderSampler {
-    using LibSafeMathV06 for uint256;
-    using LibBytesV06 for bytes;
+    using LibSafeMath for uint256;
+    // using LibBytesV06 for bytes;
 
     /// @dev Gas limit for calls to `getOrderFillableTakerAmount()`.
     uint256 constant internal DEFAULT_CALL_GAS = 200e3; // 200k
@@ -191,7 +188,7 @@ contract NativeOrderSampler {
         // convert them to maker asset amounts.
         for (uint256 i = 0; i < orders.length; ++i) {
             if (orderFillableMakerAssetAmounts[i] != 0) {
-                orderFillableMakerAssetAmounts[i] = LibMathV06.getPartialAmountCeil(
+                orderFillableMakerAssetAmounts[i] = LibSafeMath.getPartialAmountCeil(
                     orderFillableMakerAssetAmounts[i],
                     orders[i].takerAmount,
                     orders[i].makerAmount

packages/asset-swapper/contracts/src/SamplerUtils.sol

@@ -20,7 +20,7 @@
 pragma solidity ^0.6;
 pragma experimental ABIEncoderV2;
 
-import "@0x/contracts-erc20/contracts/src/v06/LibERC20TokenV06.sol";
+import "./interfaces/IERC20TokenV06.sol";
 
 
 contract SamplerUtils {
@@ -34,7 +34,7 @@ contract SamplerUtils {
         view
         returns (uint8 decimals)
     {
-        return LibERC20TokenV06.compatDecimals(IERC20TokenV06(tokenAddress));
+        return IERC20TokenV06(tokenAddress).decimals();
     }
 
     function _toSingleValueArray(uint256 v)

packages/asset-swapper/contracts/src/TwoHopSampler.sol

@@ -20,14 +20,14 @@
 pragma solidity ^0.6;
 pragma experimental ABIEncoderV2;
 
-import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
+import "./LibBytes.sol";
 import "./SamplerBase.sol";
 
 
 contract TwoHopSampler is
     SamplerBase
 {
-    using LibBytesV06 for bytes;
+    using LibBytes for bytes;
 
     struct HopInfo {
         uint256 sourceIndex;

packages/asset-swapper/contracts/src/UniswapV3Sampler.sol

@@ -20,7 +20,7 @@
 pragma solidity ^0.6;
 pragma experimental ABIEncoderV2;
 
-import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
+import "./interfaces/IERC20TokenV06.sol";
 import "./SamplerBase.sol";
 
 interface IUniswapV3Quoter {

packages/asset-swapper/contracts/src/UtilitySampler.sol

@@ -21,12 +21,10 @@
 pragma solidity ^0.6;
 pragma experimental ABIEncoderV2;
 
-import "@0x/contracts-erc20/contracts/src/v06/LibERC20TokenV06.sol";
+import "./interfaces/IERC20TokenV06.sol";
 
 contract UtilitySampler {
 
-    using LibERC20TokenV06 for IERC20TokenV06;
-
     IERC20TokenV06 private immutable UTILITY_ETH_ADDRESS = IERC20TokenV06(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
 
     function getTokenDecimals(IERC20TokenV06[] memory tokens)
@@ -38,7 +36,7 @@ contract UtilitySampler {
         for (uint256 i = 0; i != tokens.length; i++) {
             decimals[i] = tokens[i] == UTILITY_ETH_ADDRESS
                 ? 18
-                : tokens[i].compatDecimals();
+                : tokens[i].decimals();
         }
     }
 
@@ -51,7 +49,7 @@ contract UtilitySampler {
         for (uint256 i = 0; i != tokens.length; i++) {
             balances[i] = tokens[i] == UTILITY_ETH_ADDRESS
                 ? account.balance
-                : tokens[i].compatBalanceOf(account);
+                : tokens[i].balanceOf(account);
         }
     }
 
@@ -64,7 +62,7 @@ contract UtilitySampler {
         for (uint256 i = 0; i != tokens.length; i++) {
             allowances[i] = tokens[i] == UTILITY_ETH_ADDRESS
                 ? 0
-                : tokens[i].compatAllowance(account, spender);
+                : tokens[i].allowance(account, spender);
         }
     }
 

packages/asset-swapper/contracts/src/interfaces/IERC20TokenV06.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2022 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;
+
+
+interface IERC20TokenV06 {
+
+    // solhint-disable no-simple-event-func-name
+    event Transfer(
+        address indexed from,
+        address indexed to,
+        uint256 value
+    );
+
+    event Approval(
+        address indexed owner,
+        address indexed spender,
+        uint256 value
+    );
+
+    /// @dev send `value` token to `to` from `msg.sender`
+    /// @param to The address of the recipient
+    /// @param value The amount of token to be transferred
+    /// @return True if transfer was successful
+    function transfer(address to, uint256 value)
+        external
+        returns (bool);
+
+    /// @dev send `value` token to `to` from `from` on the condition it is approved by `from`
+    /// @param from The address of the sender
+    /// @param to The address of the recipient
+    /// @param value The amount of token to be transferred
+    /// @return True if transfer was successful
+    function transferFrom(
+        address from,
+        address to,
+        uint256 value
+    )
+        external
+        returns (bool);
+
+    /// @dev `msg.sender` approves `spender` to spend `value` tokens
+    /// @param spender The address of the account able to transfer the tokens
+    /// @param value The amount of wei to be approved for transfer
+    /// @return Always true if the call has enough gas to complete execution
+    function approve(address spender, uint256 value)
+        external
+        returns (bool);
+
+    /// @dev Query total supply of token
+    /// @return Total supply of token
+    function totalSupply()
+        external
+        view
+        returns (uint256);
+
+    /// @dev Get the balance of `owner`.
+    /// @param owner The address from which the balance will be retrieved
+    /// @return Balance of owner
+    function balanceOf(address owner)
+        external
+        view
+        returns (uint256);
+
+    /// @dev Get the allowance for `spender` to spend from `owner`.
+    /// @param owner The address of the account owning tokens
+    /// @param spender The address of the account able to transfer the tokens
+    /// @return Amount of remaining tokens allowed to spent
+    function allowance(address owner, address spender)
+        external
+        view
+        returns (uint256);
+
+    /// @dev Get the number of decimals this token has.
+    function decimals()
+        external
+        view
+        returns (uint8);
+}

packages/asset-swapper/contracts/src/interfaces/ILiquidityProvider.sol

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2022 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;
+
+import "./IERC20TokenV06.sol";
+
+
+interface ILiquidityProvider {
+
+    /// @dev An optional event an LP can emit for each fill against a source.
+    /// @param inputToken The input token.
+    /// @param outputToken The output token.
+    /// @param inputTokenAmount How much input token was sold.
+    /// @param outputTokenAmount How much output token was bought.
+    /// @param sourceId A bytes32 encoded ascii source ID. E.g., `bytes32('Curve')`/
+    /// @param sourceAddress An optional address associated with the source (e.g, a curve pool).
+    /// @param sourceId A bytes32 encoded ascii source ID. E.g., `bytes32('Curve')`/
+    /// @param sourceAddress An optional address associated with the source (e.g, a curve pool).
+    /// @param sender The caller of the LP.
+    /// @param recipient The recipient of the output tokens.
+    event LiquidityProviderFill(
+        IERC20TokenV06 inputToken,
+        IERC20TokenV06 outputToken,
+        uint256 inputTokenAmount,
+        uint256 outputTokenAmount,
+        bytes32 sourceId,
+        address sourceAddress,
+        address sender,
+        address recipient
+    );
+
+    /// @dev Trades `inputToken` for `outputToken`. The amount of `inputToken`
+    ///      to sell must be transferred to the contract prior to calling this
+    ///      function to trigger the trade.
+    /// @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 Arbitrary auxiliary data supplied to the contract.
+    /// @return boughtAmount The amount of `outputToken` bought.
+    function sellTokenForToken(
+        IERC20TokenV06 inputToken,
+        IERC20TokenV06 outputToken,
+        address recipient,
+        uint256 minBuyAmount,
+        bytes calldata auxiliaryData
+    )
+        external
+        returns (uint256 boughtAmount);
+
+    /// @dev Trades ETH for token. ETH must either be attached to this function
+    ///      call or sent to the contract prior to calling this function to
+    ///      trigger the trade.
+    /// @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 Arbitrary auxiliary data supplied to the contract.
+    /// @return boughtAmount The amount of `outputToken` bought.
+    function sellEthForToken(
+        IERC20TokenV06 outputToken,
+        address recipient,
+        uint256 minBuyAmount,
+        bytes calldata auxiliaryData
+    )
+        external
+        payable
+        returns (uint256 boughtAmount);
+
+    /// @dev Trades token for ETH. The token must be sent to the contract prior
+    ///      to calling this function to trigger the trade.
+    /// @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 Arbitrary auxiliary data supplied to the contract.
+    /// @return boughtAmount The amount of ETH bought.
+    function sellTokenForEth(
+        IERC20TokenV06 inputToken,
+        address payable recipient,
+        uint256 minBuyAmount,
+        bytes calldata auxiliaryData
+    )
+        external
+        returns (uint256 boughtAmount);
+
+    /// @dev Quotes the amount of `outputToken` that would be obtained by
+    ///      selling `sellAmount` of `inputToken`.
+    /// @param inputToken Address of the taker token (what to sell). Use
+    ///        the wETH address if selling ETH.
+    /// @param outputToken Address of the maker token (what to buy). Use
+    ///        the wETH address if buying ETH.
+    /// @param sellAmount Amount of `inputToken` to sell.
+    /// @return outputTokenAmount Amount of `outputToken` that would be obtained.
+    function getSellQuote(
+        IERC20TokenV06 inputToken,
+        IERC20TokenV06 outputToken,
+        uint256 sellAmount
+    )
+        external
+        view
+        returns (uint256 outputTokenAmount);
+}

packages/asset-swapper/contracts/src/test/TestBase.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.6;
+
+import "../../lib/ds-test/src/test.sol";
+
+contract TestBase is 
+    DSTest
+{
+    function _toSingleValueArray(uint256 v)
+        internal
+        pure
+        returns (uint256[] memory arr)
+    {
+        arr = new uint256[](1);
+        arr[0] = v;
+    }
+}

packages/asset-swapper/contracts/src/test/UniswapV2Sampler.t.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.6;
+
+import "./TestBase.sol";
+import "../ERC20BridgeSampler.sol";
+
+contract UniswapV2SamplerTest is
+    TestBase 
+{
+    ERC20BridgeSampler sampler;
+
+    function setUp() public {
+        sampler = new ERC20BridgeSampler();
+        sampler.setSampleValues(_toSingleValueArray(1e18));
+    }
+
+    function testUniswapV2Sell()
+        public
+    {
+        address router = 0xf164fC0Ec4E93095b804a4795bBe1e041497b92a;
+        address weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+        address usdc = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
+        address[] memory path = new address[](2);
+        path[0] = weth;
+        path[1] = usdc;
+        uint256[] memory values = sampler.sampleSellsFromUniswapV2Global(
+            router,
+            path
+        );
+
+        assertGt(values[0], 0);
+    }
+}

packages/asset-swapper/contracts/test/DummyLiquidityProvider.sol

@@ -1,39 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.6;
-pragma experimental ABIEncoderV2;
-
-
-contract DummyLiquidityProvider
-{
-    /// @dev Quotes the amount of `makerToken` that would be obtained by
-    ///      selling `sellAmount` of `takerToken`.
-    /// @param sellAmount Amount of `takerToken` to sell.
-    /// @return makerTokenAmount Amount of `makerToken` that would be obtained.
-    function getSellQuote(
-        address, /* takerToken */
-        address, /* makerToken */
-        uint256 sellAmount
-    )
-        external
-        view
-        returns (uint256 makerTokenAmount)
-    {
-        makerTokenAmount = sellAmount - 1;
-    }
-
-    /// @dev Quotes the amount of `takerToken` that would need to be sold in
-    ///      order to obtain `buyAmount` of `makerToken`.
-    /// @param buyAmount Amount of `makerToken` to buy.
-    /// @return takerTokenAmount Amount of `takerToken` that would need to be sold.
-    function getBuyQuote(
-        address, /* takerToken */
-        address, /* makerToken */
-        uint256 buyAmount
-    )
-        external
-        view
-        returns (uint256 takerTokenAmount)
-    {
-        takerTokenAmount = buyAmount + 1;
-    }
-}

packages/asset-swapper/contracts/test/TestERC20BridgeSampler.sol

@@ -1,455 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
-
-  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;
-pragma experimental ABIEncoderV2;
-
-import "../src/ERC20BridgeSampler.sol";
-import "../src/interfaces/IKyberNetwork.sol";
-import "../src/interfaces/IUniswapV2Router01.sol";
-
-
-library LibDeterministicQuotes {
-
-    address private constant WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
-    uint256 private constant RATE_DENOMINATOR = 1 ether;
-    uint256 private constant MIN_RATE = RATE_DENOMINATOR / 100;
-    uint256 private constant MAX_RATE = 100 * RATE_DENOMINATOR;
-    uint8 private constant MIN_DECIMALS = 4;
-    uint8 private constant MAX_DECIMALS = 20;
-
-    function getDeterministicSellQuote(
-        bytes32 salt,
-        address sellToken,
-        address buyToken,
-        uint256 sellAmount
-    )
-        internal
-        pure
-        returns (uint256 buyAmount)
-    {
-        uint256 sellBase = uint256(10) ** getDeterministicTokenDecimals(sellToken);
-        uint256 buyBase = uint256(10) ** getDeterministicTokenDecimals(buyToken);
-        uint256 rate = getDeterministicRate(salt, sellToken, buyToken);
-        return sellAmount * rate * buyBase / sellBase / RATE_DENOMINATOR;
-    }
-
-    function getDeterministicBuyQuote(
-        bytes32 salt,
-        address sellToken,
-        address buyToken,
-        uint256 buyAmount
-    )
-        internal
-        pure
-        returns (uint256 sellAmount)
-    {
-        uint256 sellBase = uint256(10) ** getDeterministicTokenDecimals(sellToken);
-        uint256 buyBase = uint256(10) ** getDeterministicTokenDecimals(buyToken);
-        uint256 rate = getDeterministicRate(salt, sellToken, buyToken);
-        return buyAmount * RATE_DENOMINATOR * sellBase / rate / buyBase;
-    }
-
-    function getDeterministicTokenDecimals(address token)
-        internal
-        pure
-        returns (uint8 decimals)
-    {
-        if (token == WETH_ADDRESS) {
-            return 18;
-        }
-        bytes32 seed = keccak256(abi.encodePacked(token));
-        return uint8(uint256(seed) % (MAX_DECIMALS - MIN_DECIMALS)) + MIN_DECIMALS;
-    }
-
-    function getDeterministicRate(bytes32 salt, address sellToken, address buyToken)
-        internal
-        pure
-        returns (uint256 rate)
-    {
-        bytes32 seed = keccak256(abi.encodePacked(salt, sellToken, buyToken));
-        return uint256(seed) % (MAX_RATE - MIN_RATE) + MIN_RATE;
-    }
-}
-
-contract TestDeploymentConstants {
-
-    // solhint-disable separate-by-one-line-in-contract
-
-    // Mainnet addresses ///////////////////////////////////////////////////////
-    /// @dev Mainnet address of the WETH contract.
-    address constant private WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
-
-    /// @dev Overridable way to get the WETH address.
-    /// @return wethAddress The WETH address.
-    function _getWethAddress()
-        internal
-        view
-        returns (address wethAddress)
-    {
-        return WETH_ADDRESS;
-    }
-
-}
-
-contract FailTrigger {
-
-    // Give this address a balance to force operations to fail.
-    address payable constant public FAILURE_ADDRESS = 0xe9dB8717BC5DFB20aaf538b4a5a02B7791FF430C;
-
-    // Funds `FAILURE_ADDRESS`.
-    function enableFailTrigger() external payable {
-        FAILURE_ADDRESS.transfer(msg.value);
-    }
-
-    function _revertIfShouldFail() internal view {
-        if (FAILURE_ADDRESS.balance != 0) {
-            revert("FAIL_TRIGGERED");
-        }
-    }
-}
-
-
-contract TestERC20BridgeSamplerUniswapExchange is
-    IUniswapExchangeQuotes,
-    TestDeploymentConstants,
-    FailTrigger
-{
-    bytes32 constant private BASE_SALT = 0x1d6a6a0506b0b4a554b907a4c29d9f4674e461989d9c1921feb17b26716385ab;
-
-    address public tokenAddress;
-    bytes32 public salt;
-
-    constructor(address _tokenAddress) public {
-        tokenAddress = _tokenAddress;
-        salt = keccak256(abi.encodePacked(BASE_SALT, _tokenAddress));
-    }
-
-    // Deterministic `IUniswapExchangeQuotes.getEthToTokenInputPrice()`.
-    function getEthToTokenInputPrice(
-        uint256 ethSold
-    )
-        override
-        external
-        view
-        returns (uint256 tokensBought)
-    {
-        _revertIfShouldFail();
-        return LibDeterministicQuotes.getDeterministicSellQuote(
-            salt,
-            tokenAddress,
-            _getWethAddress(),
-            ethSold
-        );
-    }
-
-    // Deterministic `IUniswapExchangeQuotes.getEthToTokenOutputPrice()`.
-    function getEthToTokenOutputPrice(
-        uint256 tokensBought
-    )
-        override
-        external
-        view
-        returns (uint256 ethSold)
-    {
-        _revertIfShouldFail();
-        return LibDeterministicQuotes.getDeterministicBuyQuote(
-            salt,
-            _getWethAddress(),
-            tokenAddress,
-            tokensBought
-        );
-    }
-
-    // Deterministic `IUniswapExchangeQuotes.getTokenToEthInputPrice()`.
-    function getTokenToEthInputPrice(
-        uint256 tokensSold
-    )
-        override
-        external
-        view
-        returns (uint256 ethBought)
-    {
-        _revertIfShouldFail();
-        return LibDeterministicQuotes.getDeterministicSellQuote(
-            salt,
-            tokenAddress,
-            _getWethAddress(),
-            tokensSold
-        );
-    }
-
-    // Deterministic `IUniswapExchangeQuotes.getTokenToEthOutputPrice()`.
-    function getTokenToEthOutputPrice(
-        uint256 ethBought
-    )
-        override
-        external
-        view
-        returns (uint256 tokensSold)
-    {
-        _revertIfShouldFail();
-        return LibDeterministicQuotes.getDeterministicBuyQuote(
-            salt,
-            _getWethAddress(),
-            tokenAddress,
-            ethBought
-        );
-    }
-}
-
-
-contract TestERC20BridgeSamplerUniswapV2Router01 is
-    IUniswapV2Router01,
-    TestDeploymentConstants,
-    FailTrigger
-{
-    bytes32 constant private SALT = 0xadc7fcb33c735913b8635927e66896b356a53a912ab2ceff929e60a04b53b3c1;
-
-    // Deterministic `IUniswapV2Router01.getAmountsOut()`.
-    function getAmountsOut(uint256 amountIn, address[] calldata path)
-        override
-        external
-        view
-        returns (uint256[] memory amounts)
-    {
-        require(path.length >= 2, "PATH_TOO_SHORT");
-        _revertIfShouldFail();
-        amounts = new uint256[](path.length);
-        amounts[0] = amountIn;
-        for (uint256 i = 0; i < path.length - 1; ++i) {
-            amounts[i + 1] = LibDeterministicQuotes.getDeterministicSellQuote(
-                SALT,
-                path[i],
-                path[i + 1],
-                amounts[i]
-            );
-        }
-    }
-
-    // Deterministic `IUniswapV2Router01.getAmountsInt()`.
-    function getAmountsIn(uint256 amountOut, address[] calldata path)
-        override
-        external
-        view
-        returns (uint256[] memory amounts)
-    {
-        require(path.length >= 2, "PATH_TOO_SHORT");
-        _revertIfShouldFail();
-        amounts = new uint256[](path.length);
-        amounts[path.length - 1] = amountOut;
-        for (uint256 i = path.length - 1; i > 0; --i) {
-            amounts[i - 1] = LibDeterministicQuotes.getDeterministicBuyQuote(
-                SALT,
-                path[i - 1],
-                path[i],
-                amounts[i]
-            );
-        }
-    }
-}
-
-
-// solhint-disable space-after-comma
-contract TestERC20BridgeSamplerKyberNetwork is
-    TestDeploymentConstants,
-    FailTrigger
-{
-    bytes32 constant private SALT = 0x0ff3ca9d46195c39f9a12afb74207b4970349fb3cfb1e459bbf170298d326bc7;
-    address constant public ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
-
-    enum TradeType {BestOfAll, MaskIn, MaskOut, Split}
-    enum ProcessWithRate {NotRequired, Required}
-
-    // IKyberHintHandler
-    function buildTokenToEthHint(
-        address tokenSrc,
-        TradeType /* tokenToEthType */,
-        bytes32[] calldata /* tokenToEthReserveIds */,
-        uint256[] calldata /* tokenToEthSplits */
-    ) external view returns (bytes memory hint)
-    {
-        return abi.encode(tokenSrc);
-    }
-
-    function buildEthToTokenHint(
-        address tokenDest,
-        TradeType /* ethToTokenType */,
-        bytes32[] calldata /* ethToTokenReserveIds */,
-        uint256[] calldata /* ethToTokenSplits */
-    ) external view returns (bytes memory hint)
-    {
-        return abi.encode(tokenDest);
-    }
-
-    // IKyberHintHandler
-    function buildTokenToTokenHint(
-        address tokenSrc,
-        TradeType /* tokenToEthType */,
-        bytes32[] calldata /* tokenToEthReserveIds */,
-        uint256[] calldata /* tokenToEthSplits */,
-        address /* tokenDest  */,
-        TradeType /* EthToTokenType */,
-        bytes32[] calldata /* EthToTokenReserveIds */,
-        uint256[] calldata /* EthToTokenSplits */
-    ) external view returns (bytes memory hint)
-    {
-        return abi.encode(tokenSrc);
-    }
-
-    // IKyberHintHandler
-    function getTradingReserves(
-        address tokenSrc,
-        address tokenDest,
-        bool isTokenToToken,
-        bytes calldata hint
-    )
-        external
-        view
-        returns (
-            bytes32[] memory reserveIds,
-            uint256[] memory splitValuesBps,
-            ProcessWithRate processWithRate
-        )
-    {
-        reserveIds = new bytes32[](1);
-        reserveIds[0] = bytes32(uint256(1));
-        splitValuesBps = new uint256[](0);
-        processWithRate = ProcessWithRate.NotRequired;
-    }
-
-    // Deterministic `IKyberNetworkProxy.getExpectedRateAfterFee()`.
-    function getExpectedRateAfterFee(
-        address fromToken,
-        address toToken,
-        uint256 /* srcQty */,
-        uint256 /* fee */,
-        bytes calldata /* hint */
-    )
-        external
-        view
-        returns
-        (uint256 expectedRate)
-    {
-        _revertIfShouldFail();
-        fromToken = fromToken == ETH_ADDRESS ? _getWethAddress() : fromToken;
-        toToken = toToken == ETH_ADDRESS ? _getWethAddress() : toToken;
-        expectedRate = LibDeterministicQuotes.getDeterministicRate(
-            SALT,
-            fromToken,
-            toToken
-        );
-    }
-
-    // Deterministic `IKyberNetworkProxy.getExpectedRate()`.
-    function getExpectedRate(
-        address fromToken,
-        address toToken,
-        uint256
-    )
-        external
-        view
-        returns (uint256 expectedRate, uint256)
-    {
-        _revertIfShouldFail();
-        fromToken = fromToken == ETH_ADDRESS ? _getWethAddress() : fromToken;
-        toToken = toToken == ETH_ADDRESS ? _getWethAddress() : toToken;
-        expectedRate = LibDeterministicQuotes.getDeterministicRate(
-            SALT,
-            fromToken,
-            toToken
-        );
-    }
-}
-
-
-contract TestERC20BridgeSamplerUniswapExchangeFactory is
-    IUniswapExchangeFactory
-{
-    mapping (address => IUniswapExchangeQuotes) private _exchangesByToken;
-
-    // Creates Uniswap exchange contracts for tokens.
-    function createTokenExchanges(address[] calldata tokenAddresses)
-        external
-    {
-        for (uint256 i = 0; i < tokenAddresses.length; i++) {
-            address tokenAddress = tokenAddresses[i];
-            _exchangesByToken[tokenAddress] =
-                new TestERC20BridgeSamplerUniswapExchange(tokenAddress);
-        }
-    }
-
-    // `IUniswapExchangeFactory.getExchange()`.
-    function getExchange(address tokenAddress)
-        override
-        external
-        view
-        returns (address)
-    {
-        return address(_exchangesByToken[tokenAddress]);
-    }
-}
-
-
-contract TestERC20BridgeSampler is
-    ERC20BridgeSampler,
-    FailTrigger
-{
-    TestERC20BridgeSamplerUniswapExchangeFactory public uniswap;
-    TestERC20BridgeSamplerUniswapV2Router01 public uniswapV2Router;
-    TestERC20BridgeSamplerKyberNetwork public kyber;
-
-    uint8 private constant MAX_ORDER_STATUS = uint8(IExchange.OrderStatus.CANCELLED) + 1;
-
-    constructor() public ERC20BridgeSampler() {
-        uniswap = new TestERC20BridgeSamplerUniswapExchangeFactory();
-        uniswapV2Router = new TestERC20BridgeSamplerUniswapV2Router01();
-        kyber = new TestERC20BridgeSamplerKyberNetwork();
-    }
-
-    // Creates Uniswap exchange contracts for tokens.
-    function createTokenExchanges(address[] calldata tokenAddresses)
-        external
-    {
-        uniswap.createTokenExchanges(tokenAddresses);
-    }
-
-    // Overridden to return deterministic states.
-    function getLimitOrderFillableTakerAmount(
-        IExchange.LimitOrder memory order,
-        IExchange.Signature memory,
-        IExchange
-    )
-        override
-        public
-        view
-        returns (uint256 fillableTakerAmount)
-    {
-        return uint256(keccak256(abi.encode(order.salt))) % order.takerAmount;
-    }
-
-    // Overriden to return deterministic decimals.
-    function _getTokenDecimals(address tokenAddress)
-        override
-        internal
-        view
-        returns (uint8 decimals)
-    {
-        return LibDeterministicQuotes.getDeterministicTokenDecimals(tokenAddress);
-    }
-}

packages/asset-swapper/contracts/test/TestNativeOrderSampler.sol

@@ -1,135 +0,0 @@
-// SPDX-License-Identifier: Apache-2.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.6;
-pragma experimental ABIEncoderV2;
-
-import "../src/NativeOrderSampler.sol";
-import "../src/UtilitySampler.sol";
-
-
-contract TestNativeOrderSamplerToken {
-    mapping (address => uint256) public balanceOf;
-    mapping (address => mapping(address => uint256)) public allowance;
-
-    function setBalanceAndAllowance(
-        address owner,
-        address spender,
-        uint256 balance,
-        uint256 allowance_
-    )
-        external
-    {
-        balanceOf[owner] = balance;
-        allowance[owner][spender] = allowance_;
-    }
-}
-
-contract TestNativeOrderSampler is
-    NativeOrderSampler,
-    UtilitySampler
-{
-    uint8 private constant MAX_ORDER_STATUS = uint8(IExchange.OrderStatus.CANCELLED) + 1;
-    bytes32 private constant VALID_SIGNATURE_HASH = bytes32(hex"01");
-
-    function createTokens(uint256 count)
-        external
-        returns (TestNativeOrderSamplerToken[] memory tokens)
-    {
-        tokens = new TestNativeOrderSamplerToken[](count);
-        for (uint256 i = 0; i < count; ++i) {
-            tokens[i] = new TestNativeOrderSamplerToken();
-        }
-    }
-
-    function setTokenBalanceAndAllowance(
-        TestNativeOrderSamplerToken token,
-        address owner,
-        address spender,
-        uint256 balance,
-        uint256 allowance
-    )
-        external
-    {
-        token.setBalanceAndAllowance(owner, spender, balance, allowance);
-    }
-
-    // IExchange.getLimitOrderRelevantState()
-    function getLimitOrderRelevantState(
-        IExchange.LimitOrder memory order,
-        IExchange.Signature calldata signature
-    )
-        external
-        view
-        returns (
-            IExchange.OrderInfo memory orderInfo,
-            uint128 actualFillableTakerTokenAmount,
-            bool isSignatureValid
-        )
-    {
-        // The order salt determines everything.
-        orderInfo.orderHash = keccak256(abi.encode(order.salt));
-        if (uint8(order.salt) == 0xFF) {
-            orderInfo.status = IExchange.OrderStatus.FILLED;
-        } else {
-            orderInfo.status = IExchange.OrderStatus.FILLABLE;
-        }
-
-        isSignatureValid = signature.r == VALID_SIGNATURE_HASH;
-
-        // The expiration time is the filled taker asset amount.
-        orderInfo.takerTokenFilledAmount = uint128(order.expiry);
-
-        // Calculate how much is fillable in maker terms given the filled taker amount
-        uint256 fillableMakerTokenAmount = LibMathV06.getPartialAmountFloor(
-            uint256(
-                order.takerAmount
-                - orderInfo.takerTokenFilledAmount
-            ),
-            uint256(order.takerAmount),
-            uint256(order.makerAmount)
-        );
-
-        // Take the min of the balance/allowance and the fillable maker amount
-        fillableMakerTokenAmount = LibSafeMathV06.min256(
-            fillableMakerTokenAmount,
-            _getSpendableERC20BalanceOf(order.makerToken, order.maker)
-        );
-
-        // Convert to taker terms
-        actualFillableTakerTokenAmount = LibMathV06.getPartialAmountCeil(
-            fillableMakerTokenAmount,
-            uint256(order.makerAmount),
-            uint256(order.takerAmount)
-        ).safeDowncastToUint128();
-    }
-
-    function _getSpendableERC20BalanceOf(
-        IERC20TokenV06 token,
-        address owner
-    )
-        internal
-        view
-        returns (uint256)
-    {
-        return LibSafeMathV06.min256(
-            token.allowance(owner, address(this)),
-            token.balanceOf(owner)
-        );
-    }
-}

packages/asset-swapper/foundry.toml

@@ -0,0 +1,6 @@
+[default]
+src = 'contracts/src'
+test = 'contracts/test'
+out = 'out'
+libs = ['contracts/lib']
+remappings = ['ds-test/=contracts/lib/ds-test/src/']

packages/asset-swapper/package.json

@@ -39,7 +39,7 @@
     "config": {
         "publicInterfaceContracts": "ERC20BridgeSampler,BalanceChecker,FakeTaker",
         "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually.",
-        "abis": "./test/generated-artifacts/@(ApproximateBuys|BalanceChecker|BalancerSampler|BalancerV2Sampler|BancorSampler|CompoundSampler|CurveSampler|DODOSampler|DODOV2Sampler|DummyLiquidityProvider|ERC20BridgeSampler|FakeTaker|IBalancer|IBancor|ICurve|IKyberNetwork|IMStable|IMooniswap|IMultiBridge|IShell|ISmoothy|IUniswapExchangeQuotes|IUniswapV2Router01|KyberDmmSampler|KyberSampler|LidoSampler|LiquidityProviderSampler|MStableSampler|MakerPSMSampler|MooniswapSampler|MultiBridgeSampler|NativeOrderSampler|SamplerBase|SamplerUtils|ShellSampler|SmoothySampler|TestERC20BridgeSampler|TestNativeOrderSampler|TwoHopSampler|UniswapSampler|UniswapV2Sampler|UniswapV3Sampler|UtilitySampler).json",
+        "abis": "./test/generated-artifacts/@(ApproximateBuys|BalanceChecker|BalancerSampler|BalancerV2Sampler|BancorSampler|CompoundSampler|CurveSampler|DODOSampler|DODOV2Sampler|DummyLiquidityProvider|ERC20BridgeSampler|FakeTaker|IBalancer|IBancor|ICurve|IERC20TokenV06|IKyberNetwork|ILiquidityProvider|IMStable|IMooniswap|IMultiBridge|IShell|ISmoothy|IUniswapExchangeQuotes|IUniswapV2Router01|KyberDmmSampler|KyberSampler|LibBytes|LibSafeMath|LidoSampler|LiquidityProviderSampler|MStableSampler|MakerPSMSampler|MooniswapSampler|MultiBridgeSampler|NativeOrderSampler|SamplerBase|SamplerUtils|ShellSampler|SmoothySampler|TestERC20BridgeSampler|TestNativeOrderSampler|TwoHopSampler|UniswapSampler|UniswapV2Sampler|UniswapV3Sampler|UtilitySampler).json",
         "postpublish": {
             "assets": []
         }

packages/asset-swapper/test/artifacts.ts

@@ -20,7 +20,9 @@ import * as FakeTaker from '../test/generated-artifacts/FakeTaker.json';
 import * as IBalancer from '../test/generated-artifacts/IBalancer.json';
 import * as IBancor from '../test/generated-artifacts/IBancor.json';
 import * as ICurve from '../test/generated-artifacts/ICurve.json';
+import * as IERC20TokenV06 from '../test/generated-artifacts/IERC20TokenV06.json';
 import * as IKyberNetwork from '../test/generated-artifacts/IKyberNetwork.json';
+import * as ILiquidityProvider from '../test/generated-artifacts/ILiquidityProvider.json';
 import * as IMooniswap from '../test/generated-artifacts/IMooniswap.json';
 import * as IMStable from '../test/generated-artifacts/IMStable.json';
 import * as IMultiBridge from '../test/generated-artifacts/IMultiBridge.json';
@@ -30,6 +32,8 @@ import * as IUniswapExchangeQuotes from '../test/generated-artifacts/IUniswapExc
 import * as IUniswapV2Router01 from '../test/generated-artifacts/IUniswapV2Router01.json';
 import * as KyberDmmSampler from '../test/generated-artifacts/KyberDmmSampler.json';
 import * as KyberSampler from '../test/generated-artifacts/KyberSampler.json';
+import * as LibBytes from '../test/generated-artifacts/LibBytes.json';
+import * as LibSafeMath from '../test/generated-artifacts/LibSafeMath.json';
 import * as LidoSampler from '../test/generated-artifacts/LidoSampler.json';
 import * as LiquidityProviderSampler from '../test/generated-artifacts/LiquidityProviderSampler.json';
 import * as MakerPSMSampler from '../test/generated-artifacts/MakerPSMSampler.json';
@@ -62,6 +66,8 @@ export const artifacts = {
     FakeTaker: FakeTaker as ContractArtifact,
     KyberDmmSampler: KyberDmmSampler as ContractArtifact,
     KyberSampler: KyberSampler as ContractArtifact,
+    LibBytes: LibBytes as ContractArtifact,
+    LibSafeMath: LibSafeMath as ContractArtifact,
     LidoSampler: LidoSampler as ContractArtifact,
     LiquidityProviderSampler: LiquidityProviderSampler as ContractArtifact,
     MStableSampler: MStableSampler as ContractArtifact,
@@ -81,7 +87,9 @@ export const artifacts = {
     IBalancer: IBalancer as ContractArtifact,
     IBancor: IBancor as ContractArtifact,
     ICurve: ICurve as ContractArtifact,
+    IERC20TokenV06: IERC20TokenV06 as ContractArtifact,
     IKyberNetwork: IKyberNetwork as ContractArtifact,
+    ILiquidityProvider: ILiquidityProvider as ContractArtifact,
     IMStable: IMStable as ContractArtifact,
     IMooniswap: IMooniswap as ContractArtifact,
     IMultiBridge: IMultiBridge as ContractArtifact,

packages/asset-swapper/test/wrappers.ts

@@ -18,7 +18,9 @@ export * from '../test/generated-wrappers/fake_taker';
 export * from '../test/generated-wrappers/i_balancer';
 export * from '../test/generated-wrappers/i_bancor';
 export * from '../test/generated-wrappers/i_curve';
+export * from '../test/generated-wrappers/i_erc20_token_v06';
 export * from '../test/generated-wrappers/i_kyber_network';
+export * from '../test/generated-wrappers/i_liquidity_provider';
 export * from '../test/generated-wrappers/i_m_stable';
 export * from '../test/generated-wrappers/i_mooniswap';
 export * from '../test/generated-wrappers/i_multi_bridge';
@@ -28,6 +30,8 @@ export * from '../test/generated-wrappers/i_uniswap_exchange_quotes';
 export * from '../test/generated-wrappers/i_uniswap_v2_router01';
 export * from '../test/generated-wrappers/kyber_dmm_sampler';
 export * from '../test/generated-wrappers/kyber_sampler';
+export * from '../test/generated-wrappers/lib_bytes';
+export * from '../test/generated-wrappers/lib_safe_math';
 export * from '../test/generated-wrappers/lido_sampler';
 export * from '../test/generated-wrappers/liquidity_provider_sampler';
 export * from '../test/generated-wrappers/m_stable_sampler';

packages/asset-swapper/tsconfig.json

@@ -21,7 +21,9 @@
         "test/generated-artifacts/IBalancer.json",
         "test/generated-artifacts/IBancor.json",
         "test/generated-artifacts/ICurve.json",
+        "test/generated-artifacts/IERC20TokenV06.json",
         "test/generated-artifacts/IKyberNetwork.json",
+        "test/generated-artifacts/ILiquidityProvider.json",
         "test/generated-artifacts/IMStable.json",
         "test/generated-artifacts/IMooniswap.json",
         "test/generated-artifacts/IMultiBridge.json",
@@ -31,6 +33,8 @@
         "test/generated-artifacts/IUniswapV2Router01.json",
         "test/generated-artifacts/KyberDmmSampler.json",
         "test/generated-artifacts/KyberSampler.json",
+        "test/generated-artifacts/LibBytes.json",
+        "test/generated-artifacts/LibSafeMath.json",
         "test/generated-artifacts/LidoSampler.json",
         "test/generated-artifacts/LiquidityProviderSampler.json",
         "test/generated-artifacts/MStableSampler.json",