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

import {Test} from "forge-std/Test.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {IMD6900LockedPool} from "src/IMD6900LockedPool.sol";

/// Finding: IMD6900LockedPool.ENGINE_CODE_HASH is not the keccak256 of the PerpEngine creation code this repository
/// builds (solc 0.8.26, via-IR, 200 runs, cancun, bytecode_hash none). createPerps therefore refuses the audited
/// engine with NotThePerpsCode, so the perps can never be created from this source (the constant is fixed in the
/// locked pool the launch's constructor creates). Fails until the constant equals the build's hash.
contract PerpsCodeHashTest is Test {
    function test_TheEngineHashIsTheBuildsHash() public {
        IMD6900LockedPool p = new IMD6900LockedPool(IPoolManager(address(0xBEEF)), 44_400, address(this), address(0x71E10C));
        bytes memory engine = vm.getCode("PerpEngine.sol:PerpEngine");
        bytes memory vault = vm.getCode("PerpVault.sol:PerpVault");
        emit log_named_bytes32("built engine creation code hash", keccak256(engine));
        emit log_named_bytes32("ENGINE_CODE_HASH", p.ENGINE_CODE_HASH());
        assertEq(keccak256(vault), p.VAULT_CODE_HASH(), "the vault's hash is the build's");
        assertEq(keccak256(engine), p.ENGINE_CODE_HASH(), "the engine's hash must be the build's: createPerps refuses the audited engine otherwise");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {FullMath} from "@uniswap/v4-core/src/libraries/FullMath.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {IMD6900Hook} from "src/IMD6900Hook.sol";
import {IMD6900LockedPool} from "src/IMD6900LockedPool.sol";
import {IMD6900RobinhoodLaunch} from "src/IMD6900RobinhoodLaunch.sol";
import {PerpEngine} from "src/perps/PerpEngine.sol";
import {PerpVault} from "src/perps/PerpVault.sol";

interface IERC20S {
    function balanceOf(address) external view returns (uint256);
    function approve(address, uint256) external returns (bool);
    function transfer(address, uint256) external returns (bool);
}

contract Imdstr0 {
    mapping(address => uint256) public balanceOf;
}

contract Buyer {
    IPoolManager immutable pm;
    PoolKey key;

    constructor(IPoolManager pm_) {
        pm = pm_;
    }

    function buy(PoolKey calldata k, int256 amt) external payable {
        key = k;
        pm.unlock(abi.encode(amt));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        int256 amt = abi.decode(data, (int256));
        BalanceDelta d = pm.swap(key, SwapParams(true, amt, TickMath.MIN_SQRT_PRICE + 1), "");
        pm.settle{value: uint128(-d.amount0())}();
        pm.take(key.currency1, address(this), uint128(d.amount1()));
        return "";
    }

    function approve(address t, address s, uint256 a) external {
        IERC20S(t).approve(s, a);
    }

    function stake(PerpVault v, uint256 a) external {
        v.depositToken(a);
    }

    receive() external payable {}
}

/// The funding index weighs the longs' BORROWED ETH against the shorts' full NOTIONAL: with the long side the larger
/// one by notional, the longs (the crowded side) receive funding and the shorts pay.
contract FundingSideTest is Test {
    address constant OWNER = address(0xA11CE);
    address constant TL = address(0x71E10C);
    address constant ALICE = address(0xA1);
    address constant BOB = address(0xB0B);
    uint256 constant SUPPLY = 1_000_000_000 ether;

    IPoolManager PM;
    IMD6900RobinhoodLaunch L;
    IMD6900LockedPool pool;
    PerpEngine engine;
    PerpVault vault;
    address t;
    PoolKey k;
    address _staker;

    function setUp() public {
        PM = IPoolManager(vm.deployCode("PoolManager.sol:PoolManager", abi.encode(address(this))));
        L = IMD6900RobinhoodLaunch(
            payable(vm.deployCode(
                    "IMD6900RobinhoodLaunch.sol:IMD6900RobinhoodLaunch",
                    abi.encode(OWNER, PM, address(new Imdstr0()), TL)
                ))
        );
        L.createHook(_mineHook());
        pool = L.pool();
        bytes32 salt = _mineCoin();
        address expected = L.tokenAddress(salt);
        vm.deal(OWNER, 2.81 ether);
        vm.prank(OWNER);
        (t,) = L.launch{value: 2.81 ether}(
            salt, expected, uint160(_sqrt(FullMath.mulDiv(SUPPLY, 1 << 192, 19.18 ether))), 0, address(L)
        );
        (address e, address v) =
            pool.createPerps{value: 0.05 ether}(vm.getCode("PerpEngine.sol:PerpEngine"), vm.getCode("PerpVault.sol:PerpVault"));
        (engine, vault) = (PerpEngine(payable(e)), PerpVault(payable(v)));
        k = pool.poolKey();
        vm.deal(address(0x57A4E), 10 ether);
        vm.prank(address(0x57A4E));
        vault.depositEth{value: 10 ether}();
        Buyer b = new Buyer(PM);
        vm.deal(address(b), 2 ether);
        b.buy(k, -2 ether);
        uint256 coins = IERC20S(t).balanceOf(address(b));
        b.approve(t, address(vault), coins);
        b.stake(vault, coins);
        _staker = address(b);
        vm.deal(ALICE, 5 ether);
        vm.deal(BOB, 5 ether);
    }

    function test_TheLargerSideByNotionalPaysFunding() public {
        vm.prank(ALICE);
        uint256 longId = engine.openLong{value: 0.3 ether}(2, 0); // notional ~0.559 ETH, borrowed ~0.279
        vm.prank(BOB);
        uint256 shortId = engine.openShort{value: 0.2 ether}(2, 0); // notional ~0.372 ETH
        emit log_named_uint("longOiEth (borrowed)", engine.longOiEth());
        emit log_named_uint("short notional at spot", _shortEth());
        vm.warp(block.timestamp + 1 days);
        engine.poke();
        int256 longFunding = engine.fundingDelta(longId);
        int256 shortFunding = engine.fundingDelta(shortId);
        emit log_named_int("long funding (positive = pays)", longFunding);
        emit log_named_int("short funding (positive = pays)", shortFunding);
        // the long side is the crowded one by notional (0.559 vs 0.372 ETH): it must pay, the shorts receive
        assertGt(longFunding, 0, "the crowded long side pays funding");
        assertLt(shortFunding, 0, "the smaller short side receives it");
    }

    function _shortEth() internal view returns (uint256) {
        (, uint256 markValue,,) = engine.positionHealth(2);
        return markValue;
    }

    function _mineHook() internal view returns (bytes32) {
        bytes memory pre = abi.encodePacked(bytes1(0xff), address(L), bytes32(0), L.hookInitCodeHash());
        uint160 flags = L.FLAGS();
        for (uint256 i;; ++i) {
            address a = _at(pre, i);
            if (uint160(a) & Hooks.ALL_HOOK_MASK == flags && uint160(a) >> 152 != 0x91) return bytes32(i);
        }
    }

    function _mineCoin() internal view returns (bytes32) {
        bytes memory pre = abi.encodePacked(bytes1(0xff), address(L), bytes32(0), L.tokenInitCodeHash());
        for (uint256 i;; ++i) {
            if (uint160(_at(pre, i)) >> 144 == 0x6900) return bytes32(i);
        }
    }

    function _at(bytes memory preimage, uint256 salt) internal pure returns (address a) {
        assembly ("memory-safe") {
            mstore(add(preimage, 53), salt)
            a := and(keccak256(add(preimage, 32), 85), 0xffffffffffffffffffffffffffffffffffffffff)
        }
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        y = x;
        uint256 z = (x + 1) / 2;
        while (z < y) (y, z) = (z, (x / z + z) / 2);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {FullMath} from "@uniswap/v4-core/src/libraries/FullMath.sol";
import {IMD6900Hook} from "src/IMD6900Hook.sol";
import {IMD6900LockedPool} from "src/IMD6900LockedPool.sol";
import {IMD6900RobinhoodLaunch} from "src/IMD6900RobinhoodLaunch.sol";
import {PerpEngine} from "src/perps/PerpEngine.sol";
import {PerpVault} from "src/perps/PerpVault.sol";

/// A stand-in for the old IMDSTR (the launch only needs an address with code for a launch without claims)
contract NoImdstr {}

/// The timelock turns the perps off (IMD6900Hook.setPerpEngine(0), "Zero turns perps off") or replaces the engine
/// while the engine the launch created still has a position open. Expected: the open position can still be closed by
/// its trader (its collateral and the vault's lent ETH come back). Actual: IMD6900LockedPool.isRefunded now says no for
/// the old engine, PerpSwapLib.swapLeg's feeCheckpoint() reverts NotRefunded, and close/liquidate/sweep all revert:
/// the position, its collateral and the vault's principal are frozen until (and unless) the timelock re-wires it.
contract EngineReplaceStrandsTest is Test {
    address constant OWNER = address(0xA11CE);
    address constant TL = address(0x71E10C);
    address constant STAKER = address(0x57A4E);
    address constant ALICE = address(0xA1);
    uint256 constant SUPPLY = 1_000_000_000 ether;

    IPoolManager PM;
    IMD6900RobinhoodLaunch L;
    IMD6900Hook hook;
    IMD6900LockedPool pool;
    PerpEngine engine;
    PerpVault vault;

    function setUp() public {
        PM = IPoolManager(vm.deployCode("PoolManager.sol:PoolManager", abi.encode(address(this))));
        L = IMD6900RobinhoodLaunch(
            payable(
                vm.deployCode(
                    "IMD6900RobinhoodLaunch.sol:IMD6900RobinhoodLaunch",
                    abi.encode(OWNER, PM, address(new NoImdstr()), TL)
                )
            )
        );
        hook = L.createHook(_mineHookSalt());
        pool = L.pool();
        bytes32 salt = _mineCoinSalt();
        address expected = L.tokenAddress(salt);
        uint160 price = uint160(_sqrt(FullMath.mulDiv(SUPPLY, 1 << 192, 19.18 ether)));
        vm.deal(OWNER, 2.81 ether);
        vm.prank(OWNER);
        L.launch{value: 2.81 ether}(salt, expected, price, 0, address(L));
        vm.deal(address(this), 1 ether);
        (address e, address v) = pool.createPerps{value: 0.05 ether}(
            vm.getCode("PerpEngine.sol:PerpEngine"), vm.getCode("PerpVault.sol:PerpVault")
        );
        (engine, vault) = (PerpEngine(payable(e)), PerpVault(payable(v)));
        vm.deal(STAKER, 20 ether);
        vm.prank(STAKER);
        vault.depositEth{value: 10 ether}();
        vm.deal(ALICE, 5 ether);
        pool.collect();
    }

    function test_TurningPerpsOffStrandsOpenPositions() public {
        vm.prank(ALICE);
        uint256 id = engine.openLong{value: 0.1 ether}(5, 0);
        assertEq(engine.openCount(), 1);
        uint256 lent = engine.longOiEth();
        assertGt(lent, 0, "the vault lent the long its borrow");

        // the timelock's documented way out: "Zero turns perps off"
        vm.prank(TL);
        hook.setPerpEngine(address(0));

        // the trader closes the position they opened before the switch: their collateral must come back
        uint256 before = ALICE.balance;
        vm.prank(ALICE);
        engine.close(id, 0); // reverts today: IMD6900LockedPool.NotRefunded from PerpSwapLib.swapLeg's feeCheckpoint
        assertEq(engine.openCount(), 0, "closed");
        assertGt(ALICE.balance, before, "collateral back");
        assertEq(engine.longOiEth(), 0, "the vault's ETH is back in the PLV");
    }

    function test_ReplacingTheEngineStrandsOpenPositionsAndLetsTheFeeMove() public {
        vm.prank(ALICE);
        uint256 id = engine.openLong{value: 0.1 ether}(5, 0);

        // the timelock replaces the engine with a fresh one (openCount 0 there)
        address fresh = address(new CountingEngine());
        vm.prank(TL);
        hook.setPerpEngine(fresh);

        // the old engine can neither be closed nor liquidated by anyone
        vm.prank(ALICE);
        (bool okClose,) = address(engine).call(abi.encodeCall(engine.close, (id, 0)));
        (bool okLiq,) = address(engine).call(abi.encodeCall(engine.liquidate, (id)));
        // and lowerFee only asks the hook's CURRENT engine, so the pool moves away from under the old engine for good
        vm.prank(TL);
        (bool okMove,) = address(pool).call(abi.encodeCall(pool.lowerFee, (33_300)));
        assertTrue(okMove, "the fee move went through with a position open in the created engine");
        assertEq(engine.openCount(), 1, "still open, bound to a pool nobody serves");
        // Expected behaviour (what the fix must restore): the trader can close while the timelock re-wires things
        assertTrue(okClose || okLiq, "an open position must stay closable after the timelock replaces the engine");
    }

    /*                               HELPERS                                */

    function _mineHookSalt() internal view returns (bytes32) {
        bytes32 initHash = L.hookInitCodeHash();
        uint160 flags = L.FLAGS();
        for (uint256 i;; ++i) {
            address a = _create2(address(L), bytes32(i), initHash);
            if (uint160(a) & Hooks.ALL_HOOK_MASK == flags && uint160(a) >> 152 != 0x91) return bytes32(i);
        }
    }

    function _mineCoinSalt() internal view returns (bytes32) {
        bytes32 initHash = L.tokenInitCodeHash();
        for (uint256 i;; ++i) {
            address a = _create2(address(L), bytes32(i), initHash);
            if (uint160(a) >> 144 == 0x6900) return bytes32(i);
        }
    }

    function _create2(address deployer, bytes32 salt, bytes32 initHash) internal pure returns (address) {
        return address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, initHash)))));
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        y = x;
        uint256 z = (x + 1) / 2;
        while (z < y) (y, z) = (z, (x / z + z) / 2);
    }
}

