diff --git a/packages/asset-swapper/.gitignore b/packages/asset-swapper/.gitignore index 2bd6a3f7e3..1c2347240f 100644 --- a/packages/asset-swapper/.gitignore +++ b/packages/asset-swapper/.gitignore @@ -1,2 +1,4 @@ **/generated-artifacts **/generated-wrappers +cache +out diff --git a/packages/asset-swapper/contracts/src/ApproximateBuys.sol b/packages/asset-swapper/contracts/src/ApproximateBuys.sol index 7f8d9ddff4..cdcbbeada5 100644 --- a/packages/asset-swapper/contracts/src/ApproximateBuys.sol +++ b/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 { diff --git a/packages/asset-swapper/contracts/src/CompoundSampler.sol b/packages/asset-swapper/contracts/src/CompoundSampler.sol index 7de55af154..5c57acd358 100644 --- a/packages/asset-swapper/contracts/src/CompoundSampler.sol +++ b/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 diff --git a/packages/asset-swapper/contracts/src/LibBytes.sol b/packages/asset-swapper/contracts/src/LibBytes.sol new file mode 100644 index 0000000000..3fadb563e9 --- /dev/null +++ b/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; + } +} \ No newline at end of file diff --git a/packages/asset-swapper/contracts/src/LibSafeMath.sol b/packages/asset-swapper/contracts/src/LibSafeMath.sol new file mode 100644 index 0000000000..8c69596c04 --- /dev/null +++ b/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; + } +} diff --git a/packages/asset-swapper/contracts/src/LiquidityProviderSampler.sol b/packages/asset-swapper/contracts/src/LiquidityProviderSampler.sol index 2fbeaadbfb..6ce3d62649 100644 --- a/packages/asset-swapper/contracts/src/LiquidityProviderSampler.sol +++ b/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"; diff --git a/packages/asset-swapper/contracts/src/MakerPSMSampler.sol b/packages/asset-swapper/contracts/src/MakerPSMSampler.sol index 9823c545b6..77613228af 100644 --- a/packages/asset-swapper/contracts/src/MakerPSMSampler.sol +++ b/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 { diff --git a/packages/asset-swapper/contracts/src/NativeOrderSampler.sol b/packages/asset-swapper/contracts/src/NativeOrderSampler.sol index 43c84272fe..630717cbf2 100644 --- a/packages/asset-swapper/contracts/src/NativeOrderSampler.sol +++ b/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 diff --git a/packages/asset-swapper/contracts/src/SamplerUtils.sol b/packages/asset-swapper/contracts/src/SamplerUtils.sol index b505512b6b..1a5c75203a 100644 --- a/packages/asset-swapper/contracts/src/SamplerUtils.sol +++ b/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) diff --git a/packages/asset-swapper/contracts/src/TwoHopSampler.sol b/packages/asset-swapper/contracts/src/TwoHopSampler.sol index 807d7cfede..474df2c2d6 100644 --- a/packages/asset-swapper/contracts/src/TwoHopSampler.sol +++ b/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; diff --git a/packages/asset-swapper/contracts/src/UniswapV3Sampler.sol b/packages/asset-swapper/contracts/src/UniswapV3Sampler.sol index 541fc6435c..9608d17c24 100644 --- a/packages/asset-swapper/contracts/src/UniswapV3Sampler.sol +++ b/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 { diff --git a/packages/asset-swapper/contracts/src/UtilitySampler.sol b/packages/asset-swapper/contracts/src/UtilitySampler.sol index bbc3c5a1ad..8038b7756c 100644 --- a/packages/asset-swapper/contracts/src/UtilitySampler.sol +++ b/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); } } diff --git a/packages/asset-swapper/contracts/src/interfaces/IERC20TokenV06.sol b/packages/asset-swapper/contracts/src/interfaces/IERC20TokenV06.sol new file mode 100644 index 0000000000..765d55f18f --- /dev/null +++ b/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); +} diff --git a/packages/asset-swapper/contracts/src/interfaces/ILiquidityProvider.sol b/packages/asset-swapper/contracts/src/interfaces/ILiquidityProvider.sol new file mode 100644 index 0000000000..59bed68824 --- /dev/null +++ b/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); +} diff --git a/packages/asset-swapper/contracts/src/test/TestBase.sol b/packages/asset-swapper/contracts/src/test/TestBase.sol new file mode 100644 index 0000000000..faa1dac859 --- /dev/null +++ b/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; + } +} \ No newline at end of file diff --git a/packages/asset-swapper/contracts/src/test/UniswapV2Sampler.t.sol b/packages/asset-swapper/contracts/src/test/UniswapV2Sampler.t.sol new file mode 100644 index 0000000000..d08846ab3f --- /dev/null +++ b/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); + } +} diff --git a/packages/asset-swapper/contracts/test/DummyLiquidityProvider.sol b/packages/asset-swapper/contracts/test/DummyLiquidityProvider.sol deleted file mode 100644 index 7b80565ece..0000000000 --- a/packages/asset-swapper/contracts/test/DummyLiquidityProvider.sol +++ /dev/null @@ -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; - } -} diff --git a/packages/asset-swapper/contracts/test/TestERC20BridgeSampler.sol b/packages/asset-swapper/contracts/test/TestERC20BridgeSampler.sol deleted file mode 100644 index 0f332f61f0..0000000000 --- a/packages/asset-swapper/contracts/test/TestERC20BridgeSampler.sol +++ /dev/null @@ -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); - } -} diff --git a/packages/asset-swapper/contracts/test/TestNativeOrderSampler.sol b/packages/asset-swapper/contracts/test/TestNativeOrderSampler.sol deleted file mode 100644 index 39cb0b2af0..0000000000 --- a/packages/asset-swapper/contracts/test/TestNativeOrderSampler.sol +++ /dev/null @@ -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) - ); - } -} diff --git a/packages/asset-swapper/foundry.toml b/packages/asset-swapper/foundry.toml new file mode 100644 index 0000000000..7e7821c529 --- /dev/null +++ b/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/'] diff --git a/packages/asset-swapper/package.json b/packages/asset-swapper/package.json index fd0b866874..ffa7c0fa69 100644 --- a/packages/asset-swapper/package.json +++ b/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": [] } diff --git a/packages/asset-swapper/test/artifacts.ts b/packages/asset-swapper/test/artifacts.ts index 3d51dc35b5..85363dbc73 100644 --- a/packages/asset-swapper/test/artifacts.ts +++ b/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, diff --git a/packages/asset-swapper/test/wrappers.ts b/packages/asset-swapper/test/wrappers.ts index 6433e7bb4a..ad77a59a72 100644 --- a/packages/asset-swapper/test/wrappers.ts +++ b/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'; diff --git a/packages/asset-swapper/tsconfig.json b/packages/asset-swapper/tsconfig.json index eb544fbdc5..fa43c9feb3 100644 --- a/packages/asset-swapper/tsconfig.json +++ b/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",