diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index b00c8e4..0000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "solidity.formatter": "forge", - "solidity.compileUsingRemoteVersion": "v0.8.20", - "solidity.packageDefaultDependenciesContractsDirectory": "evm/src", - "solidity.packageDefaultDependenciesDirectory": "evm/lib", -} \ No newline at end of file diff --git a/evm/.gitignore b/evm/.gitignore index 85198aa..409f575 100644 --- a/evm/.gitignore +++ b/evm/.gitignore @@ -1,6 +1,7 @@ # Compiler files cache/ out/ +coverage/ # Ignores development broadcast logs !/broadcast @@ -12,3 +13,7 @@ docs/ # Dotenv file .env + +# Others +.DS_STORE +lcov.info diff --git a/evm/src/integral/IntegralSwapAdapter.sol b/evm/src/integral/IntegralSwapAdapter.sol new file mode 100644 index 0000000..4797132 --- /dev/null +++ b/evm/src/integral/IntegralSwapAdapter.sol @@ -0,0 +1,583 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity ^0.8.13; + +import {IERC20, ISwapAdapter} from "src/interfaces/ISwapAdapter.sol"; +import {ERC20} from "openzeppelin-contracts/contracts/token/ERC20/ERC20.sol"; +import {SafeERC20} from "openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol"; + +/// @dev Integral submitted deadline of 3600 seconds (1 hour) to Paraswap, but it is not strictly necessary to be this long +/// as the contract allows less durations, we use 1000 seconds (15 minutes) as a deadline +uint256 constant SWAP_DEADLINE_SEC = 1000; +uint256 constant STANDARD_TOKEN_DECIMALS = 10**18; + +/// @title Integral Swap Adapter +contract IntegralSwapAdapter is ISwapAdapter { + using SafeERC20 for IERC20; + + ITwapRelayer immutable relayer; + + constructor(address relayer_) { + relayer = ITwapRelayer(relayer_); + } + + /// @inheritdoc ISwapAdapter + /// @dev Integral always relies on a single pool linked to the factory to map two pairs, and does not use routing + /// we can then use getPriceByTokenAddresses() instead of getPriceByPairAddresses() + /// as they both return the same value and the first also handles the order of tokens inside. + /// @dev Since the price of a token is determined externally by Integral Oracles and not by reserves + /// it will always be the same (pre and post trade) and independent of the amounts swapped, + /// but we still return an array of length=specifiedAmounts.length with same values to make sure the return value is the expected from caller. + function price( + bytes32, + IERC20 _sellToken, + IERC20 _buyToken, + uint256[] memory _specifiedAmounts + ) external view override returns (Fraction[] memory _prices) { + _prices = new Fraction[](_specifiedAmounts.length); + Fraction memory price = getPriceAt(address(_sellToken), address(_buyToken)); + + for (uint256 i = 0; i < _specifiedAmounts.length; i++) { + _prices[i] = price; + } + } + + /// @inheritdoc ISwapAdapter + function swap( + bytes32, + IERC20 sellToken, + IERC20 buyToken, + OrderSide side, + uint256 specifiedAmount + ) external override returns (Trade memory trade) { + if (specifiedAmount == 0) { + return trade; + } + + uint256 gasBefore = gasleft(); + if (side == OrderSide.Sell) { // sell + trade.calculatedAmount = + sell(sellToken, buyToken, specifiedAmount); + } else { // buy + trade.calculatedAmount = + buy(sellToken, buyToken, specifiedAmount); + } + trade.gasUsed = gasBefore - gasleft(); + trade.price = getPriceAt(address(sellToken), address(buyToken)); + } + + /// @inheritdoc ISwapAdapter + function getLimits(bytes32, IERC20 sellToken, IERC20 buyToken) + external + view + override + returns (uint256[] memory limits) + { + ( + , + , + , + uint256 limitMax0, + , + uint256 limitMax1 + ) = relayer.getPoolState(address(sellToken), address(buyToken)); + + limits = new uint256[](2); + limits[0] = limitMax0; + limits[1] = limitMax1; + /** + * @dev minLimits in integral are the args: 2(for sellToken, the one before limitMax0) + * and 4(for buyToken, the one before limitMax1) of the function relayer.getPoolState(sellToken, buyToken); + * an implementation of them can be found in the test of this adapter + */ + } + + /// @inheritdoc ISwapAdapter + function getCapabilities(bytes32, IERC20, IERC20) + external + pure + override + returns (Capability[] memory capabilities) + { + capabilities = new Capability[](4); + capabilities[0] = Capability.SellOrder; + capabilities[1] = Capability.BuyOrder; + capabilities[2] = Capability.PriceFunction; + capabilities[3] = Capability.ConstantPrice; + } + + /// @inheritdoc ISwapAdapter + function getTokens(bytes32 poolId) + external + view + override + returns (IERC20[] memory tokens) + { + tokens = new IERC20[](2); + ITwapPair pair = ITwapPair(address(bytes20(poolId))); + tokens[0] = IERC20(pair.token0()); + tokens[1] = IERC20(pair.token1()); + } + + /// @inheritdoc ISwapAdapter + function getPoolIds(uint256 offset, uint256 limit) + external + view + override + returns (bytes32[] memory ids) + { + ITwapFactory factory = ITwapFactory(relayer.factory()); + uint256 endIdx = offset + limit; + if (endIdx > factory.allPairsLength()) { + endIdx = factory.allPairsLength(); + } + ids = new bytes32[](endIdx - offset); + for (uint256 i = 0; i < ids.length; i++) { + ids[i] = bytes20(factory.allPairs(offset + i)); + } + } + + /// @notice Executes a sell order on a given pool. + /// @param sellToken The address of the token being sold. + /// @param buyToken The address of the token being bought. + /// @param amount The amount to be traded. + /// @return uint256 The amount of tokens received. + function sell( + IERC20 sellToken, + IERC20 buyToken, + uint256 amount + ) internal returns (uint256) { + uint256 amountOut = relayer.quoteSell(address(sellToken), address(buyToken), amount); + if (amountOut == 0) { + revert Unavailable("AmountOut is zero!"); + } + + sellToken.safeTransferFrom(msg.sender, address(this), amount); + sellToken.safeIncreaseAllowance(address(relayer), amount); + + relayer.sell(ITwapRelayer.SellParams({ + tokenIn: address(sellToken), + tokenOut: address(buyToken), + wrapUnwrap: false, + to: msg.sender, + submitDeadline: uint32(block.timestamp + SWAP_DEADLINE_SEC), + amountIn: amount, + amountOutMin: amountOut + })); + + return amountOut; + } + + /// @notice Executes a buy order on a given pool. + /// @param sellToken The address of the token being sold. + /// @param buyToken The address of the token being bought. + /// @param amountBought The amount of buyToken tokens to buy. + /// @return uint256 The amount of tokens received. + function buy( + IERC20 sellToken, + IERC20 buyToken, + uint256 amountBought + ) internal returns (uint256) { + uint256 amountIn = relayer.quoteBuy(address(sellToken), address(buyToken), amountBought); + if (amountIn == 0) { + revert Unavailable("AmountIn is zero!"); + } + + sellToken.safeTransferFrom(msg.sender, address(this), amountIn); + sellToken.safeIncreaseAllowance(address(relayer), amountIn); + + relayer.buy(ITwapRelayer.BuyParams({ + tokenIn: address(sellToken), + tokenOut: address(buyToken), + wrapUnwrap: false, + to: msg.sender, + submitDeadline: uint32(block.timestamp + SWAP_DEADLINE_SEC), + amountInMax: amountIn, + amountOut: amountBought + })); + + return amountIn; + } + + /// @notice Get swap price including fee + /// @param sellToken token to sell + /// @param buyToken token to buy + function getPriceAt(address sellToken, address buyToken) internal view returns(Fraction memory) { + uint256 priceWithoutFee = relayer.getPriceByTokenAddresses(address(sellToken), address(buyToken)); + ITwapFactory factory = ITwapFactory(relayer.factory()); + address pairAddress = factory.getPair(address(sellToken), address(buyToken)); + + // get swapFee formatted; swapFee is a constant + uint256 swapFeeFormatted = (STANDARD_TOKEN_DECIMALS - relayer.swapFee(pairAddress)); + + // get token decimals + uint256 sellTokenDecimals = 10**ERC20(sellToken).decimals(); + uint256 buyTokenDecimals = 10**ERC20(buyToken).decimals(); + + /** + * @dev + * Denominator works as a "standardizer" for the price rather than a reserve value + * as Integral takes prices from oracles and do not operate with reserves; + * it is therefore used to maintain integrity for the Fraction division, + * as numerator and denominator could have different token decimals(es. ETH(18)-USDC(6)). + * Both numerator and denominator are also multiplied by STANDARD_TOKEN_DECIMALS + * to ensure that precision losses are minimized or null. + */ + return Fraction( + priceWithoutFee * STANDARD_TOKEN_DECIMALS, + STANDARD_TOKEN_DECIMALS * sellTokenDecimals * swapFeeFormatted / buyTokenDecimals + ); + } +} + +interface ITwapRelayer { + event OwnerSet(address owner); + event RebalancerSet(address rebalancer); + event DelaySet(address delay); + event PairEnabledSet(address pair, bool enabled); + event SwapFeeSet(address pair, uint256 fee); + event TwapIntervalSet(address pair, uint32 interval); + event EthTransferGasCostSet(uint256 gasCost); + event ExecutionGasLimitSet(uint256 limit); + event TokenLimitMinSet(address token, uint256 limit); + event TokenLimitMaxMultiplierSet(address token, uint256 limit); + event ToleranceSet(address pair, uint16 tolerance); + event Approve(address token, address to, uint256 amount); + event Withdraw(address token, address to, uint256 amount); + event Sell( + address indexed sender, + address tokenIn, + address tokenOut, + uint256 amountIn, + uint256 amountOut, + uint256 amountOutMin, + bool wrapUnwrap, + uint256 fee, + address indexed to, + address orderContract, + uint256 indexed orderId + ); + event Buy( + address indexed sender, + address tokenIn, + address tokenOut, + uint256 amountIn, + uint256 amountInMax, + uint256 amountOut, + bool wrapUnwrap, + uint256 fee, + address indexed to, + address orderContract, + uint256 indexed orderId + ); + event RebalanceSellWithDelay( + address indexed sender, + address tokenIn, + address tokenOut, + uint256 amountIn, + uint256 indexed delayOrderId + ); + event RebalanceSellWithOneInch(address indexed oneInchRouter, uint256 gas, bytes data); + event OneInchRouterWhitelisted(address indexed oneInchRouter, bool whitelisted); + + function factory() external pure returns (address); + + function delay() external pure returns (address); + + function weth() external pure returns (address); + + function owner() external view returns (address); + + function rebalancer() external view returns (address); + + function isOneInchRouterWhitelisted(address oneInchRouter) external view returns (bool); + + function setOwner(address _owner) external; + + function swapFee(address pair) external view returns (uint256); + + function setSwapFee(address pair, uint256 fee) external; + + function twapInterval(address pair) external pure returns (uint32); + + function isPairEnabled(address pair) external view returns (bool); + + function setPairEnabled(address pair, bool enabled) external; + + function ethTransferGasCost() external pure returns (uint256); + + function executionGasLimit() external pure returns (uint256); + + function tokenLimitMin(address token) external pure returns (uint256); + + function tokenLimitMaxMultiplier(address token) external pure returns (uint256); + + function tolerance(address pair) external pure returns (uint16); + + function setRebalancer(address _rebalancer) external; + + function whitelistOneInchRouter(address oneInchRouter, bool whitelisted) external; + + function getTolerance(address pair) external pure returns (uint16); + + function getTokenLimitMin(address token) external pure returns (uint256); + + function getTokenLimitMaxMultiplier(address token) external pure returns (uint256); + + function getTwapInterval(address pair) external pure returns (uint32); + + struct SellParams { + address tokenIn; + address tokenOut; + uint256 amountIn; + uint256 amountOutMin; + bool wrapUnwrap; + address to; + uint32 submitDeadline; + } + + function sell(SellParams memory sellParams) external payable returns (uint256 orderId); + + struct BuyParams { + address tokenIn; + address tokenOut; + uint256 amountInMax; + uint256 amountOut; + bool wrapUnwrap; + address to; + uint32 submitDeadline; + } + + function buy(BuyParams memory buyParams) external payable returns (uint256 orderId); + + function getPriceByPairAddress(address pair, bool inverted) + external + view + returns ( + uint8 xDecimals, + uint8 yDecimals, + uint256 price + ); + + function getPriceByTokenAddresses(address tokenIn, address tokenOut) external view returns (uint256 price); + + function getPoolState(address token0, address token1) + external + view + returns ( + uint256 price, + uint256 fee, + uint256 limitMin0, + uint256 limitMax0, + uint256 limitMin1, + uint256 limitMax1 + ); + + function quoteSell( + address tokenIn, + address tokenOut, + uint256 amountIn + ) external view returns (uint256 amountOut); + + function quoteBuy( + address tokenIn, + address tokenOut, + uint256 amountOut + ) external view returns (uint256 amountIn); + + function approve( + address token, + uint256 amount, + address to + ) external; + + function withdraw( + address token, + uint256 amount, + address to + ) external; + + function rebalanceSellWithDelay( + address tokenIn, + address tokenOut, + uint256 amountIn + ) external; + + function rebalanceSellWithOneInch( + address tokenIn, + uint256 amountIn, + address oneInchRouter, + uint256 _gas, + bytes calldata data + ) external; +} + +interface ITwapFactory { + event PairCreated(address indexed token0, address indexed token1, address pair, uint256); + event OwnerSet(address owner); + + function owner() external view returns (address); + + function getPair(address tokenA, address tokenB) external view returns (address pair); + + function allPairs(uint256) external view returns (address pair); + + function allPairsLength() external view returns (uint256); + + function createPair( + address tokenA, + address tokenB, + address oracle, + address trader + ) external returns (address pair); + + function setOwner(address) external; + + function setMintFee( + address tokenA, + address tokenB, + uint256 fee + ) external; + + function setBurnFee( + address tokenA, + address tokenB, + uint256 fee + ) external; + + function setSwapFee( + address tokenA, + address tokenB, + uint256 fee + ) external; + + function setOracle( + address tokenA, + address tokenB, + address oracle + ) external; + + function setTrader( + address tokenA, + address tokenB, + address trader + ) external; + + function collect( + address tokenA, + address tokenB, + address to + ) external; + + function withdraw( + address tokenA, + address tokenB, + uint256 amount, + address to + ) external; +} + +interface ITwapERC20 is IERC20 { + function PERMIT_TYPEHASH() external pure returns (bytes32); + + function nonces(address owner) external view returns (uint256); + + function permit( + address owner, + address spender, + uint256 value, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) external; + + function increaseAllowance(address spender, uint256 addedValue) external returns (bool); + + function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool); +} + +interface IReserves { + function getReserves() external view returns (uint112 reserve0, uint112 reserve1); + + function getFees() external view returns (uint256 fee0, uint256 fee1); +} + +interface ITwapPair is ITwapERC20, IReserves { + event Mint(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 liquidityOut, address indexed to); + event Burn(address indexed sender, uint256 amount0Out, uint256 amount1Out, uint256 liquidityIn, address indexed to); + event Swap( + address indexed sender, + uint256 amount0In, + uint256 amount1In, + uint256 amount0Out, + uint256 amount1Out, + address indexed to + ); + event SetMintFee(uint256 fee); + event SetBurnFee(uint256 fee); + event SetSwapFee(uint256 fee); + event SetOracle(address account); + event SetTrader(address trader); + + function MINIMUM_LIQUIDITY() external pure returns (uint256); + + function factory() external view returns (address); + + function token0() external view returns (address); + + function token1() external view returns (address); + + function oracle() external view returns (address); + + function trader() external view returns (address); + + function mintFee() external view returns (uint256); + + function setMintFee(uint256 fee) external; + + function mint(address to) external returns (uint256 liquidity); + + function burnFee() external view returns (uint256); + + function setBurnFee(uint256 fee) external; + + function burn(address to) external returns (uint256 amount0, uint256 amount1); + + function swapFee() external view returns (uint256); + + function setSwapFee(uint256 fee) external; + + function setOracle(address account) external; + + function setTrader(address account) external; + + function collect(address to) external; + + function swap( + uint256 amount0Out, + uint256 amount1Out, + address to, + bytes calldata data + ) external; + + function sync() external; + + function initialize( + address _token0, + address _token1, + address _oracle, + address _trader + ) external; + + function getSwapAmount0In(uint256 amount1Out, bytes calldata data) external view returns (uint256 swapAmount0In); + + function getSwapAmount1In(uint256 amount0Out, bytes calldata data) external view returns (uint256 swapAmount1In); + + function getSwapAmount0Out(uint256 amount1In, bytes calldata data) external view returns (uint256 swapAmount0Out); + + function getSwapAmount1Out(uint256 amount0In, bytes calldata data) external view returns (uint256 swapAmount1Out); + + function getDepositAmount0In(uint256 amount0, bytes calldata data) external view returns (uint256 depositAmount0In); + + function getDepositAmount1In(uint256 amount1, bytes calldata data) external view returns (uint256 depositAmount1In); +} diff --git a/evm/src/integral/manifest.yaml b/evm/src/integral/manifest.yaml new file mode 100644 index 0000000..ac31df9 --- /dev/null +++ b/evm/src/integral/manifest.yaml @@ -0,0 +1,36 @@ +# information about the author helps us reach out in case of issues. +author: + name: Propellerheads.xyz + email: alan@propellerheads.xyz + +# Protocol Constants +constants: + protocol_gas: 30000 + # minimum capabilities we can expect, individual pools may extend these + capabilities: + - SellSide + - BuySide + - PriceFunction + +# The file containing the adapter contract +contract: IntegralSwapAdapter.sol + +# Deployment instances used to generate chain specific bytecode. +instances: + - chain: + name: mainnet + id: 0 + arguments: + - "0xd17b3c9784510E33cD5B87b490E79253BcD81e2E" + +# Specify some automatic test cases in case getPoolIds and +# getTokens are not implemented. +tests: + instances: + - pool_id: "0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc" + sell_token: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" + buy_token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" + block: 17000000 + chain: + id: 0 + name: mainnet diff --git a/evm/test/IntegralSwapAdapter.t.sol b/evm/test/IntegralSwapAdapter.t.sol new file mode 100644 index 0000000..3d41885 --- /dev/null +++ b/evm/test/IntegralSwapAdapter.t.sol @@ -0,0 +1,202 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +pragma solidity ^0.8.13; + +import "forge-std/Test.sol"; +import "openzeppelin-contracts/contracts/interfaces/IERC20.sol"; +import "src/interfaces/ISwapAdapterTypes.sol"; +import "src/libraries/FractionMath.sol"; +import "src/integral/IntegralSwapAdapter.sol"; + +contract IntegralSwapAdapterTest is Test, ISwapAdapterTypes { + using FractionMath for Fraction; + + IntegralSwapAdapter adapter; + ITwapRelayer relayer; + IERC20 constant WETH = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2); + IERC20 constant USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48); + address constant USDC_WETH_PAIR = + 0x2fe16Dd18bba26e457B7dD2080d5674312b026a2; + address constant relayerAddress = + 0xd17b3c9784510E33cD5B87b490E79253BcD81e2E; + + uint256 constant TEST_ITERATIONS = 100; + + function setUp() public { + uint256 forkBlock = 18835309; + vm.createSelectFork(vm.rpcUrl("mainnet"), forkBlock); + adapter = new IntegralSwapAdapter(relayerAddress); + relayer = ITwapRelayer(relayerAddress); + + vm.label(address(WETH), "WETH"); + vm.label(address(USDC), "USDC"); + vm.label(address(USDC_WETH_PAIR), "USDC_WETH_PAIR"); + } + + function testPriceFuzzIntegral(uint256 amount0, uint256 amount1) public { + bytes32 pair = bytes32(bytes20(USDC_WETH_PAIR)); + uint256[] memory limits = adapter.getLimits(pair, USDC, WETH); + vm.assume(amount0 < limits[0]); + vm.assume(amount1 < limits[1]); + + uint256[] memory amounts = new uint256[](2); + amounts[0] = amount0; + amounts[1] = amount1; + + Fraction[] memory prices = adapter.price(pair, WETH, USDC, amounts); + + for (uint256 i = 0; i < prices.length; i++) { + assertGt(prices[i].numerator, 0); + assertGt(prices[i].denominator, 0); + } + } + + /// @dev Since TwapRelayer's calculateAmountOut function is internal, and using quoteSell would + /// revert the transaction if calculateAmountOut is not enough, + /// we need a threshold to cover this internal amount, applied to + function testSwapFuzzIntegral(uint256 specifiedAmount, bool isBuy) public { + OrderSide side = isBuy ? OrderSide.Buy : OrderSide.Sell; + + bytes32 pair = bytes32(bytes20(USDC_WETH_PAIR)); + uint256[] memory limits = new uint256[](2); + uint256[] memory limitsMin = new uint256[](2); + + if (side == OrderSide.Buy) { + limits = adapter.getLimits(pair, USDC, WETH); + vm.assume(specifiedAmount < limits[1]); + + limitsMin = getMinLimits(USDC, WETH); + vm.assume(specifiedAmount > limitsMin[1] * 115 / 100); + + deal(address(USDC), address(this), type(uint256).max); + USDC.approve(address(adapter), type(uint256).max); + } else { + limits = adapter.getLimits(pair, USDC, WETH); + vm.assume(specifiedAmount < limits[0]); + + limitsMin = getMinLimits(USDC, WETH); + vm.assume(specifiedAmount > limitsMin[0] * 115 / 100); + + deal(address(USDC), address(this), type(uint256).max); + USDC.approve(address(adapter), specifiedAmount); + } + + uint256 usdc_balance_before = USDC.balanceOf(address(this)); + uint256 weth_balance_before = WETH.balanceOf(address(this)); + + Trade memory trade = adapter.swap( + pair, + USDC, + WETH, + side, + specifiedAmount + ); + + if (trade.calculatedAmount > 0) { + if (side == OrderSide.Buy) { + assertEq( + specifiedAmount, + WETH.balanceOf(address(this)) - weth_balance_before + ); + + assertEq( + trade.calculatedAmount, + usdc_balance_before - USDC.balanceOf(address(this)) + ); + } else { + assertEq( + specifiedAmount, + usdc_balance_before - USDC.balanceOf(address(this)) + ); + + assertEq( + trade.calculatedAmount, + WETH.balanceOf(address(this)) - weth_balance_before + ); + } + } + } + + function testSwapSellIncreasingIntegral() public { + executeIncreasingSwapsIntegral(OrderSide.Sell); + } + + function testSwapBuyIncreasing() public { + executeIncreasingSwapsIntegral(OrderSide.Buy); + } + + function executeIncreasingSwapsIntegral(OrderSide side) internal { + bytes32 pair = bytes32(bytes20(USDC_WETH_PAIR)); + + uint256 amountConstant_ = side == OrderSide.Sell ? 1000 * 10**6 : 10**17; + + uint256[] memory amounts = new uint256[](TEST_ITERATIONS); + amounts[0] = amountConstant_; + for (uint256 i = 1; i < TEST_ITERATIONS; i++) { + amounts[i] = amountConstant_ * i; + } + + Trade[] memory trades = new Trade[](TEST_ITERATIONS); + uint256 beforeSwap; + for (uint256 i = 1; i < TEST_ITERATIONS; i++) { + beforeSwap = vm.snapshot(); + + deal(address(USDC), address(this), amounts[i]); + USDC.approve(address(adapter), amounts[i]); + + trades[i] = adapter.swap(pair, USDC, WETH, side, amounts[i]); + vm.revertTo(beforeSwap); + } + + for (uint256 i = 1; i < TEST_ITERATIONS - 1; i++) { + assertLe( + trades[i].calculatedAmount, + trades[i + 1].calculatedAmount + ); + assertLe(trades[i].gasUsed, trades[i + 1].gasUsed); + assertEq(trades[i].price.compareFractions(trades[i + 1].price), 0); + } + } + + function testGetCapabilitiesIntegral( + bytes32 pair, + address t0, + address t1 + ) public { + Capability[] memory res = adapter.getCapabilities( + pair, + IERC20(t0), + IERC20(t1) + ); + + assertEq(res.length, 4); + } + + function testGetTokensIntegral() public { + bytes32 pair = bytes32(bytes20(USDC_WETH_PAIR)); + IERC20[] memory tokens = adapter.getTokens(pair); + + assertEq(tokens.length, 2); + } + + function testGetLimitsIntegral() public { + bytes32 pair = bytes32(bytes20(USDC_WETH_PAIR)); + uint256[] memory limits = adapter.getLimits(pair, USDC, WETH); + + assertEq(limits.length, 2); + } + + function getMinLimits(IERC20 sellToken, IERC20 buyToken) public view returns (uint256[] memory limits) { + ( + , + , + uint256 limitMin0, + , + uint256 limitMin1 + , + ) = relayer.getPoolState(address(sellToken), address(buyToken)); + + limits = new uint256[](2); + limits[0] = limitMin0; + limits[1] = limitMin1; + } +} \ No newline at end of file