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

import {Test} from "forge-std/Test.sol";
import {Deployers} from "v4-core/test/utils/Deployers.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {SherwoodV2, IDiceEntropy} from "src/SherwoodV2.sol";

/// A Dice stand-in that reveals the way Dice / Pyth Entropy does: the consumer callback gets exactly
/// the gas limit the request asked for (FLIP_CALLBACK_GAS), and a failing callback is not applied.
contract GasBoundedDice {
    uint128 public fee = 25_000_000_000_000;
    uint64 public nextSequence = 1;
    mapping(uint64 => address) public requester;
    mapping(uint64 => uint32) public gasLimitOf;

    function getFeeV2(address, uint32) external view returns (uint128) {
        return fee;
    }

    function requestV2(address, bytes32, uint32 gasLimit) external payable returns (uint64 sequence) {
        require(msg.value >= fee, "fee");
        sequence = nextSequence++;
        requester[sequence] = msg.sender;
        gasLimitOf[sequence] = gasLimit;
    }

    /// Reveals with the requested gas limit; returns whether the consumer callback succeeded.
    function reveal(uint64 sequence, bytes32 random) external returns (bool ok, uint256 gasUsed) {
        uint256 before = gasleft();
        (ok,) = requester[sequence].call{gas: gasLimitOf[sequence]}(
            abi.encodeWithSelector(SherwoodV2._entropyCallback.selector, sequence, address(0), random)
        );
        gasUsed = before - gasleft();
    }

    function refundRequest(address, uint64) external {}

    receive() external payable {}
}

