// 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";

/// @notice A stranger's free Imp mint on the genesis game, followed by 20 minutes without a roll,
/// marks PvP failed and closes the pad forever: launch() and takeCrown() revert permanently.
/// Fails on the current code (launch reverts "genesis not graduated" forever); passes once a failed
/// genesis no longer locks the pad permanently (restartable genesis, or gating that tolerates failure).
contract GenesisGriefTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    address constant POOL_MANAGER = 0x8366a39CC670B4001A1121B8F6A443A643e40951;
    address constant STRANGER = address(0xBAD);

    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame pvp;

    function setUp() public {
        vm.warp(1_800_000_000);
        PadToken tokenT = new PadToken();
        PadGame gameT = new PadGame();
        pad = new PvPPad(OWNER, address(tokenT), address(gameT));
        liq = new PadLiquidity(POOL_MANAGER, address(pad));
        king = new KingOfThePad(address(pad), address(liq), OWNER);
        pvp = PadGame(pad.gameOf(1));

        bytes32 salt = mineSalt();
        vm.prank(OWNER);
        pad.openPad(salt);
    }

    function mineSalt() internal view returns (bytes32 salt) {
        bytes32 h = liq.hookInitCodeHash();
        address d = address(liq);
        bytes memory buf = abi.encodePacked(bytes1(0xff), d, bytes32(0), h);
        for (uint256 i; i < 300_000; ++i) {
            uint256 a;
            assembly ("memory-safe") {
                mstore(add(buf, 53), i)
                a := and(keccak256(add(buf, 32), 85), 0xffffffffffffffffffffffffffffffffffffffff)
            }
            if (a & 0x3FFF == 0x2000) return bytes32(i);
        }
        revert("no salt");
    }

    function test_strangerMintThenSilenceBricksPadForever() public {
        // 1. Any wallet mints one free Imp on the genesis game: the 10-minute signup starts.
        vm.prank(STRANGER);
        pvp.mint();

        // 2. Nobody rolls for 20 minutes (10 min signup + 10 min death): all dead, no ETH raised.
        vm.warp(vm.getBlockTimestamp() + 20 minutes);
        assertTrue(pvp.ended(), "ended");

        // 3. Permissionless finalize + graduate mark the genesis launch failed.
        pvp.poke(); // finalizes (living == 0)
        pvp.poke(); // graduates -> failed (ethRaised == 0)
        assertTrue(pvp.failed(), "genesis failed");
        assertFalse(pad.genesisGraduated(), "never graduates");

        // 4. The pad is now closed forever: no launch, no king, no path to recover.
        vm.deal(address(this), 1 ether);
        vm.expectRevert(bytes("king not open"));
        king.takeCrown{value: 0.01 ether}();

        // Expected: the pad must still be usable after a griefed genesis. Actual: reverts forever.
        vm.warp(vm.getBlockTimestamp() + 365 days);
        pad.launch("Next", "NXT", "");
        assertGt(pad.launchCount(), 1, "pad usable after genesis failure");
    }

    receive() external payable {}
}

// 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 {IUnlockCallback, PoolKey, ModifyLiquidityParams, SwapParams} from "src/interfaces/Interfaces.sol";

/// ArbSys stand-in at 0x64: block number set by the test, hashes served inside the 256-block window.
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, "invalid block number");
        return keccak256(abi.encode("arb", n));
    }
}

interface IHookInit {
    function beforeInitialize(address sender, PoolKey calldata key, uint160 sqrtPriceX96) external returns (bytes4);
}

/// Minimal PoolManager stand-in: enough for one graduation (initialize through the hook, unlock,
/// a 1 wei / 1 wei liquidity delta, settle). Swaps revert; upkeep wraps them in try/catch.
contract PoolManagerStub {
    function unlock(bytes calldata data) external returns (bytes memory) {
        return IUnlockCallback(msg.sender).unlockCallback(data);
    }

    function initialize(PoolKey memory key, uint160 sqrtPriceX96) external returns (int24) {
        if (key.hooks != address(0)) {
            require(
                IHookInit(key.hooks).beforeInitialize(msg.sender, key, sqrtPriceX96) == IHookInit.beforeInitialize.selector,
                "hook"
            );
        }
        return 0;
    }

    function modifyLiquidity(PoolKey memory, ModifyLiquidityParams memory p, bytes calldata)
        external
        pure
        returns (int256 callerDelta, int256 feesAccrued)
    {
        if (p.liquidityDelta > 0) callerDelta = -1; // amount0 = -1, amount1 = -1
        feesAccrued = 0;
    }

    function swap(PoolKey memory, SwapParams memory, bytes calldata) external pure returns (int256) {
        revert("no swap in stub");
    }

    function sync(address) external {}

    function settle() external payable returns (uint256) {
        return msg.value;
    }

    function take(address, address, uint256) external {}

    receive() external payable {}
}

