igneum/contracts/dex/test/Dex.t.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Vm, VM_ADDRESS} from "./Vm.sol";
import {WIGN} from "../src/WIGN.sol";
import {TestToken} from "../src/TestToken.sol";
import {IgneumFactory, IgneumPair} from "../src/IgneumPair.sol";
import {IgneumRouter} from "../src/IgneumRouter.sol";

/// The AMM end to end on Foundry's EVM: pair creation, liquidity in and out, token and IGN swaps, the faucet's
/// hour, the k check. Every number is a test number: Devnet 3, test tokens, no value.
contract DexTest {
    Vm constant vm = Vm(VM_ADDRESS);

    WIGN wign;
    TestToken tta;
    TestToken ttb;
    IgneumFactory factory;
    IgneumRouter router;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);

    receive() external payable {}

    function setUp() public {
        wign = new WIGN();
        tta = new TestToken("Test Token A", "TTA");
        ttb = new TestToken("Test Token B", "TTB");
        factory = new IgneumFactory();
        router = new IgneumRouter(address(factory), address(wign));
        vm.deal(alice, 1_000 ether);
        vm.deal(bob, 1_000 ether);
    }

    function _drip(address who) internal {
        vm.startPrank(who);
        tta.drip();
        ttb.drip();
        tta.approve(address(router), type(uint256).max);
        ttb.approve(address(router), type(uint256).max);
        vm.stopPrank();
    }

    function _seed() internal returns (address pairAB, address pairAW) {
        _drip(alice);
        vm.startPrank(alice);
        router.addLiquidity(address(tta), address(ttb), 500 ether, 500 ether, 0, 0, alice, block.timestamp + 60);
        router.addLiquidityIGN{value: 100 ether}(address(tta), 500 ether, 0, 0, alice, block.timestamp + 60);
        vm.stopPrank();
        pairAB = factory.getPair(address(tta), address(ttb));
        pairAW = factory.getPair(address(tta), address(wign));
    }

    function test_faucet_drips_once_an_hour() public {
        vm.prank(bob);
        tta.drip();
        require(tta.balanceOf(bob) == 1_000 ether, "drip amount");
        vm.prank(bob);
        vm.expectRevert(bytes("TestToken: one drip an hour"));
        tta.drip();
        vm.warp(block.timestamp + 1 hours);
        vm.prank(bob);
        tta.drip();
        require(tta.balanceOf(bob) == 2_000 ether, "second drip");
    }

    function test_add_liquidity_creates_pairs_and_mints() public {
        (address pairAB, address pairAW) = _seed();
        require(pairAB != address(0) && pairAW != address(0) && pairAB != pairAW, "pairs");
        require(factory.allPairsLength() == 2, "two pairs");
        (uint256 rA, uint256 rB) = router.getReserves(address(tta), address(ttb));
        require(rA == 500 ether && rB == 500 ether, "AB reserves");
        (uint256 rT, uint256 rW) = router.getReserves(address(tta), address(wign));
        require(rT == 500 ether && rW == 100 ether, "AW reserves");
        require(IgneumPair(pairAB).balanceOf(alice) == 500 ether - 1000, "LP minus the locked minimum");
        require(IgneumPair(pairAB).balanceOf(address(0xdead)) == 1000, "locked minimum");
        require(wign.balanceOf(pairAW) == 100 ether, "WIGN held by the pair");
    }

    function test_swap_exact_tokens_for_tokens_keeps_k() public {
        (address pairAB,) = _seed();
        _drip(bob);
        address[] memory path = new address[](2);
        path[0] = address(tta);
        path[1] = address(ttb);
        uint256[] memory quoted = router.getAmountsOut(10 ether, path);
        // 10 in at 0.3 percent on 500/500: 10*997*500 / (500*1000 + 10*997) tokens
        require(quoted[1] == 9775084808910328058, "quote");
        (uint112 r0b, uint112 r1b,) = IgneumPair(pairAB).getReserves();
        vm.prank(bob);
        uint256[] memory amounts = router.swapExactTokensForTokens(10 ether, quoted[1], path, bob, block.timestamp + 60);
        require(amounts[1] == quoted[1], "swap matches the quote");
        require(ttb.balanceOf(bob) == 1_000 ether + quoted[1], "bob received");
        (uint112 r0a, uint112 r1a,) = IgneumPair(pairAB).getReserves();
        require(uint256(r0a) * uint256(r1a) >= uint256(r0b) * uint256(r1b), "k did not fall");
    }

    function test_swap_ign_both_ways() public {
        _seed();
        address[] memory path = new address[](2);
        path[0] = address(wign);
        path[1] = address(tta);
        uint256 before = tta.balanceOf(bob);
        vm.prank(bob);
        uint256[] memory amounts = router.swapExactIGNForTokens{value: 1 ether}(0, path, bob, block.timestamp + 60);
        require(tta.balanceOf(bob) == before + amounts[1] && amounts[1] > 4.9 ether && amounts[1] < 5 ether, "IGN to TTA");
        path[0] = address(tta);
        path[1] = address(wign);
        uint256 ignBefore = bob.balance;
        vm.startPrank(bob);
        tta.approve(address(router), type(uint256).max);
        uint256[] memory back = router.swapExactTokensForIGN(amounts[1], 0, path, bob, block.timestamp + 60);
        vm.stopPrank();
        require(bob.balance == ignBefore + back[1] && back[1] < 1 ether && back[1] > 0.99 ether, "TTA to IGN");
    }

    function test_remove_liquidity_returns_both_tokens() public {
        (address pairAB,) = _seed();
        uint256 lp = IgneumPair(pairAB).balanceOf(alice);
        vm.startPrank(alice);
        IgneumPair(pairAB).approve(address(router), lp);
        (uint256 a, uint256 b) = router.removeLiquidity(address(tta), address(ttb), lp, 0, 0, alice, block.timestamp + 60);
        vm.stopPrank();
        require(a == 500 ether - 1000 && b == 500 ether - 1000, "pro rata minus the locked share");
        require(IgneumPair(pairAB).balanceOf(alice) == 0, "LP burned");
    }

    function test_expired_deadline_is_refused() public {
        _seed();
        address[] memory path = new address[](2);
        path[0] = address(tta);
        path[1] = address(ttb);
        vm.prank(alice);
        vm.expectRevert(bytes("Router: expired"));
        router.swapExactTokensForTokens(1 ether, 0, path, alice, block.timestamp - 1);
    }
}