contract FlipCallbackGasProofTest is Test, Deployers {
    SherwoodV2 hook;
    MockERC20 gameToken;
    MockERC20 hostToken;
    GasBoundedDice dice;
    PoolKey gameKey;

    address owner = makeAddr("owner");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    uint256 constant START = 1_760_000_000;
    uint256 constant GENESIS = START - 2 hours;

    uint160 constant FLAGS = uint160(
        Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
            | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG
    );

    function setUp() public {
        vm.warp(START);
        deployFreshManagerAndRouters();
        gameToken = new MockERC20("GAME", "GAME", 18);
        gameToken.mint(address(this), 1e30);
        gameToken.approve(address(modifyLiquidityRouter), type(uint256).max);
        hostToken = new MockERC20("HOST", "HOST", 18);
        dice = new GasBoundedDice();

        address hookAddr = address(FLAGS | (uint160(0x4444) << 144));
        deployCodeTo(
            "SherwoodV2.sol:SherwoodV2",
            abi.encode(
                manager,
                Currency.wrap(address(gameToken)),
                Currency.wrap(address(hostToken)),
                100_000e18,
                IDiceEntropy(address(dice)),
                address(1),
                owner,
                GENESIS
            ),
            hookAddr
        );
        hook = SherwoodV2(payable(hookAddr));

        vm.prank(owner);
        (gameKey,) = initPool(
            CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(gameToken)), IHooks(hookAddr), 3000, SQRT_PRICE_1_1
        );
        vm.deal(address(this), 1_000 ether);
        modifyLiquidityRouter.modifyLiquidity{value: 500 ether}(
            gameKey, ModifyLiquidityParams({tickLower: -60000, tickUpper: 60000, liquidityDelta: 100e18, salt: 0}), ""
        );
    }

    function _buy(address who, uint256 amount, SherwoodV2.Move move) internal {
        vm.deal(who, who.balance + amount);
        vm.prank(who, who);
        swapRouter.swap{value: amount}(
            gameKey,
            SwapParams({zeroForOne: true, amountSpecified: -int256(amount), sqrtPriceLimitX96: MIN_PRICE_LIMIT}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            abi.encode(uint256(move))
        );
    }

    /// The round's #1 loses a flip in a round with 200 players. Dice gives the callback
    /// FLIP_CALLBACK_GAS. The loss debits the leader, which marks the cached leader stale, and
    /// _updateReign then rescans every player of the round inside the callback (two cold SLOADs
    /// per player), so the callback runs out of gas and the loss is never applied. After
    /// FLIP_TIMEOUT anyone can expire the flip, which credits the leader the stake as a plain buy.
    function test_leaderLostFlipCallbackMustFitDiceGasLimit() public {
        _buy(alice, 0.1 ether, SherwoodV2.Move.BUY); // alice 100, #1
        for (uint256 i; i < 200; ++i) {
            _buy(address(uint160(0x1000 + i)), 0.001 ether, SherwoodV2.Move.BUY);
        }
        _buy(bob, 0.002 ether, SherwoodV2.Move.BUY); // the previous player, who a loss pays
        _buy(alice, 0.05 ether, SherwoodV2.Move.FLIP); // stake 50, sequence 1
        assertEq(hook.pendingFlips(0), 1);
        assertEq(hook.points(0, alice), 100);

        vm.warp(START + 60);
        vm.cool(address(hook)); // the reveal is its own transaction: every slot it reads is cold
        (bool ok, uint256 gasUsed) = dice.reveal(1, bytes32(uint256(1))); // odd: a loss
        emit log_named_uint("callback gas limit", hook.FLIP_CALLBACK_GAS());
        emit log_named_uint("callback gas used", gasUsed);
        assertTrue(ok, "Dice callback ran out of gas: the leader's lost flip is never applied");
        assertEq(hook.points(0, alice), 50, "the loss should have come off the leader");
        assertEq(hook.points(0, bob), 52, "the previous player should have been paid the stake");
        assertEq(hook.pendingFlips(0), 0);
    }

    /// Reference: a non-leader's lost flip (no rescan) fits in the gas limit.
    function test_nonLeaderLostFlipFits() public {
        _buy(alice, 0.1 ether, SherwoodV2.Move.BUY);
        for (uint256 i; i < 200; ++i) {
            _buy(address(uint160(0x1000 + i)), 0.001 ether, SherwoodV2.Move.BUY);
        }
        _buy(bob, 0.05 ether, SherwoodV2.Move.FLIP); // bob is not #1
        vm.warp(START + 60);
        vm.cool(address(hook));
        (bool ok, uint256 gasUsed) = dice.reveal(1, bytes32(uint256(1)));
        emit log_named_uint("non-leader loss callback gas used", gasUsed);
        assertTrue(ok);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {SherwoodV2, IDiceEntropy} from "src/SherwoodV2.sol";

contract NoDice {
    function getFeeV2(address, uint32) external pure returns (uint128) {
        return 25_000_000_000_000;
    }
}

contract LargeBoardKingTest is Test {
    uint256 internal constant GENESIS = 1_791_835_200;
    uint160 internal constant PRICE_ONE = 79228162514264337593543950336;

    IPoolManager internal manager;
    PoolSwapTest internal router;
    MockERC20 internal gameToken;
    SherwoodV2 internal game;
    PoolKey internal gameKey;

    receive() external payable {}

    function setUp() public {
        vm.warp(GENESIS + 1);
        address owner = makeAddr("owner");
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        PoolModifyLiquidityTest lr = new PoolModifyLiquidityTest(manager);
        gameToken = new MockERC20("Game", "GAME", 18);
        MockERC20 hostToken = new MockERC20("Host", "HOST", 18);
        address hookAddress = address(uint160(0xA11D0000) | uint160(0x20CC));
        deployCodeTo(
            "SherwoodV2.sol:SherwoodV2",
            abi.encode(
                manager,
                Currency.wrap(address(gameToken)),
                Currency.wrap(address(hostToken)),
                uint256(100_000e18),
                IDiceEntropy(address(new NoDice())),
                makeAddr("provider"),
                owner,
                GENESIS
            ),
            hookAddress
        );
        game = SherwoodV2(payable(hookAddress));
        gameKey = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(gameToken)), 9000, 180, IHooks(hookAddress));
        vm.prank(owner);
        manager.initialize(gameKey, PRICE_ONE);
        gameToken.mint(address(this), 1e30);
        gameToken.approve(address(lr), type(uint256).max);
        vm.deal(address(this), 50_000 ether);
        lr.modifyLiquidity{value: 25_000 ether}(gameKey, ModifyLiquidityParams(-59400, 59400, 10_000e18, bytes32(0)), "");
    }

    function _buy(address who, uint256 amount) internal {
        vm.deal(who, who.balance + amount);
        vm.prank(who, who);
        router.swap{value: amount}(
            gameKey,
            SwapParams(true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            abi.encode(uint256(0))
        );
    }

    function _sellAll(address who) internal {
        uint256 amount = gameToken.balanceOf(who);
        vm.startPrank(who, who);
        gameToken.approve(address(router), type(uint256).max);
        router.swap(
            gameKey,
            SwapParams(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        vm.stopPrank();
    }

    /// 1,501 players, the leader sells, a 1-point player then plays: the stale cache hands that
    /// player the reign for the rest of the round and the King of the Hill prize, while Bob holds
    /// the top score (90 points) the whole time.
    function test_kingPrizeGoesToTrueLeaderOnLargeBoard() public {
        address alice = makeAddr("alice");
        address bob = makeAddr("bob");
        address carol = makeAddr("carol");
        _buy(alice, 0.1 ether); // 100 points
        _buy(bob, 0.09 ether); // 90 points
        for (uint256 i; i < 1499; ++i) _buy(address(uint160(0x100000 + i)), 0.001 ether); // 1 point each
        vm.warp(GENESIS + 1 hours);
        _sellAll(alice); // alice's points wiped; the cached leader is now stale and n > MAX_LEADER_SCAN
        _buy(carol, 0.001 ether); // 1 point
        vm.warp(game.roundEnd(0) + game.SETTLE_DELAY());
        while (!game.settle(0, 200)) {}
        (, address[3] memory top,,,, address king,,,) = game.result(0);
        assertEq(top[0], bob, "bob is #1");
        assertEq(king, bob, "bob held #1 for ~19 hours and must be King; carol (1 point) is crowned instead");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {SherwoodV2, IDiceEntropy} from "src/SherwoodV2.sol";

contract ProofNoDice {
    function getFeeV2(address, uint32) external pure returns (uint128) {
        return 25_000_000_000_000;
    }
}

/// On a board of more than MAX_LEADER_SCAN players, every second after the cached leader is first
/// debited is parked on the UNKNOWN_REIGN marker and handed to the round's final #1 at settlement,
/// whoever actually held #1 during that time. Bob is #1 for 18 of the round's 20 hours; Dave takes
/// #1 in the last hour and is crowned King with 19 hours of reign.
contract UnknownReignKingProofTest is Test {
    uint256 internal constant GENESIS = 1_791_835_200;
    uint160 internal constant PRICE_ONE = 79228162514264337593543950336;

    IPoolManager internal manager;
    PoolSwapTest internal router;
    MockERC20 internal gameToken;
    SherwoodV2 internal game;
    PoolKey internal gameKey;

    receive() external payable {}

    function setUp() public {
        vm.warp(GENESIS + 1);
        address owner = makeAddr("owner");
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        PoolModifyLiquidityTest lr = new PoolModifyLiquidityTest(manager);
        gameToken = new MockERC20("Game", "GAME", 18);
        MockERC20 hostToken = new MockERC20("Host", "HOST", 18);
        address hookAddress = address(uint160(0xA11D0000) | uint160(0x20CC));
        deployCodeTo(
            "SherwoodV2.sol:SherwoodV2",
            abi.encode(
                manager,
                Currency.wrap(address(gameToken)),
                Currency.wrap(address(hostToken)),
                uint256(100_000e18),
                IDiceEntropy(address(new ProofNoDice())),
                makeAddr("provider"),
                owner,
                GENESIS
            ),
            hookAddress
        );
        game = SherwoodV2(payable(hookAddress));
        gameKey = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(gameToken)), 9000, 180, IHooks(hookAddress));
        vm.prank(owner);
        manager.initialize(gameKey, PRICE_ONE);
        gameToken.mint(address(this), 1e30);
        gameToken.approve(address(lr), type(uint256).max);
        vm.deal(address(this), 50_000 ether);
        lr.modifyLiquidity{value: 25_000 ether}(
            gameKey, ModifyLiquidityParams(-59400, 59400, 10_000e18, bytes32(0)), ""
        );
    }

    function _buy(address who, uint256 amount) internal {
        vm.deal(who, who.balance + amount);
        vm.prank(who, who);
        router.swap{value: amount}(
            gameKey,
            SwapParams(true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            abi.encode(uint256(0))
        );
    }

    function _sellAll(address who) internal {
        uint256 amount = gameToken.balanceOf(who);
        vm.startPrank(who, who);
        gameToken.approve(address(router), type(uint256).max);
        router.swap(
            gameKey,
            SwapParams(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        vm.stopPrank();
    }

    function test_kingOfTheHillIsTheLongestAtFirstPlaceNotTheFinalLeader() public {
        address alice = makeAddr("alice");
        address bob = makeAddr("bob");
        address dave = makeAddr("dave");
        _buy(alice, 0.1 ether); // 100 points, #1 from GENESIS + 1
        _buy(bob, 0.09 ether); // 90 points
        for (uint256 i; i < 1499; ++i) {
            _buy(address(uint160(0x100000 + i)), 0.001 ether); // 1 point each: 1,501 players
        }
        vm.warp(GENESIS + 1 hours);
        _sellAll(alice); // alice wiped: bob (90) is #1 from now, but the cache is stale and unknown
        assertEq(game.reignHolder(0), address(1));
        vm.warp(GENESIS + 19 hours);
        _buy(dave, 0.1 ether); // 100 points: dave is #1 for the last hour only
        assertEq(game.points(0, dave), 100);
        assertEq(game.points(0, bob), 90);

        vm.warp(game.roundEnd(0) + game.SETTLE_DELAY());
        while (!game.settle(0, 200)) {}
        (, address[3] memory top,,,, address king, uint256 kingReign,,) = game.result(0);
        assertEq(top[0], dave, "dave is #1 at the end");
        assertEq(top[1], bob);
        assertEq(king, bob, "bob held #1 for 18 hours, dave for 1: bob must be King; dave is crowned instead");
        assertLe(kingReign, 18 hours);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {SherwoodV2, IDiceEntropy} from "src/SherwoodV2.sol";

contract ProofNoDice {
    function getFeeV2(address, uint32) external pure returns (uint128) {
        return 25_000_000_000_000;
    }
}

/// On a board of more than MAX_LEADER_SCAN players, every second after the cached leader is first
/// debited is parked on the UNKNOWN_REIGN marker and handed to the round's final #1 at settlement,
/// whoever actually held #1 during that time. Bob is #1 for 18 of the round's 20 hours; Dave takes
/// #1 in the last hour and is crowned King with 19 hours of reign.
contract UnknownReignKingProofTest is Test {
    uint256 internal constant GENESIS = 1_791_835_200;
    uint160 internal constant PRICE_ONE = 79228162514264337593543950336;

    IPoolManager internal manager;
    PoolSwapTest internal router;
    MockERC20 internal gameToken;
    SherwoodV2 internal game;
    PoolKey internal gameKey;

    receive() external payable {}

    function setUp() public {
        vm.warp(GENESIS + 1);
        address owner = makeAddr("owner");
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        PoolModifyLiquidityTest lr = new PoolModifyLiquidityTest(manager);
        gameToken = new MockERC20("Game", "GAME", 18);
        MockERC20 hostToken = new MockERC20("Host", "HOST", 18);
        address hookAddress = address(uint160(0xA11D0000) | uint160(0x20CC));
        deployCodeTo(
            "SherwoodV2.sol:SherwoodV2",
            abi.encode(
                manager,
                Currency.wrap(address(gameToken)),
                Currency.wrap(address(hostToken)),
                uint256(100_000e18),
                IDiceEntropy(address(new ProofNoDice())),
                makeAddr("provider"),
                owner,
                GENESIS
            ),
            hookAddress
        );
        game = SherwoodV2(payable(hookAddress));
        gameKey = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(gameToken)), 9000, 180, IHooks(hookAddress));
        vm.prank(owner);
        manager.initialize(gameKey, PRICE_ONE);
        gameToken.mint(address(this), 1e30);
        gameToken.approve(address(lr), type(uint256).max);
        vm.deal(address(this), 50_000 ether);
        lr.modifyLiquidity{value: 25_000 ether}(
            gameKey, ModifyLiquidityParams(-59400, 59400, 10_000e18, bytes32(0)), ""
        );
    }

    function _buy(address who, uint256 amount) internal {
        vm.deal(who, who.balance + amount);
        vm.prank(who, who);
        router.swap{value: amount}(
            gameKey,
            SwapParams(true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            abi.encode(uint256(0))
        );
    }

    function _sellAll(address who) internal {
        uint256 amount = gameToken.balanceOf(who);
        vm.startPrank(who, who);
        gameToken.approve(address(router), type(uint256).max);
        router.swap(
            gameKey,
            SwapParams(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        vm.stopPrank();
    }

    function test_kingOfTheHillIsTheLongestAtFirstPlaceNotTheFinalLeader() public {
        address alice = makeAddr("alice");
        address bob = makeAddr("bob");
        address dave = makeAddr("dave");
        _buy(alice, 0.1 ether); // 100 points, #1 from GENESIS + 1
        _buy(bob, 0.09 ether); // 90 points
        for (uint256 i; i < 1499; ++i) {
            _buy(address(uint160(0x100000 + i)), 0.001 ether); // 1 point each: 1,501 players
        }
        vm.warp(GENESIS + 1 hours);
        _sellAll(alice); // alice wiped: bob (90) is #1 from now, but the cache is stale and unknown
        assertEq(game.reignHolder(0), address(1));
        vm.warp(GENESIS + 19 hours);
        _buy(dave, 0.1 ether); // 100 points: dave is #1 for the last hour only
        assertEq(game.points(0, dave), 100);
        assertEq(game.points(0, bob), 90);

        vm.warp(game.roundEnd(0) + game.SETTLE_DELAY());
        while (!game.settle(0, 200)) {}
        (, address[3] memory top,,,, address king, uint256 kingReign,,) = game.result(0);
        assertEq(top[0], dave, "dave is #1 at the end");
        assertEq(top[1], bob);
        assertEq(king, bob, "bob held #1 for 18 hours, dave for 1: bob must be King; dave is crowned instead");
        assertLe(kingReign, 18 hours);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {SherwoodV2, IDiceEntropy} from "src/SherwoodV2.sol";

/// Minimal Dice: records requests and reveals them with the consumer's gas limit, like the provider.
contract ProofDice {
    struct Request {
        address consumer;
        address provider;
        uint32 gasLimit;
    }

    uint128 public constant FEE = 25_000_000_000_000;
    uint64 public next = 1;
    mapping(uint64 => Request) public requests;

    function getFeeV2(address, uint32) external pure returns (uint128) {
        return FEE;
    }

    function requestV2(address provider, bytes32, uint32 gasLimit) external payable returns (uint64 seq) {
        require(msg.value == FEE, "fee");
        seq = next++;
        requests[seq] = Request(msg.sender, provider, gasLimit);
    }

    function reveal(uint64 seq, bytes32 random) external returns (bool ok) {
        Request memory r = requests[seq];
        (ok,) = r.consumer.call{gas: r.gasLimit}(abi.encodeCall(SherwoodV2._entropyCallback, (seq, r.provider, random)));
    }

    function refundRequest(address, uint64) external {}
}

/// Finding: when the round ends while #1 is "unknown" (a rescan still to come), `settle` drops the whole
/// final unknown spell. The spell restarts at every point change, so after its start nobody's points
/// changed and the round's final #1 (top[0], which settle itself computes) held #1 for all of it. Here bob
/// held #1 for the last 19 hours of a 13-player round and gets no reign at all; alice, #1 for one hour,
/// is crowned King and takes the 8% King share.
contract Proof_FinalUnknownSpellDropped is Test {
    uint256 internal constant GENESIS = 1_791_835_200;
    uint160 internal constant PRICE_ONE = 79228162514264337593543950336;

    IPoolManager internal manager;
    PoolSwapTest internal router;
    PoolModifyLiquidityTest internal liquidityRouter;
    MockERC20 internal token;
    MockERC20 internal host;
    ProofDice internal dice;
    SherwoodV2 internal game;
    PoolKey internal key;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");

    receive() external payable {}

    function setUp() public {
        vm.warp(GENESIS + 1);
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        liquidityRouter = new PoolModifyLiquidityTest(manager);
        token = new MockERC20("Game", "GAME", 18);
        host = new MockERC20("Host", "HOST", 18);
        dice = new ProofDice();
        address hookAddress = address(uint160(0xB00F0000) | uint160(0x20CC));
        deployCodeTo(
            "SherwoodV2.sol:SherwoodV2",
            abi.encode(
                manager,
                Currency.wrap(address(token)),
                Currency.wrap(address(host)),
                uint256(100_000e18),
                IDiceEntropy(address(dice)),
                makeAddr("provider"),
                owner,
                GENESIS
            ),
            hookAddress
        );
        game = SherwoodV2(payable(hookAddress));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 9000, 180, IHooks(hookAddress));
        vm.prank(owner);
        manager.initialize(key, PRICE_ONE);
        token.mint(address(this), 1e30);
        token.approve(address(liquidityRouter), type(uint256).max);
        vm.deal(address(this), 50_000 ether);
        liquidityRouter.modifyLiquidity{value: 25_000 ether}(
            key, ModifyLiquidityParams(-59400, 59400, 10_000e18, bytes32(0)), ""
        );
    }

    function _buy(address who, uint256 amount, SherwoodV2.Move move) internal {
        vm.deal(who, who.balance + amount);
        vm.prank(who, who);
        router.swap{value: amount}(
            key,
            SwapParams(true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            abi.encode(uint256(move))
        );
    }

    function test_finalUnknownSpellMustCountForTheFinalLeader() public {
        uint256 t0 = GENESIS + 1;
        _buy(alice, 0.05 ether, SherwoodV2.Move.BUY); // 50 points, #1 from t0
        for (uint256 i; i < 11; ++i) {
            _buy(address(uint160(0x300000 + i)), 0.001 ether, SherwoodV2.Move.BUY); // 1 point each
        }
        _buy(bob, 0.045 ether, SherwoodV2.Move.BUY); // 45 points; 13 players, more than MAX_CALLBACK_SCAN
        assertEq(game.playerCount(0), 13);
        assertEq(game.reignHolder(0), alice);

        // One hour in, #1 flips and loses: alice 40, bob (the previous player) 55. The callback cannot
        // rescan 13 players under Dice's gas limit, so #1 is unknown from t1 on.
        uint256 t1 = t0 + 1 hours;
        vm.warp(t1);
        _buy(alice, 0.01 ether, SherwoodV2.Move.FLIP);
        assertTrue(dice.reveal(1, bytes32(uint256(1))), "the reveal fits the Dice gas limit");
        assertEq(game.points(0, alice), 40);
        assertEq(game.points(0, bob), 55);
        assertEq(game.reignHolder(0), address(1));
        assertEq(game.reignOf(0, alice), 1 hours);

        // Nothing else happens this round. Settlement ranks the board itself: bob is #1, and no points
        // changed after t1, so bob held #1 for the 19 hours from t1 to the end of the round.
        vm.warp(game.roundEnd(0) + game.SETTLE_DELAY());
        assertTrue(game.settle(0, 100));
        (, address[3] memory top,,,, address king, uint256 kingReign,,) = game.result(0);
        assertEq(top[0], bob);
        assertEq(king, bob, "bob, #1 for 19 of the 20 hours, must be King of the Hill");
        assertEq(kingReign, game.roundEnd(0) - t1, "bob's reign is the whole final spell");
        assertEq(game.reignOf(0, bob), game.roundEnd(0) - t1);
        assertEq(game.reignOf(0, alice), 1 hours);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {SherwoodV2, IDiceEntropy} from "src/SherwoodV2.sol";

/// Minimal Dice: records requests and reveals them with the consumer's gas limit, like the provider.
contract ProofDice {
    struct Request {
        address consumer;
        address provider;
        uint32 gasLimit;
    }

    uint128 public constant FEE = 25_000_000_000_000;
    uint64 public next = 1;
    mapping(uint64 => Request) public requests;

    function getFeeV2(address, uint32) external pure returns (uint128) {
        return FEE;
    }

    function requestV2(address provider, bytes32, uint32 gasLimit) external payable returns (uint64 seq) {
        require(msg.value == FEE, "fee");
        seq = next++;
        requests[seq] = Request(msg.sender, provider, gasLimit);
    }

    function reveal(uint64 seq, bytes32 random) external returns (bool ok) {
        Request memory r = requests[seq];
        (ok,) = r.consumer.call{gas: r.gasLimit}(abi.encodeCall(SherwoodV2._entropyCallback, (seq, r.provider, random)));
    }

    function refundRequest(address, uint64) external {}
}

/// Finding: when the round ends while #1 is "unknown" (a rescan still to come), `settle` drops the whole
/// final unknown spell. The spell restarts at every point change, so after its start nobody's points
/// changed and the round's final #1 (top[0], which settle itself computes) held #1 for all of it. Here bob
/// held #1 for the last 19 hours of a 13-player round and gets no reign at all; alice, #1 for one hour,
/// is crowned King and takes the 8% King share.
contract Proof_FinalUnknownSpellDropped is Test {
    uint256 internal constant GENESIS = 1_791_835_200;
    uint160 internal constant PRICE_ONE = 79228162514264337593543950336;

    IPoolManager internal manager;
    PoolSwapTest internal router;
    PoolModifyLiquidityTest internal liquidityRouter;
    MockERC20 internal token;
    MockERC20 internal host;
    ProofDice internal dice;
    SherwoodV2 internal game;
    PoolKey internal key;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");

    receive() external payable {}

    function setUp() public {
        vm.warp(GENESIS + 1);
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        liquidityRouter = new PoolModifyLiquidityTest(manager);
        token = new MockERC20("Game", "GAME", 18);
        host = new MockERC20("Host", "HOST", 18);
        dice = new ProofDice();
        address hookAddress = address(uint160(0xB00F0000) | uint160(0x20CC));
        deployCodeTo(
            "SherwoodV2.sol:SherwoodV2",
            abi.encode(
                manager,
                Currency.wrap(address(token)),
                Currency.wrap(address(host)),
                uint256(100_000e18),
                IDiceEntropy(address(dice)),
                makeAddr("provider"),
                owner,
                GENESIS
            ),
            hookAddress
        );
        game = SherwoodV2(payable(hookAddress));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 9000, 180, IHooks(hookAddress));
        vm.prank(owner);
        manager.initialize(key, PRICE_ONE);
        token.mint(address(this), 1e30);
        token.approve(address(liquidityRouter), type(uint256).max);
        vm.deal(address(this), 50_000 ether);
        liquidityRouter.modifyLiquidity{value: 25_000 ether}(
            key, ModifyLiquidityParams(-59400, 59400, 10_000e18, bytes32(0)), ""
        );
    }

    function _buy(address who, uint256 amount, SherwoodV2.Move move) internal {
        vm.deal(who, who.balance + amount);
        vm.prank(who, who);
        router.swap{value: amount}(
            key,
            SwapParams(true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            abi.encode(uint256(move))
        );
    }

    function test_finalUnknownSpellMustCountForTheFinalLeader() public {
        uint256 t0 = GENESIS + 1;
        _buy(alice, 0.05 ether, SherwoodV2.Move.BUY); // 50 points, #1 from t0
        for (uint256 i; i < 11; ++i) {
            _buy(address(uint160(0x300000 + i)), 0.001 ether, SherwoodV2.Move.BUY); // 1 point each
        }
        _buy(bob, 0.045 ether, SherwoodV2.Move.BUY); // 45 points; 13 players, more than MAX_CALLBACK_SCAN
        assertEq(game.playerCount(0), 13);
        assertEq(game.reignHolder(0), alice);

        // One hour in, #1 flips and loses: alice 40, bob (the previous player) 55. The callback cannot
        // rescan 13 players under Dice's gas limit, so #1 is unknown from t1 on.
        uint256 t1 = t0 + 1 hours;
        vm.warp(t1);
        _buy(alice, 0.01 ether, SherwoodV2.Move.FLIP);
        assertTrue(dice.reveal(1, bytes32(uint256(1))), "the reveal fits the Dice gas limit");
        assertEq(game.points(0, alice), 40);
        assertEq(game.points(0, bob), 55);
        assertEq(game.reignHolder(0), address(1));
        assertEq(game.reignOf(0, alice), 1 hours);

        // Nothing else happens this round. Settlement ranks the board itself: bob is #1, and no points
        // changed after t1, so bob held #1 for the 19 hours from t1 to the end of the round.
        vm.warp(game.roundEnd(0) + game.SETTLE_DELAY());
        assertTrue(game.settle(0, 100));
        (, address[3] memory top,,,, address king, uint256 kingReign,,) = game.result(0);
        assertEq(top[0], bob);
        assertEq(king, bob, "bob, #1 for 19 of the 20 hours, must be King of the Hill");
        assertEq(kingReign, game.roundEnd(0) - t1, "bob's reign is the whole final spell");
        assertEq(game.reignOf(0, bob), game.roundEnd(0) - t1);
        assertEq(game.reignOf(0, alice), 1 hours);
    }
}