/// The carry pot (king extras with no live game, dead-game pots, dust) is handed in full to whichever
/// launch comes next. launch() is permissionless, so a single wallet launches a throwaway token, plays
/// alone to the 60-minute end and is paid the whole carry pot as rank 1.
contract CarryPotCaptureTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    ArbSysStub arb;
    PoolManagerStub pm;
    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame pvp;

    address honest = address(0xA001);
    address bidder = address(0xA002);
    address attacker = address(0xA003);

    function setUp() public {
        vm.warp(1_800_000_000);
        ArbSysStub impl = new ArbSysStub();
        vm.etch(address(0x64), address(impl).code);
        arb = ArbSysStub(address(0x64));
        pm = new PoolManagerStub();
        PadToken tokenTemplate = new PadToken();
        PadGame gameTemplate = new PadGame();
        pad = new PvPPad(OWNER, address(tokenTemplate), address(gameTemplate));
        liq = new PadLiquidity(address(pm), address(pad));
        king = new KingOfThePad(address(pad), address(liq), OWNER);
        pvp = PadGame(pad.gameOf(1));
        vm.deal(honest, 10 ether);
        vm.deal(bidder, 10 ether);
        vm.deal(attacker, 1 ether);

        // open the pad with a salt whose hook address carries exactly the beforeInitialize flag
        bytes32 h = liq.hookInitCodeHash();
        bytes32 salt;
        bool found;
        for (uint256 i; i < 500_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);
                found = true;
                break;
            }
        }
        require(found, "no salt");
        vm.prank(OWNER);
        pad.openPad(salt);

        // genesis: one honest roll, then inactivity -> ends, finalizes, graduates
        vm.prank(honest);
        pvp.mint();
        advance(10 minutes);
        vm.prank(honest);
        pvp.roll{value: 0.002 ether}();
        advance(60 minutes);
        pvp.poke(); // resolve + finalize
        pvp.poke(); // graduate
        assertTrue(pad.genesisGraduated(), "genesis graduated");
    }

    function advance(uint256 secs) internal {
        vm.warp(vm.getBlockTimestamp() + secs);
        arb.advance(secs * 4);
    }

    function test_soloLaunchCapturesCarryPot() public {
        // A king bid while no game is live: 50% of the bid goes to the carry pot.
        vm.prank(bidder);
        king.takeCrown{value: 1 ether}();
        uint256 carry = pad.carryPot();
        assertGe(carry, 0.5 ether, "carry pot holds the king's games share");

        uint256 start = attacker.balance;
        vm.prank(attacker);
        uint256 id = pad.launch("junk", "JUNK", "");
        PadGame g = PadGame(pad.gameOf(id));
        assertEq(g.pot(), carry, "whole carry pot moved into the attacker's launch");

        vm.prank(attacker);
        g.mint();
        advance(10 minutes); // play starts
        // stay alive until the 60-minute hard end: one roll every 599 s
        for (uint256 i; i < 6; ++i) {
            vm.prank(attacker);
            g.roll{value: 0.002 ether}();
            advance(599);
        }
        while (!g.ended()) advance(60);
        advance(5);
        vm.prank(attacker);
        g.finalize();
        assertEq(g.livingAtEnd(), 1);
        assertEq(g.paidAtEnd(), 1);

        // Expected: a throwaway solo launch must not profit from ETH other players and the king put in.
        // Actual: the attacker walks away with the carry pot minus six rolls.
        assertLe(attacker.balance, start, "sybil launcher must not profit from the carry pot");
    }
}

// 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 {IUnlockCallback, PoolKey, ModifyLiquidityParams, SwapParams} 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, "invalid block number");
        return keccak256(abi.encode("arb", n));
    }
}

interface IHookInit {
    function beforeInitialize(address sender, PoolKey calldata key, uint160 sqrtPriceX96) external returns (bytes4);
}

contract PoolManagerStub {
    function unlock(bytes calldata data) external returns (bytes memory) {
        return IUnlockCallback(msg.sender).unlockCallback(data);
    }

    function initialize(PoolKey memory key, uint160 sqrtPriceX96) external returns (int24) {
        if (key.hooks != address(0)) {
            require(
                IHookInit(key.hooks).beforeInitialize(msg.sender, key, sqrtPriceX96) == IHookInit.beforeInitialize.selector,
                "hook"
            );
        }
        return 0;
    }

    function modifyLiquidity(PoolKey memory, ModifyLiquidityParams memory p, bytes calldata)
        external
        pure
        returns (int256 callerDelta, int256 feesAccrued)
    {
        if (p.liquidityDelta > 0) callerDelta = -1;
        feesAccrued = 0;
    }

    function swap(PoolKey memory, SwapParams memory, bytes calldata) external pure returns (int256) {
        revert("no swap in stub");
    }

    function sync(address) external {}

    function settle() external payable returns (uint256) {
        return msg.value;
    }

    function take(address, address, uint256) external {}

    receive() external payable {}
}

