// 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 {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 {HamsterNap3D} from "src/HamsterNap3D.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev A core whose rounds all have zero work. `state()` can be switched to revert (an upgraded
/// proxy whose CoreState layout changed, or a broken getter) while `roundPage` keeps answering.
contract ZeroWorkCore is ISqueekCore {
    uint64 public frontier;
    bool public stateBroken;

    function setFrontier(uint64 f) external {
        frontier = f;
    }

    function breakState() external {
        stateBroken = true;
    }

    function state() external view returns (CoreState memory result) {
        require(!stateBroken, "state unreadable");
        result.settledThroughRound = frontier;
    }

    function configuration() external pure returns (CoreConfiguration memory result) {
        result.genesisTimestamp = 1793735400;
        result.roundDuration = 600;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory result)
    {
        if (afterRound > throughRound || throughRound > frontier || maxRecords > 16) revert InvalidRoundPageBounds();
        result.certifiedThroughRound = throughRound;
        result.rounds = new RoundCheckpoint[](0);
    }
}

/// @dev Minimal router: exact-input buys and full-range liquidity, settled from its own balances.
contract Router is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function buy(PoolKey memory key, uint256 ethIn) external {
        manager.unlock(abi.encode(true, key, int256(0), -int256(ethIn)));
    }

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

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool isSwap, PoolKey memory key, int256 liquidity, int256 amount) =
            abi.decode(data, (bool, PoolKey, int256, int256));
        BalanceDelta delta;
        if (isSwap) {
            delta = manager.swap(key, SwapParams(true, amount, TickMath.MIN_SQRT_PRICE + 1), "");
        } else {
            (delta,) = manager.modifyLiquidity(
                key,
                ModifyLiquidityParams(TickMath.minUsableTick(60), TickMath.maxUsableTick(60), liquidity, bytes32(0)),
                ""
            );
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return "";
    }

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

    receive() external payable {}
}

/// @notice Once the core's `state()` is unreadable while its `roundPage` still answers and more than
/// 8 pages (128 rounds) the hook already saw certified are unscanned, no call can ever pay the pot:
/// `settleNaps` reverts `CoreUnreadable` (it needs `state()`), and `failsafe` scans 8 pages, finds
/// readable rounds left, reverts `NapsUnsettled` and discards its own progress. After `finalizeCore`
/// there is no recovery. Fails on the current code; passes once either path makes progress.
contract StateUnreadableBacklogLockTest is Test {
    uint64 constant GENESIS = 1793735400;
    uint64 constant ROUND = 600;
    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;

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

    PoolManager manager;
    NapToken token;
    HamsterNap3D hook;
    ZeroWorkCore core;
    Router router;
    PoolKey key;

    function roundEnd(uint64 r) internal pure returns (uint256) {
        return GENESIS + uint256(r) * ROUND;
    }

    function setUp() public {
        vm.warp(GENESIS + 649 * ROUND + 17); // round 650
        manager = new PoolManager(address(this));
        token = new NapToken();
        bytes memory creation = abi.encodePacked(type(HamsterNap3D).creationCode, abi.encode(manager, factory, owner));
        bytes32 initHash = keccak256(creation);
        for (uint256 i = 0; i < 500_000; i++) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initHash)))));
            if ((uint160(predicted) & Hooks.ALL_HOOK_MASK) != FLAGS) continue;
            hook = new HamsterNap3D{salt: bytes32(i)}(manager, factory, owner);
            break;
        }
        require(address(hook) != address(0), "no salt");
        core = ZeroWorkCore(address(hook.core()));
        vm.etch(address(core), address(new ZeroWorkCore()).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 Router(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 test_potStaysPayableWhenStateBreaksWithLongReadableBacklog() public {
        vm.prank(alice, alice);
        router.buy(key, 1 ether); // game starts: scanRound = 650, alice is the latest buyer
        // The core certifies 200 zero-work rounds (650..849) and a buy records that sighting.
        core.setFrontier(849);
        vm.warp(roundEnd(849));
        vm.prank(bob, bob);
        router.buy(key, 0.5 ether);
        assertEq(hook.lastSeenFrontier(), 849);
        assertEq(hook.scanRound(), 650);
        // Then state() stops being readable while roundPage still answers.
        core.breakState();
        // Pot through the sighting: 0.02 + 0.01 ETH, owed to the certified naps' winners.
        assertEq(hook.pot(), 0.03 ether);

        // Every public path, with a generous number of attempts, over the next months.
        for (uint256 i = 0; i < 20; i++) {
            try hook.settleNaps(100) {} catch {}
            vm.warp(block.timestamp + 8 days);
            try hook.failsafe() {} catch {}
        }
        assertGt(hook.cumulativePaid(), 0, "the pot can never be paid: settleNaps and failsafe both revert");
    }
}

// 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 {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 {HamsterNap3D} from "src/HamsterNap3D.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev A core whose rounds all have zero work. `state()` can be switched to revert (an upgraded
/// proxy whose CoreState layout changed, or a broken getter) while `roundPage` keeps answering.
contract ZeroWorkCore is ISqueekCore {
    uint64 public frontier;
    bool public stateBroken;

    function setFrontier(uint64 f) external {
        frontier = f;
    }

    function breakState() external {
        stateBroken = true;
    }

    function state() external view returns (CoreState memory result) {
        require(!stateBroken, "state unreadable");
        result.settledThroughRound = frontier;
    }

    function configuration() external pure returns (CoreConfiguration memory result) {
        result.genesisTimestamp = 1793735400;
        result.roundDuration = 600;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory result)
    {
        if (afterRound > throughRound || throughRound > frontier || maxRecords > 16) revert InvalidRoundPageBounds();
        result.certifiedThroughRound = throughRound;
        result.rounds = new RoundCheckpoint[](0);
    }
}

/// @dev Minimal router: exact-input buys and full-range liquidity, settled from its own balances.
contract Router is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function buy(PoolKey memory key, uint256 ethIn) external {
        manager.unlock(abi.encode(true, key, int256(0), -int256(ethIn)));
    }

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

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool isSwap, PoolKey memory key, int256 liquidity, int256 amount) =
            abi.decode(data, (bool, PoolKey, int256, int256));
        BalanceDelta delta;
        if (isSwap) {
            delta = manager.swap(key, SwapParams(true, amount, TickMath.MIN_SQRT_PRICE + 1), "");
        } else {
            (delta,) = manager.modifyLiquidity(
                key,
                ModifyLiquidityParams(TickMath.minUsableTick(60), TickMath.maxUsableTick(60), liquidity, bytes32(0)),
                ""
            );
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return "";
    }

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

    receive() external payable {}
}

