// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SwarmExit} from "src/SwarmExit.sol";

contract PlainToken is ERC20 {
    constructor(string memory n) ERC20(n, n) {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @notice Minimal constant-product V2 router: pulls tokenIn, pays tokenOut from its own reserves.
contract TinyV2Router {
    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts) {
        amounts = new uint256[](path.length);
        amounts[0] = amountIn;
        amounts[1] = _out(path[0], path[1], amountIn);
    }

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256,
        address[] calldata path,
        address to,
        uint256
    ) external {
        uint256 out = _out(path[0], path[1], amountIn);
        IERC20(path[0]).transferFrom(msg.sender, address(this), amountIn);
        IERC20(path[1]).transfer(to, out);
    }

    function _out(address tokenIn, address tokenOut, uint256 amountIn) internal view returns (uint256) {
        uint256 rIn = IERC20(tokenIn).balanceOf(address(this));
        uint256 rOut = IERC20(tokenOut).balanceOf(address(this));
        return (amountIn * 997 * rOut) / (rIn * 1000 + amountIn * 997);
    }
}

/// @dev Fails on the current code: a third party sending 1 wei of a swarm token to the seller after the
/// seller approved their exact balance makes the whole `sellAll` revert (ERC20InsufficientAllowance),
/// because `_sellOne` pulls `balanceOf(user)` instead of the approved amount. Passes once `sellAll`
/// pulls `min(balance, allowance)` (or an explicit amount) and the approved tokens are sold.
contract GriefProofTest is Test {
    address constant OWNER = 0x0acE1DBE8AAb293cd58D5e3Ea38814f0ccb74782;
    address constant IMD_ADDR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;

    SwarmExit exit;
    PlainToken imd;
    PlainToken tokenA;
    TinyV2Router router;
    address user = makeAddr("user");
    address attacker = makeAddr("attacker");

    function setUp() public {
        vm.warp(1_760_000_000);
        vm.etch(IMD_ADDR, address(new PlainToken("IMD")).code);
        imd = PlainToken(IMD_ADDR);
        tokenA = new PlainToken("A");
        router = new TinyV2Router();
        tokenA.mint(address(router), 1_000_000e18);
        imd.mint(address(router), 1_000_000e18);

        exit = new SwarmExit(OWNER);
        address[] memory path = new address[](2);
        path[0] = address(tokenA);
        path[1] = IMD_ADDR;
        vm.startPrank(OWNER);
        exit.setSwarmToken(address(tokenA), true);
        exit.setTokenRoute(address(tokenA), SwarmExit.Venue.UniswapV2, address(router), address(0), abi.encode(path));
        vm.stopPrank();

        tokenA.mint(user, 10_000e18);
    }

    function test_oneWeiFromThirdPartyMustNotBlockTheSale() public {
        uint256 approved = tokenA.balanceOf(user);
        vm.prank(user);
        tokenA.approve(address(exit), approved); // exact-balance approval, as web/app.js does

        // Attacker front-runs the sale with 1 wei.
        tokenA.mint(attacker, 1);
        vm.prank(attacker);
        tokenA.transfer(user, 1);

        address[] memory tokens = new address[](1);
        tokens[0] = address(tokenA);
        uint256[] memory mins = new uint256[](1);

        vm.prank(user);
        (SwarmExit.Outcome[] memory out,,, uint256 net) = exit.sellAll(tokens, mins, block.timestamp);

        assertTrue(out[0].status == SwarmExit.Status.Sold, "approved balance should still sell");
        assertGt(net, 0, "user should receive IMD");
        assertEq(imd.balanceOf(user), net);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {SwarmExit} from "src/SwarmExit.sol";
import {IUniswapV2Router} from "src/interfaces/IDexVenues.sol";

contract PlainToken is ERC20 {
    constructor(string memory n) ERC20(n, n) {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @dev Minimal V2-style router: a fixed 1:2 rate, pulls exactly amountIn, pays tokenOut it holds.
contract FixedRateRouter is IUniswapV2Router {
    using SafeERC20 for IERC20;

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        pure
        returns (uint256[] memory amounts)
    {
        amounts = new uint256[](path.length);
        amounts[0] = amountIn;
        amounts[path.length - 1] = amountIn * 2;
    }

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256,
        address[] calldata path,
        address to,
        uint256
    ) external {
        IERC20(path[0]).safeTransferFrom(msg.sender, address(this), amountIn);
        IERC20(path[path.length - 1]).safeTransfer(to, amountIn * 2);
    }
}

/// @notice `sellAll` pulls `balanceOf(user)` at execution time, not the amount the user approved.
/// The website approves the exact balance it displayed. Anyone who sends the user one wei of a
/// listed token between approval and execution makes the whole sale revert.
contract ExactBalancePullGriefTest is Test {
    address constant OWNER = 0x0acE1DBE8AAb293cd58D5e3Ea38814f0ccb74782;
    address constant IMD_ADDR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;

    SwarmExit exit;
    PlainToken tokenA;
    FixedRateRouter router;
    address user = makeAddr("user");
    address griefer = makeAddr("griefer");

    function setUp() public {
        vm.warp(1_760_000_000);
        vm.etch(IMD_ADDR, address(new PlainToken("IMD")).code);
        router = new FixedRateRouter();
        PlainToken(IMD_ADDR).mint(address(router), 1_000_000e18);
        tokenA = new PlainToken("A");
        exit = new SwarmExit(OWNER);

        address[] memory path = new address[](2);
        path[0] = address(tokenA);
        path[1] = IMD_ADDR;
        vm.startPrank(OWNER);
        exit.setSwarmToken(address(tokenA), true);
        exit.setTokenRoute(address(tokenA), SwarmExit.Venue.UniswapV2, address(router), address(0), abi.encode(path));
        vm.stopPrank();

        tokenA.mint(user, 10_000e18);
        tokenA.mint(griefer, 1);
    }

    function test_oneWeiDonationAfterExactApprovalDoesNotBlockTheSale() public {
        // The website approves exactly the balance it showed (web/app.js ensureApprovals).
        vm.prank(user);
        tokenA.approve(address(exit), 10_000e18);

        // Anyone front-runs the sale with a 1 wei transfer to the user.
        vm.prank(griefer);
        tokenA.transfer(user, 1);

        address[] memory tokens = new address[](1);
        tokens[0] = address(tokenA);
        uint256[] memory mins = new uint256[](1);

        // Expected: the approved 10_000e18 is sold (or at least the sale does not revert).
        // Actual: the contract pulls balanceOf(user) = 10_000e18 + 1 and reverts with
        // ERC20InsufficientAllowance, so the user cannot sell anything.
        vm.prank(user);
        (SwarmExit.Outcome[] memory out,,, uint256 net) = exit.sellAll(tokens, mins, block.timestamp);
        assertTrue(out[0].status == SwarmExit.Status.Sold);
        assertGt(net, 0);
        assertEq(IERC20(IMD_ADDR).balanceOf(user), net);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {SwarmExit} from "src/SwarmExit.sol";
import {IUniswapV2Router} from "src/interfaces/IDexVenues.sol";

contract PlainToken is ERC20 {
    constructor(string memory n) ERC20(n, n) {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @dev Honeypot variant: holders can transfer freely, but `approve` reverts for every caller
/// except the ones the token's owner whitelisted (a common "trading not open" pattern).
contract ApproveBlockedToken is ERC20 {
    mapping(address => bool) public allowedApprover;

    constructor() ERC20("Trap", "TRAP") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }

    function setAllowedApprover(address who, bool ok) external {
        allowedApprover[who] = ok;
    }

    function _approve(address owner_, address spender, uint256 value, bool emitEvent) internal override {
        require(allowedApprover[owner_], "TRAP: approvals closed");
        super._approve(owner_, spender, value, emitEvent);
    }
}

/// @dev Minimal V2-style router: a fixed 1:2 rate, pulls exactly amountIn, pays tokenOut it holds.
contract FixedRateRouter is IUniswapV2Router {
    using SafeERC20 for IERC20;

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        pure
        returns (uint256[] memory amounts)
    {
        amounts = new uint256[](path.length);
        amounts[0] = amountIn;
        amounts[path.length - 1] = amountIn * 2;
    }

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256,
        address[] calldata path,
        address to,
        uint256
    ) external {
        IERC20(path[0]).safeTransferFrom(msg.sender, address(this), amountIn);
        IERC20(path[path.length - 1]).safeTransfer(to, amountIn * 2);
    }
}

/// @notice The refund path in `_sellOne`'s catch block calls `forceApprove` on the token whose
/// sale just failed. If that token's `approve` reverts (which is exactly why the sale failed),
/// the catch block reverts too and the whole `sellAll` reverts instead of refunding that token
/// and selling the others.
contract RefundPathRevertsTest is Test {
    address constant OWNER = 0x0acE1DBE8AAb293cd58D5e3Ea38814f0ccb74782;
    address constant IMD_ADDR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;

    SwarmExit exit;
    PlainToken good;
    ApproveBlockedToken trap;
    FixedRateRouter router;
    address user = makeAddr("user");

    function setUp() public {
        vm.warp(1_760_000_000);
        vm.etch(IMD_ADDR, address(new PlainToken("IMD")).code);
        router = new FixedRateRouter();
        PlainToken(IMD_ADDR).mint(address(router), 1_000_000e18);
        good = new PlainToken("GOOD");
        trap = new ApproveBlockedToken();
        trap.setAllowedApprover(user, true); // the user can approve SwarmExit; SwarmExit cannot approve the router
        exit = new SwarmExit(OWNER);

        vm.startPrank(OWNER);
        exit.setSwarmToken(address(good), true);
        exit.setSwarmToken(address(trap), true);
        exit.setTokenRoute(
            address(good), SwarmExit.Venue.UniswapV2, address(router), address(0), _path(address(good), IMD_ADDR)
        );
        exit.setTokenRoute(
            address(trap), SwarmExit.Venue.UniswapV2, address(router), address(0), _path(address(trap), IMD_ADDR)
        );
        vm.stopPrank();

        good.mint(user, 1_000e18);
        trap.mint(user, 1_000e18);
        vm.startPrank(user);
        good.approve(address(exit), type(uint256).max);
        trap.approve(address(exit), type(uint256).max);
        vm.stopPrank();
    }

    function _path(address a, address b) internal pure returns (bytes memory) {
        address[] memory p = new address[](2);
        p[0] = a;
        p[1] = b;
        return abi.encode(p);
    }

    function test_tokenWhoseApproveRevertsIsRefundedAndOthersStillSell() public {
        address[] memory tokens = new address[](2);
        tokens[0] = address(trap);
        tokens[1] = address(good);
        uint256[] memory mins = new uint256[](2);

        // Expected (README and NatSpec): trap is refunded with status SaleFailed, good is sold.
        // Actual: `erc.forceApprove(route.router, 0)` inside the catch block reverts with
        // "TRAP: approvals closed", so the entire sellAll reverts and nothing can be sold.
        vm.prank(user);
        (SwarmExit.Outcome[] memory out,,,) = exit.sellAll(tokens, mins, block.timestamp);
        assertTrue(out[0].status == SwarmExit.Status.SaleFailed);
        assertEq(trap.balanceOf(user), 1_000e18, "trap refunded");
        assertTrue(out[1].status == SwarmExit.Status.Sold);
        assertEq(good.balanceOf(user), 0);
        assertGt(IERC20(IMD_ADDR).balanceOf(user), 0);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {SwarmExit} from "src/SwarmExit.sol";
import {IUniswapV2Router} from "src/interfaces/IDexVenues.sol";

/// @dev Minimal constant-product pool shared by the mock router.
contract Pool {
    using SafeERC20 for IERC20;

    mapping(bytes32 => uint256) public rA;
    mapping(bytes32 => uint256) public rB;

    function key(address a, address b) public pure returns (bytes32, bool) {
        return a < b ? (keccak256(abi.encode(a, b)), false) : (keccak256(abi.encode(b, a)), true);
    }

    function add(address a, address b, uint256 x, uint256 y) external {
        IERC20(a).safeTransferFrom(msg.sender, address(this), x);
        IERC20(b).safeTransferFrom(msg.sender, address(this), y);
        (bytes32 k, bool f) = key(a, b);
        if (f) (x, y) = (y, x);
        rA[k] += x;
        rB[k] += y;
    }

    function out(address i, address o, uint256 amt) public view returns (uint256) {
        (bytes32 k, bool f) = key(i, o);
        uint256 ri = f ? rB[k] : rA[k];
        uint256 ro = f ? rA[k] : rB[k];
        require(ri > 0 && ro > 0, "no liquidity");
        uint256 w = amt * 997;
        return (w * ro) / (ri * 1000 + w);
    }

    function swap(address i, address o, uint256 amt, address to) external returns (uint256 got) {
        uint256 b = IERC20(i).balanceOf(address(this));
        IERC20(i).safeTransferFrom(msg.sender, address(this), amt);
        uint256 recv = IERC20(i).balanceOf(address(this)) - b;
        got = out(i, o, recv);
        (bytes32 k, bool f) = key(i, o);
        if (f) {
            rB[k] += recv;
            rA[k] -= got;
        } else {
            rA[k] += recv;
            rB[k] -= got;
        }
        IERC20(o).safeTransfer(to, got);
    }
}

contract Router is IUniswapV2Router {
    using SafeERC20 for IERC20;

    Pool public immutable pool;

    constructor(Pool p) {
        pool = p;
    }

    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory a) {
        a = new uint256[](path.length);
        a[0] = amountIn;
        for (uint256 i; i + 1 < path.length; ++i) {
            a[i + 1] = pool.out(path[i], path[i + 1], a[i]);
        }
    }

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256
    ) external {
        IERC20(path[0]).safeTransferFrom(msg.sender, address(this), amountIn);
        uint256 amt = IERC20(path[0]).balanceOf(address(this));
        for (uint256 i; i + 1 < path.length; ++i) {
            IERC20(path[i]).forceApprove(address(pool), amt);
            address rcpt = i + 2 == path.length ? to : address(this);
            amt = pool.swap(path[i], path[i + 1], amt, rcpt);
        }
        require(amt >= amountOutMin, "INSUFFICIENT_OUTPUT_AMOUNT");
    }
}

contract Plain is ERC20 {
    constructor() ERC20("P", "P") {}

    function mint(address to, uint256 a) external {
        _mint(to, a);
    }
}

/// @dev "Transfer delay" anti-bot token (one transfer per block per tx.origin, exempting the router
/// and the pair). The user's pull sets the origin's block; the sale's transfer into the pool then
/// reverts, and so does the refund back to the user.
contract TransferDelayToken is ERC20 {
    address public router;
    mapping(address => uint256) public lastBlock;

    constructor() ERC20("D", "D") {}

    function setRouter(address r) external {
        router = r;
    }

    function mint(address to, uint256 a) external {
        _mint(to, a);
    }

    function _update(address from, address to, uint256 value) internal override {
        if (from != address(0) && to != router) {
            require(lastBlock[tx.origin] < block.number, "Only one transfer per block allowed.");
            lastBlock[tx.origin] = block.number;
        }
        super._update(from, to, value);
    }
}

contract RefundRevertTest is Test {
    address constant OWNER = 0x0acE1DBE8AAb293cd58D5e3Ea38814f0ccb74782;
    address constant IMD_ADDR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;

    SwarmExit exit;
    Plain imd;
    Plain good;
    TransferDelayToken bad;
    Pool pool;
    Router router;
    address user = makeAddr("user");

    function setUp() public {
        vm.etch(IMD_ADDR, address(new Plain()).code);
        imd = Plain(IMD_ADDR);
        pool = new Pool();
        router = new Router(pool);
        exit = new SwarmExit(OWNER);
        good = new Plain();
        bad = new TransferDelayToken();
        bad.setRouter(address(router));

        _liq(address(good), 1_000_000e18, 100_000e18);
        _liq(address(bad), 1_000_000e18, 100_000e18);

        address[] memory pGood = new address[](2);
        pGood[0] = address(good);
        pGood[1] = IMD_ADDR;
        address[] memory pBad = new address[](2);
        pBad[0] = address(bad);
        pBad[1] = IMD_ADDR;
        vm.startPrank(OWNER);
        exit.setSwarmToken(address(good), true);
        exit.setSwarmToken(address(bad), true);
        exit.setTokenRoute(address(good), SwarmExit.Venue.UniswapV2, address(router), address(0), abi.encode(pGood));
        exit.setTokenRoute(address(bad), SwarmExit.Venue.UniswapV2, address(router), address(0), abi.encode(pBad));
        vm.stopPrank();

        good.mint(user, 1_000e18);
        bad.mint(user, 1_000e18);
        vm.startPrank(user);
        good.approve(address(exit), type(uint256).max);
        bad.approve(address(exit), type(uint256).max);
        vm.stopPrank();
    }

    function _liq(address t, uint256 x, uint256 y) internal {
        address lp = makeAddr("lp");
        Plain(t).mint(lp, x);
        imd.mint(lp, y);
        vm.startPrank(lp);
        IERC20(t).approve(address(pool), x);
        imd.approve(address(pool), y);
        pool.add(t, IMD_ADDR, x, y);
        vm.stopPrank();
    }

    /// Expected: `bad` fails to sell and is refunded (or held for the user), `good` is sold.
    /// Actual on the current code: the refund transfer in the catch block reverts and the whole
    /// `sellAll` reverts, so `good` cannot be sold either.
    function test_refundThatRevertsMustNotBlockOtherSales() public {
        address[] memory tokens = new address[](2);
        tokens[0] = address(bad);
        tokens[1] = address(good);
        uint256[] memory mins = new uint256[](2);
        uint256 badBefore = bad.balanceOf(user);

        vm.prank(user, user);
        (SwarmExit.Outcome[] memory out,,,) = exit.sellAll(tokens, mins, block.timestamp);

        assertTrue(out[1].status == SwarmExit.Status.Sold, "good token sold");
        assertGt(imd.balanceOf(user), 0, "user received IMD for the good token");
        assertTrue(out[0].status == SwarmExit.Status.SaleFailed, "bad token not sold");
        assertEq(bad.balanceOf(user) + bad.balanceOf(address(exit)), badBefore, "bad token not lost");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {SwarmExit} from "src/SwarmExit.sol";

contract PToken is ERC20 {
    constructor() ERC20("T", "T") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @dev Minimal constant-product V2 router: one pair, pulls tokenIn, pays tokenOut from its own balance.
contract PRouter {
    using SafeERC20 for IERC20;

    mapping(address => uint256) public reserve;

    function add(address token, uint256 amount) external {
        IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
        reserve[token] += amount;
    }

    function _out(address tIn, address tOut, uint256 amountIn) internal view returns (uint256) {
        uint256 inWithFee = amountIn * 997;
        return (inWithFee * reserve[tOut]) / (reserve[tIn] * 1000 + inWithFee);
    }

    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory a) {
        a = new uint256[](2);
        a[0] = amountIn;
        a[1] = _out(path[0], path[1], amountIn);
    }

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256,
        address[] calldata path,
        address to,
        uint256
    ) external {
        IERC20(path[0]).safeTransferFrom(msg.sender, address(this), amountIn);
        uint256 out = _out(path[0], path[1], amountIn);
        reserve[path[0]] += amountIn;
        reserve[path[1]] -= out;
        IERC20(path[1]).safeTransfer(to, out);
    }
}

/// @notice `sellAll` settles a token whose sale yields zero IMD as `Sold` and keeps the tokens.
/// Expected: a sale that produces nothing (below the contract's own `minImdOut` dust threshold, and
/// in particular exactly zero) is refunded like any other failed sale, so the user never gives up
/// tokens for nothing. Actual: status `Sold`, `imdOut == 0`, user balance 0, tokens sit in the pool.
contract ZeroProceedsProofTest is Test {
    address constant OWNER = 0x0acE1DBE8AAb293cd58D5e3Ea38814f0ccb74782;
    address constant IMD_ADDR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;

    SwarmExit exit;
    PRouter router;
    PToken dust; // pool so skewed that any sale rounds to 0 IMD
    PToken good; // normal pool
    address user = makeAddr("user");

    function setUp() public {
        vm.etch(IMD_ADDR, address(new PToken()).code);
        router = new PRouter();
        dust = new PToken();
        good = new PToken();
        exit = new SwarmExit(OWNER);

        // dust/IMD pool: 1e30 dust vs 1 wei IMD -> output always rounds to 0
        dust.mint(address(this), 1e30);
        PToken(IMD_ADDR).mint(address(this), 1);
        dust.approve(address(router), 1e30);
        IERC20(IMD_ADDR).approve(address(router), 1);
        router.add(address(dust), 1e30);
        router.add(IMD_ADDR, 1);

        // good token: separate router instance for an honest pool
        vm.startPrank(OWNER);
        exit.setSwarmToken(address(dust), true);
        exit.setTokenRoute(address(dust), SwarmExit.Venue.UniswapV2, address(router), address(0), _path(address(dust), IMD_ADDR));
        exit.setSwarmToken(address(good), true);
        vm.stopPrank();

        PRouter goodRouter = new PRouter();
        good.mint(address(this), 1_000e18);
        PToken(IMD_ADDR).mint(address(this), 1_000e18);
        good.approve(address(goodRouter), 1_000e18);
        IERC20(IMD_ADDR).approve(address(goodRouter), 1_000e18);
        goodRouter.add(address(good), 1_000e18);
        goodRouter.add(IMD_ADDR, 1_000e18);
        vm.prank(OWNER);
        exit.setTokenRoute(
            address(good), SwarmExit.Venue.UniswapV2, address(goodRouter), address(0), _path(address(good), IMD_ADDR)
        );

        dust.mint(user, 1_000e18);
        good.mint(user, 10e18);
        vm.startPrank(user);
        dust.approve(address(exit), type(uint256).max);
        good.approve(address(exit), type(uint256).max);
        vm.stopPrank();
    }

    function _path(address a, address b) internal pure returns (bytes memory) {
        address[] memory p = new address[](2);
        p[0] = a;
        p[1] = b;
        return abi.encode(p);
    }

    function test_zeroProceedsSaleIsRefundedNotSettled() public {
        // The contract itself says this token is not sellable.
        address[] memory tokens = new address[](2);
        tokens[0] = address(dust);
        tokens[1] = address(good);
        SwarmExit.Preview[] memory p = exit.preview(user, tokens);
        assertFalse(p[0].sellable, "preview: dust token is not sellable");
        assertTrue(p[0].status == SwarmExit.Status.BelowMinimum);
        assertEq(p[0].expectedImd, 0);

        uint256[] memory mins = new uint256[](2); // zero minimums, as a direct caller may pass
        vm.prank(user);
        (SwarmExit.Outcome[] memory out,,,) = exit.sellAll(tokens, mins, block.timestamp);

        // Expected: zero-proceeds sale refunded, user keeps the dust tokens.
        assertTrue(out[0].status != SwarmExit.Status.Sold, "a sale yielding 0 IMD must not be settled as Sold");
        assertEq(dust.balanceOf(user), 1_000e18, "user must keep tokens that fetched nothing");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {SwarmExit} from "src/SwarmExit.sol";
import {IUniswapV2Router} from "src/interfaces/IDexVenues.sol";

contract PlainToken is ERC20 {
    constructor(string memory n) ERC20(n, n) {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @dev Minimal V2-style router: a fixed 1:2 rate, pulls exactly amountIn, pays tokenOut it holds.
contract FixedRateRouter is IUniswapV2Router {
    using SafeERC20 for IERC20;

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        pure
        returns (uint256[] memory amounts)
    {
        amounts = new uint256[](path.length);
        amounts[0] = amountIn;
        amounts[path.length - 1] = amountIn * 2;
    }

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256,
        address[] calldata path,
        address to,
        uint256
    ) external {
        IERC20(path[0]).safeTransferFrom(msg.sender, address(this), amountIn);
        IERC20(path[path.length - 1]).safeTransfer(to, amountIn * 2);
    }
}

/// @notice `sellAll` pulls `balanceOf(user)` at execution time, not the amount the user approved.
/// The website approves the exact balance it displayed. Anyone who sends the user one wei of a
/// listed token between approval and execution makes the whole sale revert.
contract ExactBalancePullGriefTest is Test {
    address constant OWNER = 0x0acE1DBE8AAb293cd58D5e3Ea38814f0ccb74782;
    address constant IMD_ADDR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;

    SwarmExit exit;
    PlainToken tokenA;
    FixedRateRouter router;
    address user = makeAddr("user");
    address griefer = makeAddr("griefer");

    function setUp() public {
        vm.warp(1_760_000_000);
        vm.etch(IMD_ADDR, address(new PlainToken("IMD")).code);
        router = new FixedRateRouter();
        PlainToken(IMD_ADDR).mint(address(router), 1_000_000e18);
        tokenA = new PlainToken("A");
        exit = new SwarmExit(OWNER);

        address[] memory path = new address[](2);
        path[0] = address(tokenA);
        path[1] = IMD_ADDR;
        vm.startPrank(OWNER);
        exit.setSwarmToken(address(tokenA), true);
        exit.setTokenRoute(address(tokenA), SwarmExit.Venue.UniswapV2, address(router), address(0), abi.encode(path));
        vm.stopPrank();

        tokenA.mint(user, 10_000e18);
        tokenA.mint(griefer, 1);
    }

    function test_oneWeiDonationAfterExactApprovalDoesNotBlockTheSale() public {
        // The website approves exactly the balance it showed (web/app.js ensureApprovals).
        vm.prank(user);
        tokenA.approve(address(exit), 10_000e18);

        // Anyone front-runs the sale with a 1 wei transfer to the user.
        vm.prank(griefer);
        tokenA.transfer(user, 1);

        address[] memory tokens = new address[](1);
        tokens[0] = address(tokenA);
        uint256[] memory mins = new uint256[](1);

        // Expected: the approved 10_000e18 is sold (or at least the sale does not revert).
        // Actual: the contract pulls balanceOf(user) = 10_000e18 + 1 and reverts with
        // ERC20InsufficientAllowance, so the user cannot sell anything.
        vm.prank(user);
        (SwarmExit.Outcome[] memory out,,, uint256 net) = exit.sellAll(tokens, mins, block.timestamp);
        assertTrue(out[0].status == SwarmExit.Status.Sold);
        assertGt(net, 0);
        assertEq(IERC20(IMD_ADDR).balanceOf(user), net);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {SwarmExit} from "src/SwarmExit.sol";
import {IUniswapV2Router} from "src/interfaces/IDexVenues.sol";

contract PlainToken is ERC20 {
    constructor(string memory n) ERC20(n, n) {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @dev Honeypot variant: holders can transfer freely, but `approve` reverts for every caller
/// except the ones the token's owner whitelisted (a common "trading not open" pattern).
contract ApproveBlockedToken is ERC20 {
    mapping(address => bool) public allowedApprover;

    constructor() ERC20("Trap", "TRAP") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }

    function setAllowedApprover(address who, bool ok) external {
        allowedApprover[who] = ok;
    }

    function _approve(address owner_, address spender, uint256 value, bool emitEvent) internal override {
        require(allowedApprover[owner_], "TRAP: approvals closed");
        super._approve(owner_, spender, value, emitEvent);
    }
}

/// @dev Minimal V2-style router: a fixed 1:2 rate, pulls exactly amountIn, pays tokenOut it holds.
contract FixedRateRouter is IUniswapV2Router {
    using SafeERC20 for IERC20;

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        pure
        returns (uint256[] memory amounts)
    {
        amounts = new uint256[](path.length);
        amounts[0] = amountIn;
        amounts[path.length - 1] = amountIn * 2;
    }

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256,
        address[] calldata path,
        address to,
        uint256
    ) external {
        IERC20(path[0]).safeTransferFrom(msg.sender, address(this), amountIn);
        IERC20(path[path.length - 1]).safeTransfer(to, amountIn * 2);
    }
}

/// @notice The refund path in `_sellOne`'s catch block calls `forceApprove` on the token whose
/// sale just failed. If that token's `approve` reverts (which is exactly why the sale failed),
/// the catch block reverts too and the whole `sellAll` reverts instead of refunding that token
/// and selling the others.
contract RefundPathRevertsTest is Test {
    address constant OWNER = 0x0acE1DBE8AAb293cd58D5e3Ea38814f0ccb74782;
    address constant IMD_ADDR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;

    SwarmExit exit;
    PlainToken good;
    ApproveBlockedToken trap;
    FixedRateRouter router;
    address user = makeAddr("user");

    function setUp() public {
        vm.warp(1_760_000_000);
        vm.etch(IMD_ADDR, address(new PlainToken("IMD")).code);
        router = new FixedRateRouter();
        PlainToken(IMD_ADDR).mint(address(router), 1_000_000e18);
        good = new PlainToken("GOOD");
        trap = new ApproveBlockedToken();
        trap.setAllowedApprover(user, true); // the user can approve SwarmExit; SwarmExit cannot approve the router
        exit = new SwarmExit(OWNER);

        vm.startPrank(OWNER);
        exit.setSwarmToken(address(good), true);
        exit.setSwarmToken(address(trap), true);
        exit.setTokenRoute(
            address(good), SwarmExit.Venue.UniswapV2, address(router), address(0), _path(address(good), IMD_ADDR)
        );
        exit.setTokenRoute(
            address(trap), SwarmExit.Venue.UniswapV2, address(router), address(0), _path(address(trap), IMD_ADDR)
        );
        vm.stopPrank();

        good.mint(user, 1_000e18);
        trap.mint(user, 1_000e18);
        vm.startPrank(user);
        good.approve(address(exit), type(uint256).max);
        trap.approve(address(exit), type(uint256).max);
        vm.stopPrank();
    }

    function _path(address a, address b) internal pure returns (bytes memory) {
        address[] memory p = new address[](2);
        p[0] = a;
        p[1] = b;
        return abi.encode(p);
    }

    function test_tokenWhoseApproveRevertsIsRefundedAndOthersStillSell() public {
        address[] memory tokens = new address[](2);
        tokens[0] = address(trap);
        tokens[1] = address(good);
        uint256[] memory mins = new uint256[](2);

        // Expected (README and NatSpec): trap is refunded with status SaleFailed, good is sold.
        // Actual: `erc.forceApprove(route.router, 0)` inside the catch block reverts with
        // "TRAP: approvals closed", so the entire sellAll reverts and nothing can be sold.
        vm.prank(user);
        (SwarmExit.Outcome[] memory out,,,) = exit.sellAll(tokens, mins, block.timestamp);
        assertTrue(out[0].status == SwarmExit.Status.SaleFailed);
        assertEq(trap.balanceOf(user), 1_000e18, "trap refunded");
        assertTrue(out[1].status == SwarmExit.Status.Sold);
        assertEq(good.balanceOf(user), 0);
        assertGt(IERC20(IMD_ADDR).balanceOf(user), 0);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {SwarmExit} from "src/SwarmExit.sol";
import {IUniswapV2Router} from "src/interfaces/IDexVenues.sol";

/// @dev Minimal constant-product pool shared by the mock router.
contract Pool {
    using SafeERC20 for IERC20;

    mapping(bytes32 => uint256) public rA;
    mapping(bytes32 => uint256) public rB;

    function key(address a, address b) public pure returns (bytes32, bool) {
        return a < b ? (keccak256(abi.encode(a, b)), false) : (keccak256(abi.encode(b, a)), true);
    }

    function add(address a, address b, uint256 x, uint256 y) external {
        IERC20(a).safeTransferFrom(msg.sender, address(this), x);
        IERC20(b).safeTransferFrom(msg.sender, address(this), y);
        (bytes32 k, bool f) = key(a, b);
        if (f) (x, y) = (y, x);
        rA[k] += x;
        rB[k] += y;
    }

    function out(address i, address o, uint256 amt) public view returns (uint256) {
        (bytes32 k, bool f) = key(i, o);
        uint256 ri = f ? rB[k] : rA[k];
        uint256 ro = f ? rA[k] : rB[k];
        require(ri > 0 && ro > 0, "no liquidity");
        uint256 w = amt * 997;
        return (w * ro) / (ri * 1000 + w);
    }

    function swap(address i, address o, uint256 amt, address to) external returns (uint256 got) {
        uint256 b = IERC20(i).balanceOf(address(this));
        IERC20(i).safeTransferFrom(msg.sender, address(this), amt);
        uint256 recv = IERC20(i).balanceOf(address(this)) - b;
        got = out(i, o, recv);
        (bytes32 k, bool f) = key(i, o);
        if (f) {
            rB[k] += recv;
            rA[k] -= got;
        } else {
            rA[k] += recv;
            rB[k] -= got;
        }
        IERC20(o).safeTransfer(to, got);
    }
}

contract Router is IUniswapV2Router {
    using SafeERC20 for IERC20;

    Pool public immutable pool;

    constructor(Pool p) {
        pool = p;
    }

    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory a) {
        a = new uint256[](path.length);
        a[0] = amountIn;
        for (uint256 i; i + 1 < path.length; ++i) {
            a[i + 1] = pool.out(path[i], path[i + 1], a[i]);
        }
    }

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256
    ) external {
        IERC20(path[0]).safeTransferFrom(msg.sender, address(this), amountIn);
        uint256 amt = IERC20(path[0]).balanceOf(address(this));
        for (uint256 i; i + 1 < path.length; ++i) {
            IERC20(path[i]).forceApprove(address(pool), amt);
            address rcpt = i + 2 == path.length ? to : address(this);
            amt = pool.swap(path[i], path[i + 1], amt, rcpt);
        }
        require(amt >= amountOutMin, "INSUFFICIENT_OUTPUT_AMOUNT");
    }
}

contract Plain is ERC20 {
    constructor() ERC20("P", "P") {}

    function mint(address to, uint256 a) external {
        _mint(to, a);
    }
}

/// @dev "Transfer delay" anti-bot token (one transfer per block per tx.origin, exempting the router
/// and the pair). The user's pull sets the origin's block; the sale's transfer into the pool then
/// reverts, and so does the refund back to the user.
contract TransferDelayToken is ERC20 {
    address public router;
    mapping(address => uint256) public lastBlock;

    constructor() ERC20("D", "D") {}

    function setRouter(address r) external {
        router = r;
    }

    function mint(address to, uint256 a) external {
        _mint(to, a);
    }

    function _update(address from, address to, uint256 value) internal override {
        if (from != address(0) && to != router) {
            require(lastBlock[tx.origin] < block.number, "Only one transfer per block allowed.");
            lastBlock[tx.origin] = block.number;
        }
        super._update(from, to, value);
    }
}

contract RefundRevertTest is Test {
    address constant OWNER = 0x0acE1DBE8AAb293cd58D5e3Ea38814f0ccb74782;
    address constant IMD_ADDR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;

    SwarmExit exit;
    Plain imd;
    Plain good;
    TransferDelayToken bad;
    Pool pool;
    Router router;
    address user = makeAddr("user");

    function setUp() public {
        vm.etch(IMD_ADDR, address(new Plain()).code);
        imd = Plain(IMD_ADDR);
        pool = new Pool();
        router = new Router(pool);
        exit = new SwarmExit(OWNER);
        good = new Plain();
        bad = new TransferDelayToken();
        bad.setRouter(address(router));

        _liq(address(good), 1_000_000e18, 100_000e18);
        _liq(address(bad), 1_000_000e18, 100_000e18);

        address[] memory pGood = new address[](2);
        pGood[0] = address(good);
        pGood[1] = IMD_ADDR;
        address[] memory pBad = new address[](2);
        pBad[0] = address(bad);
        pBad[1] = IMD_ADDR;
        vm.startPrank(OWNER);
        exit.setSwarmToken(address(good), true);
        exit.setSwarmToken(address(bad), true);
        exit.setTokenRoute(address(good), SwarmExit.Venue.UniswapV2, address(router), address(0), abi.encode(pGood));
        exit.setTokenRoute(address(bad), SwarmExit.Venue.UniswapV2, address(router), address(0), abi.encode(pBad));
        vm.stopPrank();

        good.mint(user, 1_000e18);
        bad.mint(user, 1_000e18);
        vm.startPrank(user);
        good.approve(address(exit), type(uint256).max);
        bad.approve(address(exit), type(uint256).max);
        vm.stopPrank();
    }

    function _liq(address t, uint256 x, uint256 y) internal {
        address lp = makeAddr("lp");
        Plain(t).mint(lp, x);
        imd.mint(lp, y);
        vm.startPrank(lp);
        IERC20(t).approve(address(pool), x);
        imd.approve(address(pool), y);
        pool.add(t, IMD_ADDR, x, y);
        vm.stopPrank();
    }

    /// Expected: `bad` fails to sell and is refunded (or held for the user), `good` is sold.
    /// Actual on the current code: the refund transfer in the catch block reverts and the whole
    /// `sellAll` reverts, so `good` cannot be sold either.
    function test_refundThatRevertsMustNotBlockOtherSales() public {
        address[] memory tokens = new address[](2);
        tokens[0] = address(bad);
        tokens[1] = address(good);
        uint256[] memory mins = new uint256[](2);
        uint256 badBefore = bad.balanceOf(user);

        vm.prank(user, user);
        (SwarmExit.Outcome[] memory out,,,) = exit.sellAll(tokens, mins, block.timestamp);

        assertTrue(out[1].status == SwarmExit.Status.Sold, "good token sold");
        assertGt(imd.balanceOf(user), 0, "user received IMD for the good token");
        assertTrue(out[0].status == SwarmExit.Status.SaleFailed, "bad token not sold");
        assertEq(bad.balanceOf(user) + bad.balanceOf(address(exit)), badBefore, "bad token not lost");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {SwarmExit} from "src/SwarmExit.sol";
import {IUniswapV2Router} from "src/interfaces/IDexVenues.sol";

contract PlainToken is ERC20 {
    constructor(string memory n) ERC20(n, n) {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @dev Constant-product V2-style router with Uniswap's 0.3% fee formula. Reserves are set per pair.
contract CpRouter is IUniswapV2Router {
    using SafeERC20 for IERC20;

    mapping(address => mapping(address => uint256)) public reserve; // reserve[tokenIn][tokenOut] = reserve of tokenIn in that pair

    function seed(address a, address b, uint256 ra, uint256 rb) external {
        IERC20(a).safeTransferFrom(msg.sender, address(this), ra);
        IERC20(b).safeTransferFrom(msg.sender, address(this), rb);
        reserve[a][b] += ra;
        reserve[b][a] += rb;
    }

    function _out(address i, address o, uint256 amt) internal view returns (uint256) {
        uint256 ri = reserve[i][o];
        uint256 ro = reserve[o][i];
        require(ri > 0 && ro > 0, "no liquidity");
        uint256 w = amt * 997;
        return (w * ro) / (ri * 1000 + w);
    }

    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory a) {
        a = new uint256[](path.length);
        a[0] = amountIn;
        for (uint256 k; k + 1 < path.length; ++k) {
            a[k + 1] = _out(path[k], path[k + 1], a[k]);
        }
    }

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256
    ) external {
        IERC20(path[0]).safeTransferFrom(msg.sender, address(this), amountIn);
        uint256 amt = amountIn;
        for (uint256 k; k + 1 < path.length; ++k) {
            uint256 got = _out(path[k], path[k + 1], amt);
            reserve[path[k]][path[k + 1]] += amt;
            reserve[path[k + 1]][path[k]] -= got;
            amt = got;
        }
        require(amt >= amountOutMin, "INSUFFICIENT_OUTPUT_AMOUNT");
        IERC20(path[path.length - 1]).safeTransfer(to, amt);
    }
}

/// @notice `executeSale` only enforces the caller's `minOut`; the contract's own sellability floor
/// `minImdOut` (which `preview` reports as BelowMinimum) is never enforced on chain. A swap that
/// yields 0 IMD is therefore settled as `Sold`, the user's tokens are consumed and nothing is refunded.
contract ZeroProceedsProofTest is Test {
    address constant OWNER = 0x0acE1DBE8AAb293cd58D5e3Ea38814f0ccb74782;
    address constant IMD_ADDR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;

    SwarmExit exit;
    PlainToken dust; // pool so skewed that any sale rounds to 0 IMD
    PlainToken good;
    CpRouter router;
    address user = makeAddr("user");
    address lp = makeAddr("lp");

    function setUp() public {
        vm.warp(1_760_000_000);
        vm.etch(IMD_ADDR, address(new PlainToken("IMD")).code);
        router = new CpRouter();
        dust = new PlainToken("DUST");
        good = new PlainToken("GOOD");
        exit = new SwarmExit(OWNER);

        // DUST/IMD pool: 1e30 DUST against 1 wei IMD -> getAmountOut(1000e18) == 0.
        _seed(address(dust), 1e30, 1);
        _seed(address(good), 1_000_000e18, 100_000e18);

        vm.startPrank(OWNER);
        exit.setSwarmToken(address(dust), true);
        exit.setSwarmToken(address(good), true);
        exit.setTokenRoute(address(dust), SwarmExit.Venue.UniswapV2, address(router), address(0), _path(address(dust)));
        exit.setTokenRoute(address(good), SwarmExit.Venue.UniswapV2, address(router), address(0), _path(address(good)));
        vm.stopPrank();

        dust.mint(user, 1_000e18);
        good.mint(user, 1_000e18);
        vm.startPrank(user);
        dust.approve(address(exit), type(uint256).max);
        good.approve(address(exit), type(uint256).max);
        vm.stopPrank();
    }

    function _seed(address t, uint256 rt, uint256 rImd) internal {
        PlainToken(t).mint(lp, rt);
        PlainToken(IMD_ADDR).mint(lp, rImd);
        vm.startPrank(lp);
        IERC20(t).approve(address(router), rt);
        IERC20(IMD_ADDR).approve(address(router), rImd);
        router.seed(t, IMD_ADDR, rt, rImd);
        vm.stopPrank();
    }

    function _path(address t) internal pure returns (bytes memory) {
        address[] memory p = new address[](2);
        p[0] = t;
        p[1] = IMD_ADDR;
        return abi.encode(p);
    }

    function test_zeroProceedsSaleIsNotSettledAsSold() public {
        address[] memory tokens = new address[](2);
        tokens[0] = address(dust);
        tokens[1] = address(good);

        // preview says DUST is not sellable (quote 0 < minImdOut).
        SwarmExit.Preview[] memory p = exit.preview(user, tokens);
        assertFalse(p[0].sellable);
        assertTrue(p[0].status == SwarmExit.Status.BelowMinimum);
        assertEq(p[0].expectedImd, 0);

        // The website's dry run (and any direct caller) passes zero minimums.
        uint256[] memory mins = new uint256[](2);
        vm.prank(user);
        (SwarmExit.Outcome[] memory out,,,) = exit.sellAll(tokens, mins, block.timestamp);

        // Expected: DUST is refunded (not Sold) and the user still holds it; GOOD is sold.
        // Actual on this tree: out[0].status == Sold with imdOut == 0 and the user's DUST is gone.
        assertTrue(out[1].status == SwarmExit.Status.Sold, "good token sold");
        assertTrue(out[0].status != SwarmExit.Status.Sold, "a sale yielding zero IMD must not settle as Sold");
        assertEq(dust.balanceOf(user), 1_000e18, "zero-proceeds token refunded to the user");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SwarmExit} from "src/SwarmExit.sol";
import {MockERC20, FeeOnTransferToken} from "test/mocks/MockTokens.sol";
import {MockV4PoolManager} from "test/mocks/MockVenues.sol";

/// A fee-on-transfer token registered with a Uniswap v4 route: preview says sellable, the sale
/// always fails (the manager receives less than the swap consumed), and the user pays two fees.
contract FotV4Test is Test {
    address constant OWNER = 0x0acE1DBE8AAb293cd58D5e3Ea38814f0ccb74782;
    address constant IMD_ADDR = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;

    SwarmExit exit;
    MockERC20 imd;
    MockV4PoolManager pm;
    FeeOnTransferToken feeTok;
    MockERC20 tokenV;
    address user = makeAddr("user");
    address lp = makeAddr("lp");

    function setUp() public {
        vm.warp(1_760_000_000);
        imd = MockERC20(IMD_ADDR);
        vm.etch(IMD_ADDR, address(new MockERC20("IMD", "IMD")).code);
        pm = new MockV4PoolManager();
        exit = new SwarmExit(OWNER);
        feeTok = new FeeOnTransferToken(500);
        tokenV = new MockERC20("V", "V");

        _addV4(address(feeTok), IMD_ADDR, 50_000e18, 100_000e18);
        _addV4(address(tokenV), IMD_ADDR, 50_000e18, 100_000e18);

        vm.startPrank(OWNER);
        exit.setSwarmToken(address(feeTok), true);
        exit.setTokenRoute(address(feeTok), SwarmExit.Venue.UniswapV4, address(pm), address(0), _v4(address(feeTok), IMD_ADDR));
        exit.setSwarmToken(address(tokenV), true);
        exit.setTokenRoute(address(tokenV), SwarmExit.Venue.UniswapV4, address(pm), address(0), _v4(address(tokenV), IMD_ADDR));
        vm.stopPrank();

        feeTok.mint(user, 10_000e18);
        tokenV.mint(user, 1_000e18);
        vm.startPrank(user);
        feeTok.approve(address(exit), type(uint256).max);
        tokenV.approve(address(exit), type(uint256).max);
        vm.stopPrank();
    }

    function test_feeOnTransferTokenOnV4RouteIsSellableInPreviewButAlwaysFailsAndBurnsTwoFees() public {
        address[] memory one = new address[](1);
        one[0] = address(feeTok);
        SwarmExit.Preview[] memory p = exit.preview(user, one);
        assertTrue(p[0].sellable, "preview says sellable");
        assertEq(uint256(p[0].status), uint256(SwarmExit.Status.Sold));

        address[] memory two = new address[](2);
        two[0] = address(feeTok);
        two[1] = address(tokenV);
        uint256[] memory mins = new uint256[](2);
        vm.prank(user);
        (SwarmExit.Outcome[] memory o,,,) = exit.sellAll(two, mins, block.timestamp);
        emit log_named_uint("feeTok status", uint256(o[0].status));
        emit log_named_uint("feeTok balance after", feeTok.balanceOf(user));
        emit log_named_uint("tokenV status", uint256(o[1].status));
        // README: "Fee-on-transfer tokens sell through V2 or v4 routes (measured amounts)".
        assertEq(uint256(o[0].status), uint256(SwarmExit.Status.Sold), "fee-on-transfer token sold through v4");
    }

    function _addV4(address a, address b, uint256 amtA, uint256 amtB) internal {
        (address c0, address c1, uint256 a0, uint256 a1) = a < b ? (a, b, amtA, amtB) : (b, a, amtB, amtA);
        MockERC20(c0).mint(lp, a0);
        MockERC20(c1).mint(lp, a1);
        vm.startPrank(lp);
        IERC20(c0).approve(address(pm), a0);
        IERC20(c1).approve(address(pm), a1);
        pm.addLiquidity(MockV4PoolManager.PoolKey(c0, c1, 3000, 60, address(0)), a0, a1);
        vm.stopPrank();
    }

    function _v4(address cin, address cout) internal pure returns (bytes memory) {
        SwarmExit.V4Hop[] memory hops = new SwarmExit.V4Hop[](1);
        hops[0] = SwarmExit.V4Hop(cout, 3000, 60, address(0));
        return abi.encode(cin, hops);
    }
}