/// fundGames() pays the king's 50% share to "live games with >= 5 Imps" weighted by pot. Imps are free
/// and one wallet may hold five of them through five addresses, so a throwaway launch with five sybil
/// Imps receives the share and its operator wins it back as the only living Imp.
contract SybilKingShareTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    ArbSysStub arb;
    PoolManagerStub pm;
    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame pvp;

    address honest = address(0xA001);
    address bidder = address(0xA002);
    address[5] sybils = [address(0xC001), address(0xC002), address(0xC003), address(0xC004), address(0xC005)];

    function setUp() public {
        vm.warp(1_800_000_000);
        ArbSysStub impl = new ArbSysStub();
        vm.etch(address(0x64), address(impl).code);
        arb = ArbSysStub(address(0x64));
        pm = new PoolManagerStub();
        PadToken tokenTemplate = new PadToken();
        PadGame gameTemplate = new PadGame();
        pad = new PvPPad(OWNER, address(tokenTemplate), address(gameTemplate));
        liq = new PadLiquidity(address(pm), address(pad));
        king = new KingOfThePad(address(pad), address(liq), OWNER);
        pvp = PadGame(pad.gameOf(1));
        vm.deal(honest, 10 ether);
        vm.deal(bidder, 10 ether);
        for (uint256 i; i < 5; ++i) {
            vm.deal(sybils[i], 1 ether);
        }

        bytes32 h = liq.hookInitCodeHash();
        bytes32 salt;
        bool found;
        for (uint256 i; i < 500_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);
                found = true;
                break;
            }
        }
        require(found, "no salt");
        vm.prank(OWNER);
        pad.openPad(salt);

        vm.prank(honest);
        pvp.mint();
        advance(10 minutes);
        vm.prank(honest);
        pvp.roll{value: 0.002 ether}();
        advance(60 minutes);
        pvp.poke();
        pvp.poke();
        assertTrue(pad.genesisGraduated(), "genesis graduated");
        // drain the carry pot left by genesis into a launch nobody plays, so it does not mix into the numbers
        pad.launch("sink", "SINK", "");
        assertEq(pad.carryPot(), 0);
    }

    function advance(uint256 secs) internal {
        vm.warp(vm.getBlockTimestamp() + secs);
        arb.advance(secs * 4);
    }

    function _sybilBalance() internal view returns (uint256 s) {
        for (uint256 i; i < 5; ++i) {
            s += sybils[i].balance;
        }
    }

    function test_fiveFreeImpsCaptureKingsGamesShare() public {
        uint256 start = _sybilBalance();
        vm.prank(sybils[0]);
        uint256 id = pad.launch("junk", "JUNK", "");
        PadGame g = PadGame(pad.gameOf(id));
        for (uint256 i; i < 5; ++i) {
            vm.prank(sybils[i]);
            g.mint();
        }
        (bool live,) = g.isLiveForKing();
        assertTrue(live, "five free imps make the launch 'live' for the king split");

        // Someone takes the crown: 50% of the bid is paid into the sybil game's pot.
        vm.prank(bidder);
        king.takeCrown{value: 1 ether}();
        assertEq(g.pot(), 0.5 ether, "king's games share landed in the sybil pot");

        // One sybil plays alone to the 60-minute end and is the only living Imp.
        advance(10 minutes);
        for (uint256 i; i < 6; ++i) {
            vm.prank(sybils[0]);
            g.roll{value: 0.002 ether}();
            advance(599);
        }
        while (!g.ended()) advance(60);
        advance(5);
        vm.prank(sybils[0]);
        g.finalize();
        assertEq(g.livingAtEnd(), 1);

        // Expected: the king's extra reaches games other people are playing, not the bidder-independent
        // operator of five free Imps. Actual: the sybil wallets net about +0.49 ETH.
        assertLe(_sybilBalance(), start, "five free imps must not capture the king's games share");
    }
}

// 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,
    IERC20Min,
    PoolKey,
    ModifyLiquidityParams,
    SwapParams
} from "src/interfaces/Interfaces.sol";
import {PadLib} from "src/libs/PadLib.sol";

/// Proof for: a game finalized by the upkeep that KingOfThePad.takeCrown triggers pays the finalizer
/// fee to the KingOfThePad contract (msg.sender of pad.upkeep). KingOfThePad has no receive(), so the
/// push fails and the fee becomes claimable[KingOfThePad] inside the game, which nothing can claim.
/// Expected: the fee reaches the bidder (the account that paid for the finalizing transaction) or is
/// at least recoverable. Actual: it is locked in the game forever.
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, "invalid block number");
        return keccak256(abi.encode("arb", n));
    }
}

interface IHookInit {
    function beforeInitialize(address sender, PoolKey calldata key, uint160 sqrtPriceX96) external returns (bytes4);
}

