Liquidity.Party/tycho-protocol-sdk
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #5 from propeller-heads/feature/integral-adapter

Browse Source 
Feature/integral adapter
This commit is contained in:
Alan Höng
2024-01-25 09:04:25 -03:00
committed by GitHub
parent b37ecaeeb0 f4f56ad42d
commit f781bc709d
5 changed files with 826 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
.vscode/settings.json vendored
View File

@@ -1,6 +0,0 @@
{
"solidity.formatter": "forge",
"solidity.compileUsingRemoteVersion": "v0.8.20",
"solidity.packageDefaultDependenciesContractsDirectory": "evm/src",
"solidity.packageDefaultDependenciesDirectory": "evm/lib",
}

5
evm/.gitignore vendored
View File

@@ -1,6 +1,7 @@
# Compiler files # Compiler files
cache/ cache/
out/ out/
coverage/
# Ignores development broadcast logs # Ignores development broadcast logs
!/broadcast !/broadcast
@@ -12,3 +13,7 @@ docs/
# Dotenv file # Dotenv file
.env .env
# Others
.DS_STORE
lcov.info

583
evm/src/integral/IntegralSwapAdapter.sol Normal file
View File

@@ -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);
}

36
evm/src/integral/manifest.yaml Normal file
View File

@@ -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

202
evm/test/IntegralSwapAdapter.t.sol Normal file
View File

@@ -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;
}
}