Merge branch 'main' into feature/angle-adapter
This commit is contained in:
Ale personal
5
evm/.gitignore
vendored
5
evm/.gitignore
vendored
@@ -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
|
||||
|
||||
583
evm/src/integral/IntegralSwapAdapter.sol
Normal file
583
evm/src/integral/IntegralSwapAdapter.sol
Normal 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
36
evm/src/integral/manifest.yaml
Normal 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
|
||||
@@ -87,7 +87,12 @@ contract UniswapV2SwapAdapter is ISwapAdapter {
|
||||
buy(pair, sellToken, zero2one, r0, r1, specifiedAmount);
|
||||
}
|
||||
trade.gasUsed = gasBefore - gasleft();
|
||||
trade.price = getPriceAt(specifiedAmount, r0, r1);
|
||||
if(side == OrderSide.Sell) {
|
||||
trade.price = getPriceAt(specifiedAmount, r0, r1);
|
||||
}
|
||||
else {
|
||||
trade.price = getPriceAt(trade.calculatedAmount, r0, r1);
|
||||
}
|
||||
}
|
||||
|
||||
/// @notice Executes a sell order on a given pool.
|
||||
|
||||
202
evm/test/IntegralSwapAdapter.t.sol
Normal file
202
evm/test/IntegralSwapAdapter.t.sol
Normal 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;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user