contract PMStub is IPoolManager {
    uint256 internal constant Q96 = 1 << 96;
    uint160 internal constant SQRT_MIN_FULL = 4_310_618_291;
    uint160 internal constant SQRT_MAX_FULL = 1_456_195_216_270_955_103_182_949_462_556_801_019_286_893_565_306;

    struct P {
        bool init;
        uint160 sqrtP;
        uint256 r0;
        uint256 r1;
    }

    mapping(bytes32 => P) public pools;
    mapping(address => int256) public delta;
    address public locker;
    address public syncedToken;
    uint256 public syncedBalance;

    function unlock(bytes calldata data) external returns (bytes memory result) {
        locker = msg.sender;
        result = IUnlockCallback(msg.sender).unlockCallback(data);
        locker = address(0);
    }

    function initialize(PoolKey memory key, uint160 sqrtPriceX96) external returns (int24) {
        P storage p = pools[keccak256(abi.encode(key))];
        require(!p.init, "initialized");
        IHookInit(key.hooks).beforeInitialize(msg.sender, key, sqrtPriceX96);
        p.init = true;
        p.sqrtP = sqrtPriceX96;
        return 0;
    }

    function modifyLiquidity(PoolKey memory key, ModifyLiquidityParams memory params, bytes calldata)
        external
        returns (int256 callerDelta, int256 feesAccrued)
    {
        P storage p = pools[keccak256(abi.encode(key))];
        if (params.liquidityDelta > 0) {
            uint256 l = uint256(params.liquidityDelta);
            uint256 a0 = PadLib.mulDiv(l, PadLib.mulDiv(SQRT_MAX_FULL - p.sqrtP, Q96, SQRT_MAX_FULL), p.sqrtP) + 1;
            uint256 a1 = PadLib.mulDiv(l, p.sqrtP - SQRT_MIN_FULL, Q96) + 1;
            p.r0 += a0;
            p.r1 += a1;
            callerDelta = _pack(-int256(a0), -int256(a1));
        }
        feesAccrued = 0;
    }

    function swap(PoolKey memory, SwapParams memory, bytes calldata) external pure returns (int256) {
        revert("no swap in stub");
    }

    function sync(address currency) external {
        syncedToken = currency;
        syncedBalance = IERC20Min(currency).balanceOf(address(this));
    }

    function settle() external payable returns (uint256) {
        return msg.value;
    }

    function take(address, address, uint256) external pure {}

    function _pack(int256 a0, int256 a1) internal pure returns (int256 d) {
        assembly ("memory-safe") {
            d := or(shl(128, a0), and(a1, 0xffffffffffffffffffffffffffffffff))
        }
    }

    receive() external payable {}
}

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

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

contract FinalizerFeeStuckTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    ArbSysStub arb;
    PMStub pm;
    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame pvp;
    address[] players;

    function setUp() public {
        vm.warp(1_800_000_000);
        ArbSysStub impl = new ArbSysStub();
        vm.etch(address(0x64), address(impl).code);
        arb = ArbSysStub(address(0x64));
        pm = new PMStub();
        Deployer d = new Deployer();
        d.deployAll(OWNER, address(pm));
        pad = d.pad();
        liq = d.liquidity();
        king = d.king();
        pvp = PadGame(pad.gameOf(1));
        for (uint256 i; i < 8; ++i) {
            address p = address(uint160(0xA000 + i));
            players.push(p);
            vm.deal(p, 10 ether);
        }
        // open the pad with a mined 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);
    }

    function advance(uint256 secs) internal {
        vm.warp(vm.getBlockTimestamp() + secs);
        arb.advance(secs * 4);
    }

    function playAndGraduate(PadGame g, uint256 n) internal {
        for (uint256 i; i < n; ++i) {
            vm.prank(players[i]);
            g.mint();
        }
        advance(10 minutes);
        for (uint256 i; i < n; ++i) {
            vm.prank(players[i]);
            g.roll{value: 0.002 ether}();
        }
        advance(60 minutes);
        g.poke();
        if (!g.finalized()) g.finalize();
        if (!g.graduated()) g.graduate();
    }

    function test_finalizerFeeIsLockedInsideGameWhenTakeCrownFinalizes() public {
        playAndGraduate(pvp, 2);
        assertTrue(pad.genesisGraduated());

        // launch #2, play it, let it end with a pot, but do not finalize it
        uint256 id = pad.launch("Foo", "FOO", "");
        PadGame g = PadGame(pad.gameOf(id));
        for (uint256 i; i < 3; ++i) {
            vm.prank(players[i]);
            g.mint();
        }
        advance(10 minutes);
        for (uint256 i; i < 3; ++i) {
            vm.prank(players[i]);
            g.roll{value: 0.002 ether}();
        }
        advance(60 minutes);
        assertTrue(g.ended());
        assertFalse(g.finalized());
        uint256 potBefore = g.pot();
        uint256 expectedFee = potBefore * 50 / 10_000;
        assertGt(expectedFee, 0);

        // the bidder's takeCrown runs pad.upkeep(), which finalizes launch #2
        address bidder = players[7];
        uint256 bidderBefore = bidder.balance;
        vm.prank(bidder);
        king.takeCrown{value: 0.01 ether}();
        assertTrue(g.finalized(), "upkeep finalized the game");

        // Expected: the 0.5% finalizer fee reaches the bidder (or is recoverable by someone).
        // Actual: it is credited to the KingOfThePad contract inside the game and can never be claimed.
        assertEq(g.claimable(address(king)), 0, "fee must not be stranded on the king contract");
        assertEq(bidder.balance, bidderBefore - 0.01 ether + expectedFee, "bidder receives the finalizer fee");
    }
}

// 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";

