134 lines
4.6 KiB
Solidity
134 lines
4.6 KiB
Solidity
// 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/uniswap-v2/UniswapV2SwapAdapter.sol";
|
|
import "src/interfaces/ISwapAdapterTypes.sol";
|
|
|
|
contract UniswapV2PairFunctionTest is Test, ISwapAdapterTypes {
|
|
UniswapV2SwapAdapter pairFunctions;
|
|
IERC20 constant WETH = IERC20(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
|
|
IERC20 constant USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
|
|
address constant USDC_WETH_PAIR = 0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc;
|
|
|
|
function setUp() public {
|
|
uint256 forkBlock = 17000000;
|
|
vm.createSelectFork(vm.rpcUrl("mainnet"), forkBlock);
|
|
pairFunctions = new
|
|
UniswapV2SwapAdapter(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
|
|
}
|
|
|
|
function testPriceFuzz(uint256 amount0, uint256 amount1) public {
|
|
bytes32 pair = bytes32(bytes20(USDC_WETH_PAIR));
|
|
uint256[] memory limits = pairFunctions.getLimits(pair, SwapSide.Sell);
|
|
vm.assume(amount0 < limits[0]);
|
|
vm.assume(amount1 < limits[0]);
|
|
|
|
uint256[] memory amounts = new uint256[](2);
|
|
amounts[0] = amount0;
|
|
amounts[1] = amount1;
|
|
|
|
Fraction[] memory prices =
|
|
pairFunctions.price(pair, WETH, USDC, amounts);
|
|
|
|
for (uint256 i = 0; i < prices.length; i++) {
|
|
assertGt(prices[i].numerator, 0);
|
|
assertGt(prices[i].denominator, 0);
|
|
}
|
|
}
|
|
|
|
function testPriceDecreasing() public {
|
|
bytes32 pair = bytes32(bytes20(USDC_WETH_PAIR));
|
|
uint256[] memory amounts = new uint256[](100);
|
|
|
|
for (uint256 i = 0; i < 100; i++) {
|
|
amounts[i] = 1000 * i * 10 ** 6;
|
|
}
|
|
|
|
Fraction[] memory prices =
|
|
pairFunctions.price(pair, WETH, USDC, amounts);
|
|
|
|
for (uint256 i = 0; i < 99; i++) {
|
|
assertEq(compareFractions(prices[i], prices[i + 1]), 1);
|
|
assertGt(prices[i].denominator, 0);
|
|
assertGt(prices[i + 1].denominator, 0);
|
|
}
|
|
}
|
|
|
|
function compareFractions(Fraction memory frac1, Fraction memory frac2)
|
|
internal
|
|
pure
|
|
returns (int8)
|
|
{
|
|
uint256 crossProduct1 = frac1.numerator * frac2.denominator;
|
|
uint256 crossProduct2 = frac2.numerator * frac1.denominator;
|
|
|
|
// fractions are equal
|
|
if (crossProduct1 == crossProduct2) return 0;
|
|
// frac1 is greater than frac2
|
|
else if (crossProduct1 > crossProduct2) return 1;
|
|
// frac1 is less than frac2
|
|
else return -1;
|
|
}
|
|
|
|
function testSwapFuzz(uint256 amount, bool isBuy) public {
|
|
bytes32 pair = bytes32(bytes20(USDC_WETH_PAIR));
|
|
SwapSide side = SwapSide.Sell;
|
|
if (isBuy) {
|
|
side = SwapSide.Buy;
|
|
}
|
|
uint256[] memory limits = pairFunctions.getLimits(pair, side);
|
|
vm.assume(amount < limits[0]);
|
|
deal(address(USDC), address(this), amount);
|
|
USDC.approve(address(pairFunctions), amount);
|
|
|
|
pairFunctions.swap(pair, USDC, WETH, side, amount);
|
|
}
|
|
|
|
function testSwapSellIncreasing() public {
|
|
executeIncreasingSwaps(SwapSide.Sell);
|
|
}
|
|
|
|
function executeIncreasingSwaps(SwapSide side) internal {
|
|
bytes32 pair = bytes32(bytes20(USDC_WETH_PAIR));
|
|
|
|
uint256[] memory amounts = new uint256[](100);
|
|
for (uint256 i = 0; i < 100; i++) {
|
|
amounts[i] = 1000 * i * 10 ** 6;
|
|
}
|
|
|
|
Trade[] memory trades = new Trade [](100);
|
|
uint256 beforeSwap;
|
|
for (uint256 i = 0; i < 100; i++) {
|
|
beforeSwap = vm.snapshot();
|
|
deal(address(USDC), address(this), amounts[i]);
|
|
USDC.approve(address(pairFunctions), amounts[i]);
|
|
trades[i] = pairFunctions.swap(pair, USDC, WETH, side, amounts[i]);
|
|
vm.revertTo(beforeSwap);
|
|
}
|
|
|
|
for (uint256 i = 1; i < 99; i++) {
|
|
assertLe(trades[i].receivedAmount, trades[i + 1].receivedAmount);
|
|
assertLe(trades[i].gasUsed, trades[i + 1].gasUsed);
|
|
assertEq(compareFractions(trades[i].price, trades[i + 1].price), 1);
|
|
}
|
|
}
|
|
|
|
function testSwapBuyIncreasing() public {
|
|
executeIncreasingSwaps(SwapSide.Buy);
|
|
}
|
|
|
|
function testGetCapabilities(bytes32 pair, address t0, address t1) public {
|
|
Capability[] memory res =
|
|
pairFunctions.getCapabilities(pair, IERC20(t0), IERC20(t1));
|
|
|
|
assertEq(res.length, 3);
|
|
}
|
|
|
|
function testGetLimits() public {
|
|
bytes32 pair = bytes32(bytes20(USDC_WETH_PAIR));
|
|
uint256[] memory limits = pairFunctions.getLimits(pair, SwapSide.Sell);
|
|
}
|
|
}
|