/// @notice Once the core's `state()` is unreadable while its `roundPage` still answers and more than
/// 8 pages (128 rounds) the hook already saw certified are unscanned, no call can ever pay the pot:
/// `settleNaps` reverts `CoreUnreadable` (it needs `state()`), and `failsafe` scans 8 pages, finds
/// readable rounds left, reverts `NapsUnsettled` and discards its own progress. After `finalizeCore`
/// there is no recovery. Fails on the current code; passes once either path makes progress.
contract StateUnreadableBacklogLockTest is Test {
    uint64 constant GENESIS = 1793735400;
    uint64 constant ROUND = 600;
    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;

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

    PoolManager manager;
    NapToken token;
    HamsterNap3D hook;
    ZeroWorkCore core;
    Router router;
    PoolKey key;

    function roundEnd(uint64 r) internal pure returns (uint256) {
        return GENESIS + uint256(r) * ROUND;
    }

    function setUp() public {
        vm.warp(GENESIS + 649 * ROUND + 17); // round 650
        manager = new PoolManager(address(this));
        token = new NapToken();
        bytes memory creation = abi.encodePacked(type(HamsterNap3D).creationCode, abi.encode(manager, factory, owner));
        bytes32 initHash = keccak256(creation);
        for (uint256 i = 0; i < 500_000; i++) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initHash)))));
            if ((uint160(predicted) & Hooks.ALL_HOOK_MASK) != FLAGS) continue;
            hook = new HamsterNap3D{salt: bytes32(i)}(manager, factory, owner);
            break;
        }
        require(address(hook) != address(0), "no salt");
        core = ZeroWorkCore(address(hook.core()));
        vm.etch(address(core), address(new ZeroWorkCore()).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 Router(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 test_potStaysPayableWhenStateBreaksWithLongReadableBacklog() public {
        vm.prank(alice, alice);
        router.buy(key, 1 ether); // game starts: scanRound = 650, alice is the latest buyer
        // The core certifies 200 zero-work rounds (650..849) and a buy records that sighting.
        core.setFrontier(849);
        vm.warp(roundEnd(849));
        vm.prank(bob, bob);
        router.buy(key, 0.5 ether);
        assertEq(hook.lastSeenFrontier(), 849);
        assertEq(hook.scanRound(), 650);
        // Then state() stops being readable while roundPage still answers.
        core.breakState();
        // Pot through the sighting: 0.02 + 0.01 ETH, owed to the certified naps' winners.
        assertEq(hook.pot(), 0.03 ether);

        // Every public path, with a generous number of attempts, over the next months.
        for (uint256 i = 0; i < 20; i++) {
            try hook.settleNaps(100) {} catch {}
            vm.warp(block.timestamp + 8 days);
            try hook.failsafe() {} catch {}
        }
        assertGt(hook.cumulativePaid(), 0, "the pot can never be paid: settleNaps and failsafe both revert");
    }
}

// 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 {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 {HamsterNap3D} from "src/HamsterNap3D.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev A core whose rounds all have zero work. `state()` can be switched to revert (an upgraded
/// proxy whose CoreState layout changed, or a broken getter) while `roundPage` keeps answering.
contract ZeroWorkCore is ISqueekCore {
    uint64 public frontier;
    bool public stateBroken;

    function setFrontier(uint64 f) external {
        frontier = f;
    }

    function breakState() external {
        stateBroken = true;
    }

    bool public pageBroken;

    function breakPage() external {
        pageBroken = true;
    }

    function state() external view returns (CoreState memory result) {
        require(!stateBroken, "state unreadable");
        result.settledThroughRound = frontier;
    }

    function configuration() external pure returns (CoreConfiguration memory result) {
        result.genesisTimestamp = 1793735400;
        result.roundDuration = 600;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory result)
    {
        require(!pageBroken, "page unreadable");
        if (afterRound > throughRound || throughRound > frontier || maxRecords > 16) revert InvalidRoundPageBounds();
        result.certifiedThroughRound = throughRound;
        if (afterRound < 650 && throughRound >= 650) {
            result.rounds = new RoundCheckpoint[](1);
            result.rounds[0].roundId = 650; // round 650 had work: a nap starts at 651
        } else {
            result.rounds = new RoundCheckpoint[](0);
        }
    }
}

/// @dev Minimal router: exact-input buys and full-range liquidity, settled from its own balances.
contract Router is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function buy(PoolKey memory key, uint256 ethIn) external {
        manager.unlock(abi.encode(true, key, int256(0), -int256(ethIn)));
    }

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

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool isSwap, PoolKey memory key, int256 liquidity, int256 amount) =
            abi.decode(data, (bool, PoolKey, int256, int256));
        BalanceDelta delta;
        if (isSwap) {
            delta = manager.swap(key, SwapParams(true, amount, TickMath.MIN_SQRT_PRICE + 1), "");
        } else {
            (delta,) = manager.modifyLiquidity(
                key,
                ModifyLiquidityParams(TickMath.minUsableTick(60), TickMath.maxUsableTick(60), liquidity, bytes32(0)),
                ""
            );
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return "";
    }

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

    receive() external payable {}
}