/// @notice A stranger's free Imp mint on the genesis game, followed by 20 minutes without a roll,
/// marks PvP failed and closes the pad forever: launch() and takeCrown() revert permanently.
/// Fails on the current code (launch reverts "genesis not graduated" forever); passes once a failed
/// genesis no longer locks the pad permanently (restartable genesis, or gating that tolerates failure).
contract GenesisGriefTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    address constant POOL_MANAGER = 0x8366a39CC670B4001A1121B8F6A443A643e40951;
    address constant STRANGER = address(0xBAD);

    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame pvp;

    function setUp() public {
        vm.warp(1_800_000_000);
        PadToken tokenT = new PadToken();
        PadGame gameT = new PadGame();
        pad = new PvPPad(OWNER, address(tokenT), address(gameT));
        liq = new PadLiquidity(POOL_MANAGER, address(pad));
        king = new KingOfThePad(address(pad), address(liq), OWNER);
        pvp = PadGame(pad.gameOf(1));

        bytes32 salt = mineSalt();
        vm.prank(OWNER);
        pad.openPad(salt);
    }

    function mineSalt() internal view returns (bytes32 salt) {
        bytes32 h = liq.hookInitCodeHash();
        address d = address(liq);
        bytes memory buf = abi.encodePacked(bytes1(0xff), d, bytes32(0), h);
        for (uint256 i; i < 300_000; ++i) {
            uint256 a;
            assembly ("memory-safe") {
                mstore(add(buf, 53), i)
                a := and(keccak256(add(buf, 32), 85), 0xffffffffffffffffffffffffffffffffffffffff)
            }
            if (a & 0x3FFF == 0x2000) return bytes32(i);
        }
        revert("no salt");
    }

    function test_strangerMintThenSilenceBricksPadForever() public {
        // 1. Any wallet mints one free Imp on the genesis game: the 10-minute signup starts.
        vm.prank(STRANGER);
        pvp.mint();

        // 2. Nobody rolls for 20 minutes (10 min signup + 10 min death): all dead, no ETH raised.
        vm.warp(vm.getBlockTimestamp() + 20 minutes);
        assertTrue(pvp.ended(), "ended");

        // 3. Permissionless finalize + graduate mark the genesis launch failed.
        pvp.poke(); // finalizes (living == 0)
        pvp.poke(); // graduates -> failed (ethRaised == 0)
        assertTrue(pvp.failed(), "genesis failed");
        assertFalse(pad.genesisGraduated(), "never graduates");

        // 4. The pad is now closed forever: no launch, no king, no path to recover.
        vm.deal(address(this), 1 ether);
        vm.expectRevert(bytes("king not open"));
        king.takeCrown{value: 0.01 ether}();

        // Expected: the pad must still be usable after a griefed genesis. Actual: reverts forever.
        vm.warp(vm.getBlockTimestamp() + 365 days);
        pad.launch("Next", "NXT", "");
        assertGt(pad.launchCount(), 1, "pad usable after genesis failure");
    }

    receive() external payable {}
}

// 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 {IUnlockCallback, PoolKey, ModifyLiquidityParams, SwapParams} from "src/interfaces/Interfaces.sol";

/// ArbSys stand-in at 0x64: block number set by the test, hashes served inside the 256-block window.
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, "invalid block number");
        return keccak256(abi.encode("arb", n));
    }
}

interface IHookInit {
    function beforeInitialize(address sender, PoolKey calldata key, uint160 sqrtPriceX96) external returns (bytes4);
}

/// Minimal PoolManager stand-in: enough for one graduation (initialize through the hook, unlock,
/// a 1 wei / 1 wei liquidity delta, settle). Swaps revert; upkeep wraps them in try/catch.
contract PoolManagerStub {
    function unlock(bytes calldata data) external returns (bytes memory) {
        return IUnlockCallback(msg.sender).unlockCallback(data);
    }

    function initialize(PoolKey memory key, uint160 sqrtPriceX96) external returns (int24) {
        if (key.hooks != address(0)) {
            require(
                IHookInit(key.hooks).beforeInitialize(msg.sender, key, sqrtPriceX96) == IHookInit.beforeInitialize.selector,
                "hook"
            );
        }
        return 0;
    }

    function modifyLiquidity(PoolKey memory, ModifyLiquidityParams memory p, bytes calldata)
        external
        pure
        returns (int256 callerDelta, int256 feesAccrued)
    {
        if (p.liquidityDelta > 0) callerDelta = -1; // amount0 = -1, amount1 = -1
        feesAccrued = 0;
    }

    function swap(PoolKey memory, SwapParams memory, bytes calldata) external pure returns (int256) {
        revert("no swap in stub");
    }

    function sync(address) external {}

    function settle() external payable returns (uint256) {
        return msg.value;
    }

    function take(address, address, uint256) external {}

    receive() external payable {}
}