/// A replacement engine with nothing open
contract CountingEngine {
    function openCount() external pure returns (uint256) {
        return 0;
    }

    function sweepLiquidations(address, int256, bool, uint160) external pure returns (uint8) {
        return 0;
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {FullMath} from "@uniswap/v4-core/src/libraries/FullMath.sol";
import {IMD6900RobinhoodLaunch} from "src/IMD6900RobinhoodLaunch.sol";

/// A pot bridge that refuses plain ETH (paused bridge, minimum deposit, no receive()).
contract RefusingPot {
    receive() external payable {
        revert("paused");
    }
}

contract MockImdstr {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function approve(address s, uint256 a) external returns (bool) { allowance[msg.sender][s] = a; return true; }
    function transfer(address to, uint256 a) external returns (bool) { balanceOf[msg.sender] -= a; balanceOf[to] += a; return true; }
    function transferFrom(address f, address to, uint256 a) external returns (bool) {
        allowance[f][msg.sender] -= a; balanceOf[f] -= a; balanceOf[to] += a; return true;
    }
}

/// The fee split's 90% to the pot bridge is a guarantee of the launch. When the pot bridge refuses its share,
/// split() leaves it in the balance ("for the next split") but the next split() re-splits that same ETH and books
/// 10% of it into imdBucket again. Anyone can call split() repeatedly, so the pot's share migrates into the $IMD
/// burn bucket and is spent by burnImd(): the pot can never get it back.
contract SplitDriftTest is Test {
    address constant OWNER = address(0xA11CE);
    address constant TL = address(0x71E10C);
    address constant POT = 0xc39e650a24985C2bBA9FD83C81041B8f3E3f9EDd;
    uint256 constant SUPPLY = 1_000_000_000 ether;

    IPoolManager PM;
    IMD6900RobinhoodLaunch L;

    function setUp() public {
        PM = IPoolManager(vm.deployCode("PoolManager.sol:PoolManager", abi.encode(address(this))));
        L = IMD6900RobinhoodLaunch(
            payable(vm.deployCode("IMD6900RobinhoodLaunch.sol:IMD6900RobinhoodLaunch", abi.encode(OWNER, PM, address(new MockImdstr()), TL)))
        );
        L.createHook(_mineHook());
        bytes32 salt = _mineCoin();
        address expected = L.tokenAddress(salt);
        uint160 price = uint160(_sqrt(FullMath.mulDiv(SUPPLY, 1 << 192, 19.18 ether)));
        vm.deal(OWNER, 1 ether);
        vm.prank(OWNER);
        L.launch{value: 1 ether}(salt, expected, price, 0, address(L));
        // the pot bridge refuses ETH
        vm.etch(POT, address(new RefusingPot()).code);
    }

    function test_FailedPotShareMigratesIntoTheImdBucket() public {
        // 10 ETH of fees arrive
        vm.deal(address(this), 10 ether);
        L.addFees{value: 10 ether}();
        // first split: 9 ETH to the pot (refused, stays here), 1 ETH to the $IMD bucket
        L.split();
        assertEq(L.imdBucket(), 1 ether);
        assertEq(address(L).balance, 10 ether);
        // anyone calls split() again: the pot's unpaid 9 ETH is split AGAIN, 0.9 ETH more to the $IMD bucket
        for (uint256 i; i < 60; ++i) L.split();
        uint256 potShareLeft = address(L).balance - L.imdBucket();
        emit log_named_decimal_uint("pot's share still reserved for it", potShareLeft, 18);
        emit log_named_decimal_uint("imdBucket (spent by burnImd on $IMD)", L.imdBucket(), 18);
        // the pot's 9 ETH must stay the pot's: it never agreed to fund the $IMD burn
        assertEq(potShareLeft, 9 ether, "the pot bridge's refused share was re-split into the $IMD bucket");
    }

    /*                               HELPERS                                */

    function _mineHook() internal view returns (bytes32) {
        bytes32 initHash = L.hookInitCodeHash();
        uint160 flags = L.FLAGS();
        bytes memory pre = abi.encodePacked(bytes1(0xff), address(L), bytes32(0), initHash);
        for (uint256 i;; ++i) {
            address a = _at(pre, i);
            if (uint160(a) & Hooks.ALL_HOOK_MASK == flags && uint160(a) >> 152 != 0x91) return bytes32(i);
        }
    }

    function _mineCoin() internal view returns (bytes32) {
        bytes32 initHash = L.tokenInitCodeHash();
        bytes memory pre = abi.encodePacked(bytes1(0xff), address(L), bytes32(0), initHash);
        for (uint256 i;; ++i) {
            if (uint160(_at(pre, i)) >> 144 == 0x6900) return bytes32(i);
        }
    }

    function _at(bytes memory pre, uint256 salt) internal pure returns (address a) {
        assembly ("memory-safe") {
            mstore(add(pre, 53), salt)
            a := and(keccak256(add(pre, 32), 85), 0xffffffffffffffffffffffffffffffffffffffff)
        }
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        y = x;
        uint256 z = (x + 1) / 2;
        while (z < y) (y, z) = (z, (x / z + z) / 2);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {SwapParams, ModifyLiquidityParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {FullMath} from "@uniswap/v4-core/src/libraries/FullMath.sol";
import {IMD6900Hook} from "src/IMD6900Hook.sol";
import {IMD6900RobinhoodLaunch} from "src/IMD6900RobinhoodLaunch.sol";

interface IERC20 {
    function balanceOf(address) external view returns (uint256);
    function transfer(address, uint256) external returns (bool);
}

contract MockToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 a) external { balanceOf[to] += a; totalSupply += a; }
    function approve(address s, uint256 a) external returns (bool) { allowance[msg.sender][s] = a; return true; }
    function transfer(address to, uint256 a) external returns (bool) { balanceOf[msg.sender] -= a; balanceOf[to] += a; return true; }
    function transferFrom(address f, address to, uint256 a) external returns (bool) {
        allowance[f][msg.sender] -= a; balanceOf[f] -= a; balanceOf[to] += a; return true;
    }
}

/// A plain trader (a router): one unlock per swap
contract Trader {
    IPoolManager immutable pm;
    PoolKey key;
    constructor(IPoolManager pm_) { pm = pm_; }
    function swap(PoolKey calldata k, bool buy, int256 amountSpecified) external returns (BalanceDelta d) {
        key = k;
        d = abi.decode(pm.unlock(abi.encode(buy, amountSpecified)), (BalanceDelta));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool buy, int256 amt) = abi.decode(data, (bool, int256));
        BalanceDelta d = pm.swap(key, SwapParams(buy, amt, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), "");
        _settle(key.currency0, d.amount0());
        _settle(key.currency1, d.amount1());
        return abi.encode(d);
    }
    function _settle(Currency c, int128 v) internal {
        if (v < 0) {
            if (c.isAddressZero()) pm.settle{value: uint128(-v)}();
            else { pm.sync(c); IERC20(Currency.unwrap(c)).transfer(address(pm), uint128(-v)); pm.settle(); }
        } else if (v > 0) {
            pm.take(c, address(this), uint128(v));
        }
    }
    receive() external payable {}
}

contract LiquidityAdder {
    IPoolManager immutable pm;
    PoolKey key;
    uint256 liq;
    constructor(IPoolManager pm_) { pm = pm_; }
    function add(PoolKey calldata k, uint256 l) external { (key, liq) = (k, l); pm.unlock(""); }
    function unlockCallback(bytes calldata) external returns (bytes memory) {
        (BalanceDelta d,) = pm.modifyLiquidity(key, ModifyLiquidityParams(TickMath.minUsableTick(key.tickSpacing), TickMath.maxUsableTick(key.tickSpacing), int256(liq), 0), "");
        pm.settle{value: uint128(-d.amount0())}();
        pm.sync(key.currency1);
        IERC20(Currency.unwrap(key.currency1)).transfer(address(pm), uint128(-d.amount1()));
        pm.settle();
        return "";
    }
    receive() external payable {}
}

contract BurnImdSandwichTest is Test {
    address constant OWNER = address(0xA11CE);
    address constant TL = address(0x71E10C);
    uint256 constant SUPPLY = 1_000_000_000 ether;
    IPoolManager PM;
    IMD6900RobinhoodLaunch L;
    PoolKey ik;

    function setUp() public {
        PM = IPoolManager(vm.deployCode("PoolManager.sol:PoolManager", abi.encode(address(this))));
        L = IMD6900RobinhoodLaunch(payable(vm.deployCode("IMD6900RobinhoodLaunch.sol:IMD6900RobinhoodLaunch", abi.encode(OWNER, PM, address(new MockToken()), TL))));
        L.createHook(_mineHook());
        // $IMD and a thin pool: ~261 $IMD per ETH, about 6 ETH of ETH-side depth
        address imd = L.IMD();
        vm.etch(imd, address(new MockToken()).code);
        LiquidityAdder adder = new LiquidityAdder(PM);
        vm.deal(address(adder), 100 ether);
        MockToken(imd).mint(address(adder), 1e30);
        ik = L.imdPoolKey();
        PM.initialize(ik, uint160(_sqrt(261 << 192)));
        adder.add(ik, 1e20);
        // launch, then 50 ETH of fees split: 5 ETH in the $IMD bucket
        bytes32 salt = _mineCoin();
        address expected = L.tokenAddress(salt);
        vm.deal(OWNER, 1 ether);
        vm.prank(OWNER);
        L.launch{value: 1 ether}(salt, expected, uint160(_sqrt(FullMath.mulDiv(SUPPLY, 1 << 192, 19.18 ether))), 0, address(L));
        vm.deal(address(this), 50 ether);
        L.addFees{value: 50 ether}();
        L.split();
        assertEq(L.imdBucket(), 5 ether);
    }

    /// Fails on the current code: burnImd accepts whatever price the caller just set in the $IMD pool, so a
    /// sandwicher is paid out of the burn's ETH. Passes once burnImd refuses a buy that is manipulated away from the
    /// pool's fair price (or otherwise bounds the price it pays), whether by reverting or by returning the fair amount.
    function test_TheBurnBuyCannotBeSandwichedForProfit() public {
        address imd = L.IMD();
        // control: what an unmolested burn buy returns
        uint256 snap = vm.snapshotState();
        uint256 clean = L.burnImd(0);
        vm.revertToState(snap);

        Trader attacker = new Trader(PM);
        vm.deal(address(attacker), 3 ether);
        uint256 before = address(attacker).balance;
        // one transaction from the attacker: buy $IMD, trigger the burn buy at the inflated price, sell back
        attacker.swap(ik, true, -3 ether);
        (bool ok, bytes memory ret) = address(L).call(abi.encodeCall(L.burnImd, (0)));
        uint256 got = ok ? abi.decode(ret, (uint256)) : 0;
        attacker.swap(ik, false, -int256(IERC20(imd).balanceOf(address(attacker))));
        emit log_named_decimal_uint("burn executor got, clean", clean, 18);
        emit log_named_decimal_uint("burn executor got, sandwiched", got, 18);
        emit log_named_decimal_int("attacker profit", int256(address(attacker).balance) - int256(before), 18);
        if (ok) assertGe(got, clean * 9 / 10, "the burn bought far less $IMD than the pool's fair price gives");
        assertLe(address(attacker).balance, before, "the sandwicher must not profit from the burn's ETH");
    }

    function _mineHook() internal view returns (bytes32) {
        bytes32 initHash = L.hookInitCodeHash();
        uint160 flags = L.FLAGS();
        for (uint256 i;; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(L), bytes32(i), initHash)))));
            if (uint160(a) & Hooks.ALL_HOOK_MASK == flags && uint160(a) >> 152 != 0x91) return bytes32(i);
        }
    }

    function _mineCoin() internal view returns (bytes32) {
        bytes32 initHash = L.tokenInitCodeHash();
        for (uint256 i;; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(L), bytes32(i), initHash)))));
            if (uint160(a) >> 144 == 0x6900) return bytes32(i);
        }
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        y = x;
        uint256 z = (x + 1) / 2;
        while (z < y) (y, z) = (z, (x / z + z) / 2);
    }
}