/// @notice Pages unreadable while the frontier advances.
contract AdvancingFrontierUnreadablePagesTest is Test {
    uint64 constant GENESIS = 1793735400;
    uint64 constant ROUND = 600;
    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;

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

    PoolManager manager;
    NapToken token;
    HamsterNap3D hook;
    ZeroWorkCore core;
    Router router;
    PoolKey key;

    function roundEnd(uint64 r) internal pure returns (uint256) {
        return GENESIS + uint256(r) * ROUND;
    }

    function setUp() public {
        vm.warp(GENESIS + 649 * ROUND + 17); // round 650
        manager = new PoolManager(address(this));
        token = new NapToken();
        bytes memory creation = abi.encodePacked(type(HamsterNap3D).creationCode, abi.encode(manager, factory, owner));
        bytes32 initHash = keccak256(creation);
        for (uint256 i = 0; i < 500_000; i++) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initHash)))));
            if ((uint160(predicted) & Hooks.ALL_HOOK_MASK) != FLAGS) continue;
            hook = new HamsterNap3D{salt: bytes32(i)}(manager, factory, owner);
            break;
        }
        require(address(hook) != address(0), "no salt");
        core = ZeroWorkCore(address(hook.core()));
        vm.etch(address(core), address(new ZeroWorkCore()).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 Router(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);
    }

    /// Frontier keeps advancing, roundPage is unreadable: settleNaps reverts CoreUnreadable and
    /// the failsafe never opens, so after finalizeCore the pot is locked for good.
    function test_potPayableWhenPagesBreakButFrontierAdvances() public {
        vm.prank(alice, alice);
        router.buy(key, 1 ether); // pot 0.02, alice latest buyer, scanRound 650
        vm.prank(owner);
        hook.finalizeCore();
        core.breakPage();
        for (uint256 d = 0; d < 60; d++) {
            vm.warp(block.timestamp + 1 days);
            core.setFrontier(hook.currentRound() - 1);
            try hook.settleNaps(8) {} catch {}
            try hook.failsafe() {} catch {}
        }
        assertGt(hook.cumulativePaid(), 0, "pot frozen: settleNaps reverts and failsafe never opens");
    }
}