/// The carry pot (king extras with no live game, dead-game pots, dust) is handed in full to whichever
/// launch comes next. launch() is permissionless, so a single wallet launches a throwaway token, plays
/// alone to the 60-minute end and is paid the whole carry pot as rank 1.
contract CarryPotCaptureTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    ArbSysStub arb;
    PoolManagerStub pm;
    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame pvp;

    address honest = address(0xA001);
    address bidder = address(0xA002);
    address attacker = address(0xA003);

    function setUp() public {
        vm.warp(1_800_000_000);
        ArbSysStub impl = new ArbSysStub();
        vm.etch(address(0x64), address(impl).code);
        arb = ArbSysStub(address(0x64));
        pm = new PoolManagerStub();
        PadToken tokenTemplate = new PadToken();
        PadGame gameTemplate = new PadGame();
        pad = new PvPPad(OWNER, address(tokenTemplate), address(gameTemplate));
        liq = new PadLiquidity(address(pm), address(pad));
        king = new KingOfThePad(address(pad), address(liq), OWNER);
        pvp = PadGame(pad.gameOf(1));
        vm.deal(honest, 10 ether);
        vm.deal(bidder, 10 ether);
        vm.deal(attacker, 1 ether);

        // open the pad with a salt whose hook address carries exactly the beforeInitialize flag
        bytes32 h = liq.hookInitCodeHash();
        bytes32 salt;
        bool found;
        for (uint256 i; i < 500_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);
                found = true;
                break;
            }
        }
        require(found, "no salt");
        vm.prank(OWNER);
        pad.openPad(salt);

        // genesis: one honest roll, then inactivity -> ends, finalizes, graduates
        vm.prank(honest);
        pvp.mint();
        advance(10 minutes);
        vm.prank(honest);
        pvp.roll{value: 0.002 ether}();
        advance(60 minutes);
        pvp.poke(); // resolve + finalize
        pvp.poke(); // graduate
        assertTrue(pad.genesisGraduated(), "genesis graduated");
    }

    function advance(uint256 secs) internal {
        vm.warp(vm.getBlockTimestamp() + secs);
        arb.advance(secs * 4);
    }

    function test_soloLaunchCapturesCarryPot() public {
        // A king bid while no game is live: 50% of the bid goes to the carry pot.
        vm.prank(bidder);
        king.takeCrown{value: 1 ether}();
        uint256 carry = pad.carryPot();
        assertGe(carry, 0.5 ether, "carry pot holds the king's games share");

        uint256 start = attacker.balance;
        vm.prank(attacker);
        uint256 id = pad.launch("junk", "JUNK", "");
        PadGame g = PadGame(pad.gameOf(id));
        assertEq(g.pot(), carry, "whole carry pot moved into the attacker's launch");

        vm.prank(attacker);
        g.mint();
        advance(10 minutes); // play starts
        // stay alive until the 60-minute hard end: one roll every 599 s
        for (uint256 i; i < 6; ++i) {
            vm.prank(attacker);
            g.roll{value: 0.002 ether}();
            advance(599);
        }
        while (!g.ended()) advance(60);
        advance(5);
        vm.prank(attacker);
        g.finalize();
        assertEq(g.livingAtEnd(), 1);
        assertEq(g.paidAtEnd(), 1);

        // Expected: a throwaway solo launch must not profit from ETH other players and the king put in.
        // Actual: the attacker walks away with the carry pot minus six rolls.
        assertLe(attacker.balance, start, "sybil launcher must not profit from the carry pot");
    }
}

// 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 {IUnlockCallback, PoolKey, ModifyLiquidityParams, SwapParams} 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, "invalid block number");
        return keccak256(abi.encode("arb", n));
    }
}

interface IHookInit {
    function beforeInitialize(address sender, PoolKey calldata key, uint160 sqrtPriceX96) external returns (bytes4);
}

contract PoolManagerStub {
    function unlock(bytes calldata data) external returns (bytes memory) {
        return IUnlockCallback(msg.sender).unlockCallback(data);
    }

    function initialize(PoolKey memory key, uint160 sqrtPriceX96) external returns (int24) {
        if (key.hooks != address(0)) {
            require(
                IHookInit(key.hooks).beforeInitialize(msg.sender, key, sqrtPriceX96) == IHookInit.beforeInitialize.selector,
                "hook"
            );
        }
        return 0;
    }

    function modifyLiquidity(PoolKey memory, ModifyLiquidityParams memory p, bytes calldata)
        external
        pure
        returns (int256 callerDelta, int256 feesAccrued)
    {
        if (p.liquidityDelta > 0) callerDelta = -1;
        feesAccrued = 0;
    }

    function swap(PoolKey memory, SwapParams memory, bytes calldata) external pure returns (int256) {
        revert("no swap in stub");
    }

    function sync(address) external {}

    function settle() external payable returns (uint256) {
        return msg.value;
    }

    function take(address, address, uint256) external {}

    receive() external payable {}
}

