From 87c0c8baba571782099515b760ba31dfbfb6bb6b Mon Sep 17 00:00:00 2001 From: pistomat Date: Wed, 27 Mar 2024 10:43:02 +0100 Subject: [PATCH] chore: forge fmt --- evm/src/balancer-v2/BalancerV2SwapAdapter.sol | 5 +- evm/src/integral/IntegralSwapAdapter.sol | 351 ++++++++++-------- evm/src/uniswap-v2/UniswapV2SwapAdapter.sol | 5 +- evm/test/IntegralSwapAdapter.t.sol | 129 +++---- evm/test/TemplateSwapAdapter.t.sol | 8 +- evm/test/UniswapV2SwapAdapter.t.sol | 4 +- 6 files changed, 271 insertions(+), 231 deletions(-) diff --git a/evm/src/balancer-v2/BalancerV2SwapAdapter.sol b/evm/src/balancer-v2/BalancerV2SwapAdapter.sol index 6413013..e373649 100644 --- a/evm/src/balancer-v2/BalancerV2SwapAdapter.sol +++ b/evm/src/balancer-v2/BalancerV2SwapAdapter.sol @@ -477,9 +477,8 @@ interface IVault { uint256 lastChangeBlock ); - enum SwapKind - /// The number of tokens to send to the Pool is known - { + enum SwapKind { + /// The number of tokens to send to the Pool is known GIVEN_IN, /// The number of tokens to take from the Pool is known GIVEN_OUT diff --git a/evm/src/integral/IntegralSwapAdapter.sol b/evm/src/integral/IntegralSwapAdapter.sol index 4797132..b79f1be 100644 --- a/evm/src/integral/IntegralSwapAdapter.sol +++ b/evm/src/integral/IntegralSwapAdapter.sol @@ -3,12 +3,15 @@ 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"; +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 +/// @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; +uint256 constant STANDARD_TOKEN_DECIMALS = 10 ** 18; /// @title Integral Swap Adapter contract IntegralSwapAdapter is ISwapAdapter { @@ -21,12 +24,18 @@ contract IntegralSwapAdapter is ISwapAdapter { } /// @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. + /// @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, @@ -34,8 +43,9 @@ contract IntegralSwapAdapter is ISwapAdapter { uint256[] memory _specifiedAmounts ) external view override returns (Fraction[] memory _prices) { _prices = new Fraction[](_specifiedAmounts.length); - Fraction memory price = getPriceAt(address(_sellToken), address(_buyToken)); - + Fraction memory price = + getPriceAt(address(_sellToken), address(_buyToken)); + for (uint256 i = 0; i < _specifiedAmounts.length; i++) { _prices[i] = price; } @@ -54,12 +64,12 @@ contract IntegralSwapAdapter is ISwapAdapter { } uint256 gasBefore = gasleft(); - if (side == OrderSide.Sell) { // sell - trade.calculatedAmount = - sell(sellToken, buyToken, specifiedAmount); - } else { // buy - trade.calculatedAmount = - buy(sellToken, buyToken, specifiedAmount); + 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)); @@ -72,21 +82,17 @@ contract IntegralSwapAdapter is ISwapAdapter { override returns (uint256[] memory limits) { - ( - , - , - , - uint256 limitMax0, - , - uint256 limitMax1 - ) = relayer.getPoolState(address(sellToken), address(buyToken)); + (,,, 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); + /** + * @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 */ } @@ -141,12 +147,12 @@ contract IntegralSwapAdapter is ISwapAdapter { /// @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); + 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!"); } @@ -154,15 +160,17 @@ contract IntegralSwapAdapter is ISwapAdapter { 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 - })); + 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; } @@ -172,12 +180,13 @@ contract IntegralSwapAdapter is ISwapAdapter { /// @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); + 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!"); } @@ -185,15 +194,17 @@ contract IntegralSwapAdapter is ISwapAdapter { 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 - })); + 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; } @@ -201,30 +212,43 @@ contract IntegralSwapAdapter is ISwapAdapter { /// @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)); + 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)); + address pairAddress = + factory.getPair(address(sellToken), address(buyToken)); // get swapFee formatted; swapFee is a constant - uint256 swapFeeFormatted = (STANDARD_TOKEN_DECIMALS - relayer.swapFee(pairAddress)); + uint256 swapFeeFormatted = + (STANDARD_TOKEN_DECIMALS - relayer.swapFee(pairAddress)); // get token decimals - uint256 sellTokenDecimals = 10**ERC20(sellToken).decimals(); - uint256 buyTokenDecimals = 10**ERC20(buyToken).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; + * 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 + * 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 + STANDARD_TOKEN_DECIMALS * sellTokenDecimals * swapFeeFormatted + / buyTokenDecimals ); } } @@ -276,8 +300,12 @@ interface ITwapRelayer { uint256 amountIn, uint256 indexed delayOrderId ); - event RebalanceSellWithOneInch(address indexed oneInchRouter, uint256 gas, bytes data); - event OneInchRouterWhitelisted(address indexed oneInchRouter, bool whitelisted); + event RebalanceSellWithOneInch( + address indexed oneInchRouter, uint256 gas, bytes data + ); + event OneInchRouterWhitelisted( + address indexed oneInchRouter, bool whitelisted + ); function factory() external pure returns (address); @@ -289,7 +317,10 @@ interface ITwapRelayer { function rebalancer() external view returns (address); - function isOneInchRouterWhitelisted(address oneInchRouter) external view returns (bool); + function isOneInchRouterWhitelisted(address oneInchRouter) + external + view + returns (bool); function setOwner(address _owner) external; @@ -309,19 +340,26 @@ interface ITwapRelayer { function tokenLimitMin(address token) external pure returns (uint256); - function tokenLimitMaxMultiplier(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 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 getTokenLimitMaxMultiplier(address token) + external + pure + returns (uint256); function getTwapInterval(address pair) external pure returns (uint32); @@ -335,7 +373,10 @@ interface ITwapRelayer { uint32 submitDeadline; } - function sell(SellParams memory sellParams) external payable returns (uint256 orderId); + function sell(SellParams memory sellParams) + external + payable + returns (uint256 orderId); struct BuyParams { address tokenIn; @@ -347,18 +388,20 @@ interface ITwapRelayer { uint32 submitDeadline; } - function buy(BuyParams memory buyParams) external payable returns (uint256 orderId); + 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 - ); + returns (uint8 xDecimals, uint8 yDecimals, uint256 price); - function getPriceByTokenAddresses(address tokenIn, address tokenOut) external view returns (uint256 price); + function getPriceByTokenAddresses(address tokenIn, address tokenOut) + external + view + returns (uint256 price); function getPoolState(address token0, address token1) external @@ -372,29 +415,19 @@ interface ITwapRelayer { uint256 limitMax1 ); - function quoteSell( - address tokenIn, - address tokenOut, - uint256 amountIn - ) external view returns (uint256 amountOut); + 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 quoteBuy(address tokenIn, address tokenOut, uint256 amountOut) + external + view + returns (uint256 amountIn); - function approve( - address token, - uint256 amount, - address to - ) external; + function approve(address token, uint256 amount, address to) external; - function withdraw( - address token, - uint256 amount, - address to - ) external; + function withdraw(address token, uint256 amount, address to) external; function rebalanceSellWithDelay( address tokenIn, @@ -412,12 +445,17 @@ interface ITwapRelayer { } interface ITwapFactory { - event PairCreated(address indexed token0, address indexed token1, address pair, uint256); + 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 getPair(address tokenA, address tokenB) + external + view + returns (address pair); function allPairs(uint256) external view returns (address pair); @@ -432,41 +470,19 @@ interface ITwapFactory { function setOwner(address) external; - function setMintFee( - address tokenA, - address tokenB, - uint256 fee - ) external; + function setMintFee(address tokenA, address tokenB, uint256 fee) external; - function setBurnFee( - 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 setSwapFee(address tokenA, address tokenB, uint256 fee) external; - function setOracle( - address tokenA, - address tokenB, - address oracle - ) external; + function setOracle(address tokenA, address tokenB, address oracle) + external; - function setTrader( - address tokenA, - address tokenB, - address trader - ) external; + function setTrader(address tokenA, address tokenB, address trader) + external; - function collect( - address tokenA, - address tokenB, - address to - ) external; + function collect(address tokenA, address tokenB, address to) external; function withdraw( address tokenA, @@ -491,20 +507,39 @@ interface ITwapERC20 is IERC20 { bytes32 s ) external; - function increaseAllowance(address spender, uint256 addedValue) external returns (bool); + function increaseAllowance(address spender, uint256 addedValue) + external + returns (bool); - function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool); + function decreaseAllowance(address spender, uint256 subtractedValue) + external + returns (bool); } interface IReserves { - function getReserves() external view returns (uint112 reserve0, uint112 reserve1); + 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 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, @@ -541,7 +576,9 @@ interface ITwapPair is ITwapERC20, IReserves { function setBurnFee(uint256 fee) external; - function burn(address to) external returns (uint256 amount0, uint256 amount1); + function burn(address to) + external + returns (uint256 amount0, uint256 amount1); function swapFee() external view returns (uint256); @@ -569,15 +606,33 @@ interface ITwapPair is ITwapERC20, IReserves { address _trader ) external; - function getSwapAmount0In(uint256 amount1Out, bytes calldata data) external view returns (uint256 swapAmount0In); + 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 getSwapAmount1In(uint256 amount0Out, bytes calldata data) + external + view + returns (uint256 swapAmount1In); - function getSwapAmount0Out(uint256 amount1In, bytes calldata data) external view returns (uint256 swapAmount0Out); + 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 getSwapAmount1Out(uint256 amount0In, bytes calldata data) + external + view + returns (uint256 swapAmount1Out); - function getDepositAmount0In(uint256 amount0, bytes calldata data) external view returns (uint256 depositAmount0In); + function getDepositAmount0In(uint256 amount0, bytes calldata data) + external + view + returns (uint256 depositAmount0In); - function getDepositAmount1In(uint256 amount1, bytes calldata data) external view returns (uint256 depositAmount1In); + function getDepositAmount1In(uint256 amount1, bytes calldata data) + external + view + returns (uint256 depositAmount1In); } diff --git a/evm/src/uniswap-v2/UniswapV2SwapAdapter.sol b/evm/src/uniswap-v2/UniswapV2SwapAdapter.sol index 16a1673..8704677 100644 --- a/evm/src/uniswap-v2/UniswapV2SwapAdapter.sol +++ b/evm/src/uniswap-v2/UniswapV2SwapAdapter.sol @@ -87,10 +87,9 @@ contract UniswapV2SwapAdapter is ISwapAdapter { buy(pair, sellToken, zero2one, r0, r1, specifiedAmount); } trade.gasUsed = gasBefore - gasleft(); - if(side == OrderSide.Sell) { + if (side == OrderSide.Sell) { trade.price = getPriceAt(specifiedAmount, r0, r1); - } - else { + } else { trade.price = getPriceAt(trade.calculatedAmount, r0, r1); } } diff --git a/evm/test/IntegralSwapAdapter.t.sol b/evm/test/IntegralSwapAdapter.t.sol index 3d41885..dcba8fb 100644 --- a/evm/test/IntegralSwapAdapter.t.sol +++ b/evm/test/IntegralSwapAdapter.t.sol @@ -1,103 +1,97 @@ // 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; - + 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 + + /// @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 + /// 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 - ); - + + 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)) @@ -107,7 +101,7 @@ contract IntegralSwapAdapterTest is Test, ISwapAdapterTypes { specifiedAmount, usdc_balance_before - USDC.balanceOf(address(this)) ); - + assertEq( trade.calculatedAmount, WETH.balanceOf(address(this)) - weth_balance_before @@ -127,76 +121,67 @@ contract IntegralSwapAdapterTest is Test, ISwapAdapterTypes { function executeIncreasingSwapsIntegral(OrderSide side) internal { bytes32 pair = bytes32(bytes20(USDC_WETH_PAIR)); - uint256 amountConstant_ = side == OrderSide.Sell ? 1000 * 10**6 : 10**17; - + 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].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) - ); - + + 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)); - + 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 +} diff --git a/evm/test/TemplateSwapAdapter.t.sol b/evm/test/TemplateSwapAdapter.t.sol index 8ace710..b0ac931 100644 --- a/evm/test/TemplateSwapAdapter.t.sol +++ b/evm/test/TemplateSwapAdapter.t.sol @@ -7,12 +7,14 @@ import "src/libraries/FractionMath.sol"; /// @title TemplateSwapAdapterTest /// @dev This is a template for a swap adapter test. -/// Test all functions that are implemented in your swap adapter, the two test included here are just an example. -/// Feel free to use UniswapV2SwapAdapterTest and BalancerV2SwapAdapterTest as a reference. +/// Test all functions that are implemented in your swap adapter, the two test +/// included here are just an example. +/// Feel free to use UniswapV2SwapAdapterTest and BalancerV2SwapAdapterTest as a +/// reference. contract TemplateSwapAdapterTest is Test, ISwapAdapterTypes { using FractionMath for Fraction; function testPriceFuzz(uint256 amount0, uint256 amount1) public {} function testSwapFuzz(uint256 specifiedAmount) public {} -} \ No newline at end of file +} diff --git a/evm/test/UniswapV2SwapAdapter.t.sol b/evm/test/UniswapV2SwapAdapter.t.sol index 960d0e1..b5a43fe 100644 --- a/evm/test/UniswapV2SwapAdapter.t.sol +++ b/evm/test/UniswapV2SwapAdapter.t.sol @@ -20,8 +20,8 @@ contract UniswapV2PairFunctionTest is Test, ISwapAdapterTypes { function setUp() public { uint256 forkBlock = 17000000; vm.createSelectFork(vm.rpcUrl("mainnet"), forkBlock); - adapter = new - UniswapV2SwapAdapter(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f); + adapter = + new UniswapV2SwapAdapter(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f); vm.label(address(adapter), "UniswapV2SwapAdapter"); vm.label(address(WETH), "WETH");