// 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 {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 {HamsterNap3D} from "src/HamsterNap3D.sol";
import {NapToken} from "src/NapToken.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev A core whose rounds all have zero work. `state()` can be switched to revert (an upgraded
/// proxy whose CoreState layout changed, or a broken getter) while `roundPage` keeps answering.
contract ZeroWorkCore is ISqueekCore {
    uint64 public frontier;
    bool public stateBroken;

    function setFrontier(uint64 f) external {
        frontier = f;
    }

    function breakState() external {
        stateBroken = true;
    }

    bool public pageBroken;

    function breakPage() external {
        pageBroken = true;
    }

    function state() external view returns (CoreState memory result) {
        require(!stateBroken, "state unreadable");
        result.settledThroughRound = frontier;
    }

    function configuration() external pure returns (CoreConfiguration memory result) {
        result.genesisTimestamp = 1793735400;
        result.roundDuration = 600;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory result)
    {
        require(!pageBroken, "page unreadable");
        if (afterRound > throughRound || throughRound > frontier || maxRecords > 16) revert InvalidRoundPageBounds();
        result.certifiedThroughRound = throughRound;
        result.rounds = new RoundCheckpoint[](0);
    }
}

/// @dev Minimal router: exact-input buys and full-range liquidity, settled from its own balances.
contract Router is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function buy(PoolKey memory key, uint256 ethIn) external {
        manager.unlock(abi.encode(true, key, int256(0), -int256(ethIn)));
    }

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

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool isSwap, PoolKey memory key, int256 liquidity, int256 amount) =
            abi.decode(data, (bool, PoolKey, int256, int256));
        BalanceDelta delta;
        if (isSwap) {
            delta = manager.swap(key, SwapParams(true, amount, TickMath.MIN_SQRT_PRICE + 1), "");
        } else {
            (delta,) = manager.modifyLiquidity(
                key,
                ModifyLiquidityParams(TickMath.minUsableTick(60), TickMath.maxUsableTick(60), liquidity, bytes32(0)),
                ""
            );
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return "";
    }

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

    receive() external payable {}
}

/// @notice Future frontier.
contract FutureFrontierTest is Test {
    uint64 constant GENESIS = 1793735400;
    uint64 constant ROUND = 600;
    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;

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

    PoolManager manager;
    NapToken token;
    HamsterNap3D hook;
    ZeroWorkCore core;
    Router router;
    PoolKey key;

    function roundEnd(uint64 r) internal pure returns (uint256) {
        return GENESIS + uint256(r) * ROUND;
    }

    function setUp() public {
        vm.warp(GENESIS + 649 * ROUND + 17); // round 650
        manager = new PoolManager(address(this));
        token = new NapToken();
        bytes memory creation = abi.encodePacked(type(HamsterNap3D).creationCode, abi.encode(manager, factory, owner));
        bytes32 initHash = keccak256(creation);
        for (uint256 i = 0; i < 500_000; i++) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initHash)))));
            if ((uint160(predicted) & Hooks.ALL_HOOK_MASK) != FLAGS) continue;
            hook = new HamsterNap3D{salt: bytes32(i)}(manager, factory, owner);
            break;
        }
        require(address(hook) != address(0), "no salt");
        core = ZeroWorkCore(address(hook.core()));
        vm.etch(address(core), address(new ZeroWorkCore()).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 Router(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);
    }

    /// The core reports a frontier far beyond the running round once, then stops (pages revert).
    /// The failsafe should open 7 days after the stall; it is pushed ~694 days out.
    function test_failsafeOpensAfterStallWithFutureFrontier() public {
        vm.prank(alice, alice);
        router.buy(key, 1 ether);
        vm.prank(owner);
        hook.finalizeCore();
        core.breakPage();
        core.setFrontier(650 + 100_000);
        vm.prank(bob, bob);
        router.buy(key, 0.0001 ether); // records the bogus frontier
        vm.warp(block.timestamp + 8 days);
        try hook.failsafe() {} catch {}
        assertGt(hook.cumulativePaid(), 0, "failsafe postponed by a future frontier");
    }
}