/// fundGames() pays the king's 50% share to "live games with >= 5 Imps" weighted by pot. Imps are free
/// and one wallet may hold five of them through five addresses, so a throwaway launch with five sybil
/// Imps receives the share and its operator wins it back as the only living Imp.
contract SybilKingShareTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    ArbSysStub arb;
    PoolManagerStub pm;
    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame pvp;

    address honest = address(0xA001);
    address bidder = address(0xA002);
    address[5] sybils = [address(0xC001), address(0xC002), address(0xC003), address(0xC004), address(0xC005)];

    function setUp() public {
        vm.warp(1_800_000_000);
        ArbSysStub impl = new ArbSysStub();
        vm.etch(address(0x64), address(impl).code);
        arb = ArbSysStub(address(0x64));
        pm = new PoolManagerStub();
        PadToken tokenTemplate = new PadToken();
        PadGame gameTemplate = new PadGame();
        pad = new PvPPad(OWNER, address(tokenTemplate), address(gameTemplate));
        liq = new PadLiquidity(address(pm), address(pad));
        king = new KingOfThePad(address(pad), address(liq), OWNER);
        pvp = PadGame(pad.gameOf(1));
        vm.deal(honest, 10 ether);
        vm.deal(bidder, 10 ether);
        for (uint256 i; i < 5; ++i) {
            vm.deal(sybils[i], 1 ether);
        }

        bytes32 h = liq.hookInitCodeHash();
        bytes32 salt;
        bool found;
        for (uint256 i; i < 500_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);
                found = true;
                break;
            }
        }
        require(found, "no salt");
        vm.prank(OWNER);
        pad.openPad(salt);

        vm.prank(honest);
        pvp.mint();
        advance(10 minutes);
        vm.prank(honest);
        pvp.roll{value: 0.002 ether}();
        advance(60 minutes);
        pvp.poke();
        pvp.poke();
        assertTrue(pad.genesisGraduated(), "genesis graduated");
        // drain the carry pot left by genesis into a launch nobody plays, so it does not mix into the numbers
        pad.launch("sink", "SINK", "");
        assertEq(pad.carryPot(), 0);
    }

    function advance(uint256 secs) internal {
        vm.warp(vm.getBlockTimestamp() + secs);
        arb.advance(secs * 4);
    }

    function _sybilBalance() internal view returns (uint256 s) {
        for (uint256 i; i < 5; ++i) {
            s += sybils[i].balance;
        }
    }

    function test_fiveFreeImpsCaptureKingsGamesShare() public {
        uint256 start = _sybilBalance();
        vm.prank(sybils[0]);
        uint256 id = pad.launch("junk", "JUNK", "");
        PadGame g = PadGame(pad.gameOf(id));
        for (uint256 i; i < 5; ++i) {
            vm.prank(sybils[i]);
            g.mint();
        }
        (bool live,) = g.isLiveForKing();
        assertTrue(live, "five free imps make the launch 'live' for the king split");

        // Someone takes the crown: 50% of the bid is paid into the sybil game's pot.
        vm.prank(bidder);
        king.takeCrown{value: 1 ether}();
        assertEq(g.pot(), 0.5 ether, "king's games share landed in the sybil pot");

        // One sybil plays alone to the 60-minute end and is the only living Imp.
        advance(10 minutes);
        for (uint256 i; i < 6; ++i) {
            vm.prank(sybils[0]);
            g.roll{value: 0.002 ether}();
            advance(599);
        }
        while (!g.ended()) advance(60);
        advance(5);
        vm.prank(sybils[0]);
        g.finalize();
        assertEq(g.livingAtEnd(), 1);

        // Expected: the king's extra reaches games other people are playing, not the bidder-independent
        // operator of five free Imps. Actual: the sybil wallets net about +0.49 ETH.
        assertLe(_sybilBalance(), start, "five free imps must not capture the king's games share");
    }
}

// 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,
    IERC20Min,
    PoolKey,
    ModifyLiquidityParams,
    SwapParams
} from "src/interfaces/Interfaces.sol";
import {PadLib} from "src/libs/PadLib.sol";

/// Proof for: a game finalized by the upkeep that KingOfThePad.takeCrown triggers pays the finalizer
/// fee to the KingOfThePad contract (msg.sender of pad.upkeep). KingOfThePad has no receive(), so the
/// push fails and the fee becomes claimable[KingOfThePad] inside the game, which nothing can claim.
/// Expected: the fee reaches the bidder (the account that paid for the finalizing transaction) or is
/// at least recoverable. Actual: it is locked in the game forever.
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, "invalid block number");
        return keccak256(abi.encode("arb", n));
    }
}

interface IHookInit {
    function beforeInitialize(address sender, PoolKey calldata key, uint160 sqrtPriceX96) external returns (bytes4);
}

contract PMStub is IPoolManager {
    uint256 internal constant Q96 = 1 << 96;
    uint160 internal constant SQRT_MIN_FULL = 4_310_618_291;
    uint160 internal constant SQRT_MAX_FULL = 1_456_195_216_270_955_103_182_949_462_556_801_019_286_893_565_306;

    struct P {
        bool init;
        uint160 sqrtP;
        uint256 r0;
        uint256 r1;
    }

    mapping(bytes32 => P) public pools;
    mapping(address => int256) public delta;
    address public locker;
    address public syncedToken;
    uint256 public syncedBalance;

    function unlock(bytes calldata data) external returns (bytes memory result) {
        locker = msg.sender;
        result = IUnlockCallback(msg.sender).unlockCallback(data);
        locker = address(0);
    }

    function initialize(PoolKey memory key, uint160 sqrtPriceX96) external returns (int24) {
        P storage p = pools[keccak256(abi.encode(key))];
        require(!p.init, "initialized");
        IHookInit(key.hooks).beforeInitialize(msg.sender, key, sqrtPriceX96);
        p.init = true;
        p.sqrtP = sqrtPriceX96;
        return 0;
    }

    function modifyLiquidity(PoolKey memory key, ModifyLiquidityParams memory params, bytes calldata)
        external
        returns (int256 callerDelta, int256 feesAccrued)
    {
        P storage p = pools[keccak256(abi.encode(key))];
        if (params.liquidityDelta > 0) {
            uint256 l = uint256(params.liquidityDelta);
            uint256 a0 = PadLib.mulDiv(l, PadLib.mulDiv(SQRT_MAX_FULL - p.sqrtP, Q96, SQRT_MAX_FULL), p.sqrtP) + 1;
            uint256 a1 = PadLib.mulDiv(l, p.sqrtP - SQRT_MIN_FULL, Q96) + 1;
            p.r0 += a0;
            p.r1 += a1;
            callerDelta = _pack(-int256(a0), -int256(a1));
        }
        feesAccrued = 0;
    }

    function swap(PoolKey memory, SwapParams memory, bytes calldata) external pure returns (int256) {
        revert("no swap in stub");
    }

    function sync(address currency) external {
        syncedToken = currency;
        syncedBalance = IERC20Min(currency).balanceOf(address(this));
    }

    function settle() external payable returns (uint256) {
        return msg.value;
    }

    function take(address, address, uint256) external pure {}

    function _pack(int256 a0, int256 a1) internal pure returns (int256 d) {
        assembly ("memory-safe") {
            d := or(shl(128, a0), and(a1, 0xffffffffffffffffffffffffffffffff))
        }
    }

    receive() external payable {}
}

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

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

contract FinalizerFeeStuckTest is Test {
    address constant OWNER = 0x5b95A971B4583A5f011E9DA082acdD679b870D06;
    ArbSysStub arb;
    PMStub pm;
    PvPPad pad;
    PadLiquidity liq;
    KingOfThePad king;
    PadGame pvp;
    address[] players;

    function setUp() public {
        vm.warp(1_800_000_000);
        ArbSysStub impl = new ArbSysStub();
        vm.etch(address(0x64), address(impl).code);
        arb = ArbSysStub(address(0x64));
        pm = new PMStub();
        Deployer d = new Deployer();
        d.deployAll(OWNER, address(pm));
        pad = d.pad();
        liq = d.liquidity();
        king = d.king();
        pvp = PadGame(pad.gameOf(1));
        for (uint256 i; i < 8; ++i) {
            address p = address(uint160(0xA000 + i));
            players.push(p);
            vm.deal(p, 10 ether);
        }
        // open the pad with a mined 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);
    }

    function advance(uint256 secs) internal {
        vm.warp(vm.getBlockTimestamp() + secs);
        arb.advance(secs * 4);
    }

    function playAndGraduate(PadGame g, uint256 n) internal {
        for (uint256 i; i < n; ++i) {
            vm.prank(players[i]);
            g.mint();
        }
        advance(10 minutes);
        for (uint256 i; i < n; ++i) {
            vm.prank(players[i]);
            g.roll{value: 0.002 ether}();
        }
        advance(60 minutes);
        g.poke();
        if (!g.finalized()) g.finalize();
        if (!g.graduated()) g.graduate();
    }

    function test_finalizerFeeIsLockedInsideGameWhenTakeCrownFinalizes() public {
        playAndGraduate(pvp, 2);
        assertTrue(pad.genesisGraduated());

        // launch #2, play it, let it end with a pot, but do not finalize it
        uint256 id = pad.launch("Foo", "FOO", "");
        PadGame g = PadGame(pad.gameOf(id));
        for (uint256 i; i < 3; ++i) {
            vm.prank(players[i]);
            g.mint();
        }
        advance(10 minutes);
        for (uint256 i; i < 3; ++i) {
            vm.prank(players[i]);
            g.roll{value: 0.002 ether}();
        }
        advance(60 minutes);
        assertTrue(g.ended());
        assertFalse(g.finalized());
        uint256 potBefore = g.pot();
        uint256 expectedFee = potBefore * 50 / 10_000;
        assertGt(expectedFee, 0);

        // the bidder's takeCrown runs pad.upkeep(), which finalizes launch #2
        address bidder = players[7];
        uint256 bidderBefore = bidder.balance;
        vm.prank(bidder);
        king.takeCrown{value: 0.01 ether}();
        assertTrue(g.finalized(), "upkeep finalized the game");

        // Expected: the 0.5% finalizer fee reaches the bidder (or is recoverable by someone).
        // Actual: it is credited to the KingOfThePad contract inside the game and can never be claimed.
        assertEq(g.claimable(address(king)), 0, "fee must not be stranded on the king contract");
        assertEq(bidder.balance, bidderBefore - 0.01 ether + expectedFee, "bidder receives the finalizer fee");
    }
}