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

import {Test} from "forge-std/Test.sol";
import {MockSQK} from "src/MockSQK.sol";
import {PremiumModel} from "src/PremiumModel.sol";
import {CoverPool} from "src/CoverPool.sol";
import {CoreReader} from "src/CoreReader.sol";
import {PolicyBook} from "src/PolicyBook.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal V3-shaped core: frontier 100, no active records, current round 101.
contract StubCore is ISqueekCore {
    uint64 public immutable genesis;
    uint64 public frontier = 100;

    constructor(uint64 genesis_) {
        genesis = genesis_;
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function configuration() external view returns (CoreConfiguration memory c) {
        c.genesisTimestamp = genesis;
        c.roundDuration = 600;
        c.maxRoundsPerBatch = 16;
        c.initialWorkPerThousandBlocks = 10_875;
    }

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

    function roundPage(uint64, uint64 throughRound, uint256) external pure returns (RoundPage memory p) {
        p.certifiedThroughRound = throughRound;
        p.start = LedgerPosition(0, 0, 10_875);
        p.end = p.start;
        p.rounds = new RoundCheckpoint[](0);
    }
}

/// @notice openPolicy accepts a start round that the core can never certify, so the whole free
/// liquidity of the pool is reserved forever for one flat premium. A start-round lead cap makes
/// this call revert and the test pass.
contract FarFutureLockTest is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    address internal owner = makeAddr("owner");
    address internal lp = makeAddr("lp");
    address internal attacker = makeAddr("attacker");
    MockSQK internal token;
    PremiumModel internal model;
    CoverPool internal pool;
    CoreReader internal reader;
    PolicyBook internal book;

    function setUp() public {
        vm.chainId(11_155_111);
        vm.warp(GENESIS + 100 * 600);
        StubCore core = new StubCore(GENESIS);
        token = new MockSQK(owner);
        model = new PremiumModel(owner);
        pool = new CoverPool(owner, address(token));
        reader = new CoreReader(address(core));
        book = new PolicyBook(owner, address(token), address(model), address(pool), address(reader));
        vm.startPrank(owner);
        pool.setPolicyBook(address(book));
        model.setRate(144, 3000, 500, 1000);
        token.mint(lp, 1000 ether);
        token.mint(attacker, 1000 ether);
        vm.stopPrank();
        vm.startPrank(lp);
        token.approve(address(pool), 1000 ether);
        pool.deposit(1000 ether, 1);
        vm.stopPrank();
    }

    function test_startRoundBeyondAnyReachableRoundIsRejected() public {
        // Current round is 101 and the frontier is 100. This window ends at round 2^64-1,
        // which at 600 s per round is ~3.5e14 years away: the reservation can never be released.
        uint64 start = type(uint64).max - 143;
        vm.startPrank(attacker);
        token.approve(address(book), type(uint256).max);
        vm.expectRevert();
        book.openPolicy(start, 144, 3000, 1000 ether, type(uint256).max, block.timestamp);
        vm.stopPrank();
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockSQK} from "src/MockSQK.sol";
import {PremiumModel} from "src/PremiumModel.sol";
import {CoverPool} from "src/CoverPool.sol";
import {CoreReader} from "src/CoreReader.sol";
import {PolicyBook} from "src/PolicyBook.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal V3 core: no active records at all, so every certified round is zero-work.
contract EmptyCore is ISqueekCore {
    uint64 public genesis;
    uint64 public frontier;

    constructor(uint64 genesis_) {
        genesis = genesis_;
    }

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

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function configuration() external view returns (CoreConfiguration memory result) {
        result.genesisTimestamp = genesis;
        result.roundDuration = 600;
        result.maxRoundsPerBatch = 16;
    }

    function state() external view returns (CoreState memory result) {
        result.settledThroughRound = frontier;
        result.workPerThousandBlocks = 10_875;
    }

    function roundPage(uint64, uint64 throughRound, uint256) external pure returns (RoundPage memory result) {
        result.certifiedThroughRound = throughRound;
        result.start.workPerThousandBlocks = 10_875;
        result.end.workPerThousandBlocks = 10_875;
        result.rounds = new RoundCheckpoint[](0);
    }
}

contract LpExitBeforeSettleTest is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    uint64 internal constant START = 102;
    address internal owner = makeAddr("owner");
    address internal lpA = makeAddr("lpA");
    address internal lpB = makeAddr("lpB");
    address internal buyer = makeAddr("buyer");
    MockSQK internal token;
    PremiumModel internal model;
    CoverPool internal pool;
    CoreReader internal reader;
    PolicyBook internal book;
    EmptyCore internal core;

    function setUp() public {
        vm.chainId(11_155_111);
        vm.warp(GENESIS + 100 * 600);
        core = new EmptyCore(GENESIS);
        core.setFrontier(100);
        token = new MockSQK(owner);
        model = new PremiumModel(owner);
        pool = new CoverPool(owner, address(token));
        reader = new CoreReader(address(core));
        book = new PolicyBook(owner, address(token), address(model), address(pool), address(reader));
        vm.startPrank(owner);
        pool.setPolicyBook(address(book));
        model.setRate(6, 5000, 500, 1000);
        token.transfer(lpA, 1000 ether);
        token.transfer(lpB, 1000 ether);
        token.transfer(buyer, 1000 ether);
        vm.stopPrank();
        _deposit(lpA, 1000 ether);
        _deposit(lpB, 1000 ether);
    }

    /// Two equal LPs back one fully reserved policy. Once the window is certified (payout is
    /// certain) but before anyone calls settle, LP A redeems all shares at the pre-loss price.
    /// LP B then absorbs the entire 1000-token loss and LP A leaves with a profit.
    function test_lpCanExitAtPreLossPriceOnceLossIsCertain() public {
        (uint256 premium,) = book.quote(START, 6, 5000, 1000 ether);
        vm.startPrank(buyer);
        token.approve(address(book), premium);
        uint256 id = book.openPolicy(START, 6, 5000, 1000 ether, premium, block.timestamp);
        vm.stopPrank();
        assertEq(pool.reserved(), 1000 ether);

        // Window fully certified with zero work everywhere: settle(id) is guaranteed to pay 1000.
        core.setFrontier(START + 5);
        vm.warp(uint256(GENESIS) + uint256(START + 5) * 600);

        // LP A front-runs settlement and withdraws everything free capital allows.
        uint256 sharesA = pool.sharesOf(lpA);
        uint256 outA = pool.previewRedeem(sharesA);
        assertLe(outA, pool.freeAssets());
        vm.prank(lpA);
        pool.redeem(sharesA, outA);

        // Settlement pays the buyer in full, entirely out of what remains (LP B's capital).
        assertEq(book.settle(id), 1000 ether);
        uint256 outB = pool.previewRedeem(pool.sharesOf(lpB));

        // Expected: both LPs share the 1000 loss equally (each ends near 500 + premium/2).
        // Actual on this code: LP A leaves with 1000 + premium/2, LP B is left with ~premium/2.
        assertLe(outA, 1000 ether + premium / 2 - 400 ether, "LP A escaped the loss entirely");
        assertGe(outB, 400 ether, "LP B bore the whole loss");
    }

    function _deposit(address lp, uint256 amount) private {
        vm.startPrank(lp);
        token.approve(address(pool), amount);
        pool.deposit(amount, 1);
        vm.stopPrank();
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockSQK} from "src/MockSQK.sol";
import {PremiumModel} from "src/PremiumModel.sol";
import {CoverPool} from "src/CoverPool.sol";
import {CoreReader} from "src/CoreReader.sol";
import {PolicyBook} from "src/PolicyBook.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal V3 core fixture: sparse active records, settable frontier and batch limit.
contract EconCore is ISqueekCore {
    uint64 public genesis;
    uint64 public frontier;
    uint16 public maxRoundsPerBatch = 16;
    RoundCheckpoint[] private _records;

    constructor(uint64 genesis_) {
        genesis = genesis_;
    }

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

    function setMaxRoundsPerBatch(uint16 value) external {
        maxRoundsPerBatch = value;
    }

    function record(uint64 roundId, uint64 work) external {
        LedgerPosition memory last = _positionAt(type(uint64).max);
        _records.push(
            RoundCheckpoint(
                roundId,
                last.cumulativeWork + work,
                last.cumulativeBlockUnits + uint96(work) * 1e9,
                10_875,
                keccak256(abi.encode(roundId, work))
            )
        );
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function configuration() external view returns (CoreConfiguration memory result) {
        result.genesisTimestamp = genesis;
        result.roundDuration = 600;
        result.maxWorkPerRound = 10_000;
        result.maxRoundsPerBatch = maxRoundsPerBatch;
        result.initialWorkPerThousandBlocks = 10_875;
        result.targetBlocksPerActiveRound = 40;
        result.difficultySmoothingRounds = 30;
        result.blockUnitsPerBlock = 1e9;
    }

    function state() external view returns (CoreState memory result) {
        LedgerPosition memory position = _positionAt(frontier);
        result.settledThroughRound = frontier;
        result.cumulativeWork = position.cumulativeWork;
        result.cumulativeBlockUnits = position.cumulativeBlockUnits;
        result.workPerThousandBlocks = position.workPerThousandBlocks;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory result)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "core: bounds");
        require(maxRecords <= maxRoundsPerBatch, "core: batch");
        result.start = _positionAt(afterRound);
        result.certifiedThroughRound = throughRound;
        RoundCheckpoint[] memory records = new RoundCheckpoint[](maxRecords);
        uint256 count;
        for (uint256 i; i < _records.length; ++i) {
            RoundCheckpoint memory checkpoint = _records[i];
            if (checkpoint.roundId <= afterRound) continue;
            if (checkpoint.roundId > throughRound) break;
            if (count == maxRecords) {
                result.certifiedThroughRound = checkpoint.roundId - 1;
                break;
            }
            records[count++] = checkpoint;
        }
        assembly ("memory-safe") {
            mstore(records, count)
        }
        result.rounds = records;
        result.end = _positionAt(result.certifiedThroughRound);
    }

    function _positionAt(uint64 round) private view returns (LedgerPosition memory result) {
        result.workPerThousandBlocks = 10_875;
        for (uint256 i = _records.length; i != 0; --i) {
            RoundCheckpoint memory checkpoint = _records[i - 1];
            if (checkpoint.roundId <= round) {
                return LedgerPosition(
                    checkpoint.cumulativeWork, checkpoint.cumulativeBlockUnits, checkpoint.workPerThousandBlocks
                );
            }
        }
    }
}

abstract contract EconBase is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    uint64 internal constant START = 102;
    address internal owner = makeAddr("owner");
    address internal lp = makeAddr("lp");
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");
    MockSQK internal token;
    PremiumModel internal model;
    CoverPool internal pool;
    CoreReader internal reader;
    PolicyBook internal book;
    EconCore internal core;

    function setUp() public virtual {
        vm.chainId(11_155_111);
        vm.warp(GENESIS + 100 * 600);
        core = new EconCore(GENESIS);
        core.setFrontier(100);
        token = new MockSQK(owner);
        model = new PremiumModel(owner);
        pool = new CoverPool(owner, address(token));
        reader = new CoreReader(address(core));
        book = new PolicyBook(owner, address(token), address(model), address(pool), address(reader));
        vm.startPrank(owner);
        pool.setPolicyBook(address(book));
        uint16[4] memory durations = [uint16(6), 12, 24, 144];
        uint16[3] memory thresholds = [uint16(3000), 5000, 7000];
        for (uint256 i; i < 4; ++i) {
            for (uint256 j; j < 3; ++j) {
                model.setRate(durations[i], thresholds[j], 500, 1000);
            }
        }
        token.mint(lp, 100_000 ether);
        token.mint(alice, 100_000 ether);
        token.mint(bob, 100_000 ether);
        vm.stopPrank();
        _deposit(lp, 1000 ether);
    }

    function _deposit(address who, uint256 amount) internal returns (uint256 shares) {
        vm.startPrank(who);
        token.approve(address(pool), amount);
        shares = pool.deposit(amount, 1);
        vm.stopPrank();
    }

    function _open(address buyer, uint64 start, uint16 rounds, uint16 threshold, uint256 cover)
        internal
        returns (uint256 id, uint256 premium)
    {
        (premium,) = book.quote(start, rounds, threshold, cover);
        vm.startPrank(buyer);
        token.approve(address(book), premium);
        id = book.openPolicy(start, rounds, threshold, cover, premium, block.timestamp);
        vm.stopPrank();
    }

    function _certify(uint64 end) internal {
        core.setFrontier(end);
        uint256 endTime = uint256(GENESIS) + uint256(end) * 600;
        if (endTime > block.timestamp) vm.warp(endTime);
    }
}

/// Fails now: a depositor who sandwiches openPolicy exits in the same block with more than deposited.
contract ProofJitPremium is EconBase {
    function test_jitDepositCannotExtractPremiumRiskFree() public {
        (uint256 quoted,) = book.quote(START, 6, 5000, 500 ether);
        assertEq(quoted, 50 ether);
        uint256 bobShares = _deposit(bob, 9000 ether);
        vm.startPrank(alice);
        token.approve(address(book), quoted);
        book.openPolicy(START, 6, 5000, 500 ether, quoted, block.timestamp);
        vm.stopPrank();
        // Bob exits in the same block. Either the exit is refused or it returns no more than he put in.
        vm.prank(bob);
        try pool.redeem(bobShares, 1) returns (uint256 got) {
            assertLe(got, 9000 ether, "same-block exit must not profit from the premium");
        } catch {}
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockSQK} from "src/MockSQK.sol";
import {PremiumModel} from "src/PremiumModel.sol";
import {CoverPool} from "src/CoverPool.sol";
import {CoreReader} from "src/CoreReader.sol";
import {PolicyBook} from "src/PolicyBook.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal V3 core fixture: sparse active records, settable frontier and batch limit.
contract EconCore is ISqueekCore {
    uint64 public genesis;
    uint64 public frontier;
    uint16 public maxRoundsPerBatch = 16;
    RoundCheckpoint[] private _records;

    constructor(uint64 genesis_) {
        genesis = genesis_;
    }

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

    function setMaxRoundsPerBatch(uint16 value) external {
        maxRoundsPerBatch = value;
    }

    function record(uint64 roundId, uint64 work) external {
        LedgerPosition memory last = _positionAt(type(uint64).max);
        _records.push(
            RoundCheckpoint(
                roundId,
                last.cumulativeWork + work,
                last.cumulativeBlockUnits + uint96(work) * 1e9,
                10_875,
                keccak256(abi.encode(roundId, work))
            )
        );
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function configuration() external view returns (CoreConfiguration memory result) {
        result.genesisTimestamp = genesis;
        result.roundDuration = 600;
        result.maxWorkPerRound = 10_000;
        result.maxRoundsPerBatch = maxRoundsPerBatch;
        result.initialWorkPerThousandBlocks = 10_875;
        result.targetBlocksPerActiveRound = 40;
        result.difficultySmoothingRounds = 30;
        result.blockUnitsPerBlock = 1e9;
    }

    function state() external view returns (CoreState memory result) {
        LedgerPosition memory position = _positionAt(frontier);
        result.settledThroughRound = frontier;
        result.cumulativeWork = position.cumulativeWork;
        result.cumulativeBlockUnits = position.cumulativeBlockUnits;
        result.workPerThousandBlocks = position.workPerThousandBlocks;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory result)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "core: bounds");
        require(maxRecords <= maxRoundsPerBatch, "core: batch");
        result.start = _positionAt(afterRound);
        result.certifiedThroughRound = throughRound;
        RoundCheckpoint[] memory records = new RoundCheckpoint[](maxRecords);
        uint256 count;
        for (uint256 i; i < _records.length; ++i) {
            RoundCheckpoint memory checkpoint = _records[i];
            if (checkpoint.roundId <= afterRound) continue;
            if (checkpoint.roundId > throughRound) break;
            if (count == maxRecords) {
                result.certifiedThroughRound = checkpoint.roundId - 1;
                break;
            }
            records[count++] = checkpoint;
        }
        assembly ("memory-safe") {
            mstore(records, count)
        }
        result.rounds = records;
        result.end = _positionAt(result.certifiedThroughRound);
    }

    function _positionAt(uint64 round) private view returns (LedgerPosition memory result) {
        result.workPerThousandBlocks = 10_875;
        for (uint256 i = _records.length; i != 0; --i) {
            RoundCheckpoint memory checkpoint = _records[i - 1];
            if (checkpoint.roundId <= round) {
                return LedgerPosition(
                    checkpoint.cumulativeWork, checkpoint.cumulativeBlockUnits, checkpoint.workPerThousandBlocks
                );
            }
        }
    }
}

abstract contract EconBase is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    uint64 internal constant START = 102;
    address internal owner = makeAddr("owner");
    address internal lp = makeAddr("lp");
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");
    MockSQK internal token;
    PremiumModel internal model;
    CoverPool internal pool;
    CoreReader internal reader;
    PolicyBook internal book;
    EconCore internal core;

    function setUp() public virtual {
        vm.chainId(11_155_111);
        vm.warp(GENESIS + 100 * 600);
        core = new EconCore(GENESIS);
        core.setFrontier(100);
        token = new MockSQK(owner);
        model = new PremiumModel(owner);
        pool = new CoverPool(owner, address(token));
        reader = new CoreReader(address(core));
        book = new PolicyBook(owner, address(token), address(model), address(pool), address(reader));
        vm.startPrank(owner);
        pool.setPolicyBook(address(book));
        uint16[4] memory durations = [uint16(6), 12, 24, 144];
        uint16[3] memory thresholds = [uint16(3000), 5000, 7000];
        for (uint256 i; i < 4; ++i) {
            for (uint256 j; j < 3; ++j) {
                model.setRate(durations[i], thresholds[j], 500, 1000);
            }
        }
        token.mint(lp, 100_000 ether);
        token.mint(alice, 100_000 ether);
        token.mint(bob, 100_000 ether);
        vm.stopPrank();
        _deposit(lp, 1000 ether);
    }

    function _deposit(address who, uint256 amount) internal returns (uint256 shares) {
        vm.startPrank(who);
        token.approve(address(pool), amount);
        shares = pool.deposit(amount, 1);
        vm.stopPrank();
    }

    function _open(address buyer, uint64 start, uint16 rounds, uint16 threshold, uint256 cover)
        internal
        returns (uint256 id, uint256 premium)
    {
        (premium,) = book.quote(start, rounds, threshold, cover);
        vm.startPrank(buyer);
        token.approve(address(book), premium);
        id = book.openPolicy(start, rounds, threshold, cover, premium, block.timestamp);
        vm.stopPrank();
    }

    function _certify(uint64 end) internal {
        core.setFrontier(end);
        uint256 endTime = uint256(GENESIS) + uint256(end) * 600;
        if (endTime > block.timestamp) vm.warp(endTime);
    }
}

/// Fails now: an LP exits after the payout is certain but before settlement is possible,
/// leaving the other LP with the whole loss.
contract ProofLpExitBeforeLoss is EconBase {
    function test_lossIsSharedByLpsPresentWhenCoverWasSold() public {
        uint256 bobShares = _deposit(bob, 1000 ether);
        (uint256 id, uint256 premium) = _open(alice, START, 6, 3000, 1000 ether);
        assertEq(premium, 100 ether);
        // Rounds START and START+1 certified with no work: 2 >= ceil(6 * 30%) so C is owed.
        _certify(START + 1);
        vm.expectRevert(abi.encodeWithSelector(CoreReader.UnknownRounds.selector, START + 5, START + 1));
        book.settle(id);
        vm.prank(bob);
        try pool.redeem(bobShares, 1) {} catch {}
        _certify(START + 5);
        assertEq(book.settle(id), 1000 ether);
        // Both LPs funded the 1000 cover equally; each should carry about 500 of the loss.
        assertGe(pool.previewRedeem(pool.sharesOf(lp)), 500 ether, "lp left holding the whole loss");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockSQK} from "src/MockSQK.sol";
import {PremiumModel} from "src/PremiumModel.sol";
import {CoverPool} from "src/CoverPool.sol";
import {CoreReader} from "src/CoreReader.sol";
import {PolicyBook} from "src/PolicyBook.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal V3 core fixture: sparse active records, settable frontier and batch limit.
contract EconCore is ISqueekCore {
    uint64 public genesis;
    uint64 public frontier;
    uint16 public maxRoundsPerBatch = 16;
    RoundCheckpoint[] private _records;

    constructor(uint64 genesis_) {
        genesis = genesis_;
    }

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

    function setMaxRoundsPerBatch(uint16 value) external {
        maxRoundsPerBatch = value;
    }

    function record(uint64 roundId, uint64 work) external {
        LedgerPosition memory last = _positionAt(type(uint64).max);
        _records.push(
            RoundCheckpoint(
                roundId,
                last.cumulativeWork + work,
                last.cumulativeBlockUnits + uint96(work) * 1e9,
                10_875,
                keccak256(abi.encode(roundId, work))
            )
        );
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function configuration() external view returns (CoreConfiguration memory result) {
        result.genesisTimestamp = genesis;
        result.roundDuration = 600;
        result.maxWorkPerRound = 10_000;
        result.maxRoundsPerBatch = maxRoundsPerBatch;
        result.initialWorkPerThousandBlocks = 10_875;
        result.targetBlocksPerActiveRound = 40;
        result.difficultySmoothingRounds = 30;
        result.blockUnitsPerBlock = 1e9;
    }

    function state() external view returns (CoreState memory result) {
        LedgerPosition memory position = _positionAt(frontier);
        result.settledThroughRound = frontier;
        result.cumulativeWork = position.cumulativeWork;
        result.cumulativeBlockUnits = position.cumulativeBlockUnits;
        result.workPerThousandBlocks = position.workPerThousandBlocks;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory result)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "core: bounds");
        require(maxRecords <= maxRoundsPerBatch, "core: batch");
        result.start = _positionAt(afterRound);
        result.certifiedThroughRound = throughRound;
        RoundCheckpoint[] memory records = new RoundCheckpoint[](maxRecords);
        uint256 count;
        for (uint256 i; i < _records.length; ++i) {
            RoundCheckpoint memory checkpoint = _records[i];
            if (checkpoint.roundId <= afterRound) continue;
            if (checkpoint.roundId > throughRound) break;
            if (count == maxRecords) {
                result.certifiedThroughRound = checkpoint.roundId - 1;
                break;
            }
            records[count++] = checkpoint;
        }
        assembly ("memory-safe") {
            mstore(records, count)
        }
        result.rounds = records;
        result.end = _positionAt(result.certifiedThroughRound);
    }

    function _positionAt(uint64 round) private view returns (LedgerPosition memory result) {
        result.workPerThousandBlocks = 10_875;
        for (uint256 i = _records.length; i != 0; --i) {
            RoundCheckpoint memory checkpoint = _records[i - 1];
            if (checkpoint.roundId <= round) {
                return LedgerPosition(
                    checkpoint.cumulativeWork, checkpoint.cumulativeBlockUnits, checkpoint.workPerThousandBlocks
                );
            }
        }
    }
}

abstract contract EconBase is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    uint64 internal constant START = 102;
    address internal owner = makeAddr("owner");
    address internal lp = makeAddr("lp");
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");
    MockSQK internal token;
    PremiumModel internal model;
    CoverPool internal pool;
    CoreReader internal reader;
    PolicyBook internal book;
    EconCore internal core;

    function setUp() public virtual {
        vm.chainId(11_155_111);
        vm.warp(GENESIS + 100 * 600);
        core = new EconCore(GENESIS);
        core.setFrontier(100);
        token = new MockSQK(owner);
        model = new PremiumModel(owner);
        pool = new CoverPool(owner, address(token));
        reader = new CoreReader(address(core));
        book = new PolicyBook(owner, address(token), address(model), address(pool), address(reader));
        vm.startPrank(owner);
        pool.setPolicyBook(address(book));
        uint16[4] memory durations = [uint16(6), 12, 24, 144];
        uint16[3] memory thresholds = [uint16(3000), 5000, 7000];
        for (uint256 i; i < 4; ++i) {
            for (uint256 j; j < 3; ++j) {
                model.setRate(durations[i], thresholds[j], 500, 1000);
            }
        }
        token.mint(lp, 100_000 ether);
        token.mint(alice, 100_000 ether);
        token.mint(bob, 100_000 ether);
        vm.stopPrank();
        _deposit(lp, 1000 ether);
    }

    function _deposit(address who, uint256 amount) internal returns (uint256 shares) {
        vm.startPrank(who);
        token.approve(address(pool), amount);
        shares = pool.deposit(amount, 1);
        vm.stopPrank();
    }

    function _open(address buyer, uint64 start, uint16 rounds, uint16 threshold, uint256 cover)
        internal
        returns (uint256 id, uint256 premium)
    {
        (premium,) = book.quote(start, rounds, threshold, cover);
        vm.startPrank(buyer);
        token.approve(address(book), premium);
        id = book.openPolicy(start, rounds, threshold, cover, premium, block.timestamp);
        vm.stopPrank();
    }

    function _certify(uint64 end) internal {
        core.setFrontier(end);
        uint256 endTime = uint256(GENESIS) + uint256(end) * 600;
        if (endTime > block.timestamp) vm.warp(endTime);
    }
}

/// Fails now: a start round in the unreachable future is accepted and reserves the pool forever.
contract ProofFarFutureLock is EconBase {
    function test_rejectsStartBeyondReasonableHorizon() public {
        uint64 farStart = type(uint64).max - 10;
        (uint256 premium,) = book.quote(farStart, 6, 5000, 1000 ether);
        vm.startPrank(alice);
        token.approve(address(book), premium);
        vm.expectRevert();
        book.openPolicy(farStart, 6, 5000, 1000 ether, premium, block.timestamp);
        vm.stopPrank();
        assertEq(pool.reserved(), 0);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockSQK} from "src/MockSQK.sol";
import {PremiumModel} from "src/PremiumModel.sol";
import {CoverPool} from "src/CoverPool.sol";
import {CoreReader} from "src/CoreReader.sol";
import {PolicyBook} from "src/PolicyBook.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal V3 core fixture: sparse active records, settable frontier and batch limit.
contract EconCore is ISqueekCore {
    uint64 public genesis;
    uint64 public frontier;
    uint16 public maxRoundsPerBatch = 16;
    RoundCheckpoint[] private _records;

    constructor(uint64 genesis_) {
        genesis = genesis_;
    }

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

    function setMaxRoundsPerBatch(uint16 value) external {
        maxRoundsPerBatch = value;
    }

    function record(uint64 roundId, uint64 work) external {
        LedgerPosition memory last = _positionAt(type(uint64).max);
        _records.push(
            RoundCheckpoint(
                roundId,
                last.cumulativeWork + work,
                last.cumulativeBlockUnits + uint96(work) * 1e9,
                10_875,
                keccak256(abi.encode(roundId, work))
            )
        );
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function configuration() external view returns (CoreConfiguration memory result) {
        result.genesisTimestamp = genesis;
        result.roundDuration = 600;
        result.maxWorkPerRound = 10_000;
        result.maxRoundsPerBatch = maxRoundsPerBatch;
        result.initialWorkPerThousandBlocks = 10_875;
        result.targetBlocksPerActiveRound = 40;
        result.difficultySmoothingRounds = 30;
        result.blockUnitsPerBlock = 1e9;
    }

    function state() external view returns (CoreState memory result) {
        LedgerPosition memory position = _positionAt(frontier);
        result.settledThroughRound = frontier;
        result.cumulativeWork = position.cumulativeWork;
        result.cumulativeBlockUnits = position.cumulativeBlockUnits;
        result.workPerThousandBlocks = position.workPerThousandBlocks;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory result)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "core: bounds");
        require(maxRecords <= maxRoundsPerBatch, "core: batch");
        result.start = _positionAt(afterRound);
        result.certifiedThroughRound = throughRound;
        RoundCheckpoint[] memory records = new RoundCheckpoint[](maxRecords);
        uint256 count;
        for (uint256 i; i < _records.length; ++i) {
            RoundCheckpoint memory checkpoint = _records[i];
            if (checkpoint.roundId <= afterRound) continue;
            if (checkpoint.roundId > throughRound) break;
            if (count == maxRecords) {
                result.certifiedThroughRound = checkpoint.roundId - 1;
                break;
            }
            records[count++] = checkpoint;
        }
        assembly ("memory-safe") {
            mstore(records, count)
        }
        result.rounds = records;
        result.end = _positionAt(result.certifiedThroughRound);
    }

    function _positionAt(uint64 round) private view returns (LedgerPosition memory result) {
        result.workPerThousandBlocks = 10_875;
        for (uint256 i = _records.length; i != 0; --i) {
            RoundCheckpoint memory checkpoint = _records[i - 1];
            if (checkpoint.roundId <= round) {
                return LedgerPosition(
                    checkpoint.cumulativeWork, checkpoint.cumulativeBlockUnits, checkpoint.workPerThousandBlocks
                );
            }
        }
    }
}

abstract contract EconBase is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    uint64 internal constant START = 102;
    address internal owner = makeAddr("owner");
    address internal lp = makeAddr("lp");
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");
    MockSQK internal token;
    PremiumModel internal model;
    CoverPool internal pool;
    CoreReader internal reader;
    PolicyBook internal book;
    EconCore internal core;

    function setUp() public virtual {
        vm.chainId(11_155_111);
        vm.warp(GENESIS + 100 * 600);
        core = new EconCore(GENESIS);
        core.setFrontier(100);
        token = new MockSQK(owner);
        model = new PremiumModel(owner);
        pool = new CoverPool(owner, address(token));
        reader = new CoreReader(address(core));
        book = new PolicyBook(owner, address(token), address(model), address(pool), address(reader));
        vm.startPrank(owner);
        pool.setPolicyBook(address(book));
        uint16[4] memory durations = [uint16(6), 12, 24, 144];
        uint16[3] memory thresholds = [uint16(3000), 5000, 7000];
        for (uint256 i; i < 4; ++i) {
            for (uint256 j; j < 3; ++j) {
                model.setRate(durations[i], thresholds[j], 500, 1000);
            }
        }
        token.mint(lp, 100_000 ether);
        token.mint(alice, 100_000 ether);
        token.mint(bob, 100_000 ether);
        vm.stopPrank();
        _deposit(lp, 1000 ether);
    }

    function _deposit(address who, uint256 amount) internal returns (uint256 shares) {
        vm.startPrank(who);
        token.approve(address(pool), amount);
        shares = pool.deposit(amount, 1);
        vm.stopPrank();
    }

    function _open(address buyer, uint64 start, uint16 rounds, uint16 threshold, uint256 cover)
        internal
        returns (uint256 id, uint256 premium)
    {
        (premium,) = book.quote(start, rounds, threshold, cover);
        vm.startPrank(buyer);
        token.approve(address(book), premium);
        id = book.openPolicy(start, rounds, threshold, cover, premium, block.timestamp);
        vm.stopPrank();
    }

    function _certify(uint64 end) internal {
        core.setFrontier(end);
        uint256 endTime = uint256(GENESIS) + uint256(end) * 600;
        if (endTime > block.timestamp) vm.warp(endTime);
    }
}

/// Fails now: raising Core's maxRoundsPerBatch above 16 makes every settlement revert
/// although 16-record pages are still served.
contract ProofBatchLimitBrick is EconBase {
    function test_settlementSurvivesRaisedBatchLimit() public {
        (uint256 id,) = _open(alice, START, 6, 5000, 100 ether);
        _certify(START + 5);
        core.setMaxRoundsPerBatch(32);
        ISqueekCore.RoundPage memory page = core.roundPage(START - 1, START + 5, 16);
        assertEq(page.certifiedThroughRound, START + 5);
        assertEq(book.settle(id), 100 ether);
        assertEq(pool.reserved(), 0);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockSQK} from "src/MockSQK.sol";
import {PremiumModel} from "src/PremiumModel.sol";
import {CoverPool} from "src/CoverPool.sol";
import {CoreReader} from "src/CoreReader.sol";
import {PolicyBook} from "src/PolicyBook.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

contract CertifiedEmptyHistoryForShares is ISqueekCore {
    uint64 public constant GENESIS = 1_700_000_000;
    uint64 public frontier;

    function certify(uint64 value) external {
        frontier = value;
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function configuration() external pure returns (CoreConfiguration memory c) {
        c.genesisTimestamp = GENESIS;
        c.roundDuration = 600;
        c.maxRoundsPerBatch = 16;
    }

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

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (RoundPage memory p)
    {
        require(afterRound < throughRound && throughRound <= frontier);
        p.certifiedThroughRound = throughRound;
        p.start.workPerThousandBlocks = 10_875;
        p.end.workPerThousandBlocks = 10_875;
        p.rounds = new RoundCheckpoint[](0);
    }
}

contract ShareDenominatorProofTest is Test {
    CertifiedEmptyHistoryForShares core;
    MockSQK token;
    PremiumModel model;
    CoverPool pool;
    CoreReader reader;
    PolicyBook book;

    function test_otherLpCanRedeemAfterAdversarialShareGrowth() public {
        vm.chainId(11_155_111);
        core = new CertifiedEmptyHistoryForShares();
        vm.warp(core.GENESIS());
        address administrator = makeAddr("administrator");
        token = new MockSQK(administrator);
        model = new PremiumModel(administrator);
        pool = new CoverPool(administrator, address(token));
        reader = new CoreReader(address(core));
        book = new PolicyBook(administrator, address(token), address(model), address(pool), address(reader));
        vm.startPrank(administrator);
        pool.setPolicyBook(address(book));
        // A supported, constant 10% premium. The same user is LP and buyer.
        model.setRate(6, 5000, 1000, 0);
        token.transfer(address(this), 1100 ether);
        vm.stopPrank();
        // From here, the test is an ordinary LP/buyer with no administrative role.
        token.approve(address(pool), type(uint256).max);
        token.approve(address(book), type(uint256).max);
        uint256 originalBalance = token.balanceOf(address(this));
        for (uint64 cycle; cycle < 3; ++cycle) {
            pool.deposit(1000 ether, 1);
            (, uint64 current,) = reader.snapshot();
            uint64 start = current + 1;
            uint256 id = book.openPolicy(start, 6, 5000, 1000 ether, 100 ether, block.timestamp);
            // Redeem exactly the free premium before the certified full payout.
            uint256 shares = _sharesForAssets(100 ether);
            assertEq(pool.redeem(shares, 100 ether), 100 ether);
            uint64 end = start + 5;
            core.certify(end);
            vm.warp(uint256(core.GENESIS()) + uint256(end) * 600);
            assertEq(book.settle(id), 1000 ether);
            assertEq(pool.totalAssets(), 0);
            assertEq(pool.reserved(), 0);
            assertEq(token.balanceOf(address(this)), originalBalance);
        }
        // One atom allows a positive redemption that burns arbitrary worthless shares.
        pool.deposit(1, 1);
        uint256 retained = (uint256(1) << 196) - pool.VIRTUAL_SHARES();
        assertEq(pool.redeem(pool.sharesOf(address(this)) - retained, 1), 1);
        assertEq(pool.totalAssets(), 0);
        assertEq(pool.totalShares() + pool.VIRTUAL_SHARES(), uint256(1) << 196);

        address victim = makeAddr("innocent LP");
        token.transfer(victim, 1 ether);
        vm.startPrank(victim);
        token.approve(address(pool), 1 ether);
        uint256 victimShares = pool.deposit(1 ether, 1);
        vm.stopPrank();

        // S + virtual = (A + 1) * 2**196. Top up A to 2**60 - 1.
        // totalShares itself still fits: it becomes 2**256 - 1_000_000.
        // A fixed implementation may reject this adversarial deposit; either way,
        // the innocent LP must retain access to their fully liquid capital.
        uint256 topUp = (uint256(1) << 60) - 1 - 1 ether;
        (bool deposited,) = address(pool).call(abi.encodeCall(pool.deposit, (topUp, 1)));
        if (deposited) assertEq(pool.totalAssets(), (uint256(1) << 60) - 1);
        assertEq(pool.reserved(), 0);
        assertGe(token.balanceOf(address(pool)), 1 ether);
        vm.prank(victim);
        assertEq(pool.redeem(victimShares, 1 ether), 1 ether);
    }

    function _sharesForAssets(uint256 assets) private view returns (uint256) {
        uint256 low;
        uint256 high = pool.sharesOf(address(this));
        while (low < high) {
            uint256 mid = low + (high - low) / 2;
            if (pool.previewRedeem(mid) < assets) low = mid + 1;
            else high = mid;
        }
        return low;
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockSQK} from "src/MockSQK.sol";
import {PremiumModel} from "src/PremiumModel.sol";
import {CoverPool} from "src/CoverPool.sol";
import {CoreReader} from "src/CoreReader.sol";
import {PolicyBook} from "src/PolicyBook.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

contract CertifiedEmptyHistory is ISqueekCore {
    uint64 public constant GENESIS = 1_700_000_000;
    uint64 public frontier;

    function certify(uint64 value) external {
        frontier = value;
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function configuration() external pure returns (CoreConfiguration memory c) {
        c.genesisTimestamp = GENESIS;
        c.roundDuration = 600;
        c.maxRoundsPerBatch = 16;
    }

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

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (RoundPage memory p)
    {
        require(afterRound < throughRound && throughRound <= frontier);
        p.certifiedThroughRound = throughRound;
        p.start.workPerThousandBlocks = 10_875;
        p.end.workPerThousandBlocks = 10_875;
        p.rounds = new RoundCheckpoint[](0);
    }
}

contract RepeatedLossProofTest is Test {
    CertifiedEmptyHistory core;
    MockSQK token;
    PremiumModel model;
    CoverPool pool;
    CoreReader reader;
    PolicyBook book;

    function test_recapitalizationRemainsPossibleAfterThreeCoveredLosses() public {
        vm.chainId(11_155_111);
        core = new CertifiedEmptyHistory();
        vm.warp(core.GENESIS());
        address administrator = makeAddr("administrator");
        token = new MockSQK(administrator);
        model = new PremiumModel(administrator);
        pool = new CoverPool(administrator, address(token));
        reader = new CoreReader(address(core));
        book = new PolicyBook(administrator, address(token), address(model), address(pool), address(reader));
        vm.startPrank(administrator);
        pool.setPolicyBook(address(book));
        // A supported, constant 10% premium. The same user is LP and buyer.
        model.setRate(6, 5000, 1000, 0);
        token.transfer(address(this), 1100 ether);
        vm.stopPrank();
        // From here, the test is an ordinary LP/buyer with no administrative role.
        token.approve(address(pool), type(uint256).max);
        token.approve(address(book), type(uint256).max);
        uint256 originalBalance = token.balanceOf(address(this));
        for (uint64 cycle; cycle < 3; ++cycle) {
            pool.deposit(1000 ether, 1);
            (, uint64 current,) = reader.snapshot();
            uint64 start = current + 1;
            uint256 id = book.openPolicy(start, 6, 5000, 1000 ether, 100 ether, block.timestamp);
            // Redeem exactly the free premium before the certified full payout.
            uint256 shares = _sharesForAssets(100 ether);
            assertEq(pool.redeem(shares, 100 ether), 100 ether);
            uint64 end = start + 5;
            core.certify(end);
            vm.warp(uint256(core.GENESIS()) + uint256(end) * 600);
            assertEq(book.settle(id), 1000 ether);
            assertEq(pool.totalAssets(), 0);
            assertEq(pool.reserved(), 0);
            assertEq(token.balanceOf(address(this)), originalBalance);
        }
        // Expected: a funded user can recapitalize an empty pool, just as after the first loss.
        // Actual: arithmetic overflow in Math.mulDiv; the outstanding worthless shares grew each cycle.
        uint256 newShares = pool.deposit(1 ether, 1);
        assertGt(newShares, 0);
        assertEq(pool.totalAssets(), 1 ether);
    }

    function _sharesForAssets(uint256 assets) private view returns (uint256) {
        uint256 low;
        uint256 high = pool.sharesOf(address(this));
        while (low < high) {
            uint256 mid = low + (high - low) / 2;
            if (pool.previewRedeem(mid) < assets) low = mid + 1;
            else high = mid;
        }
        return low;
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockSQK} from "src/MockSQK.sol";
import {PremiumModel} from "src/PremiumModel.sol";
import {CoverPool} from "src/CoverPool.sol";
import {CoreReader} from "src/CoreReader.sol";
import {PolicyBook} from "src/PolicyBook.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

contract CertifiedEmptyHistoryForShares is ISqueekCore {
    uint64 public constant GENESIS = 1_700_000_000;
    uint64 public frontier;

    function certify(uint64 value) external {
        frontier = value;
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function configuration() external pure returns (CoreConfiguration memory c) {
        c.genesisTimestamp = GENESIS;
        c.roundDuration = 600;
        c.maxRoundsPerBatch = 16;
    }

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

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (RoundPage memory p)
    {
        require(afterRound < throughRound && throughRound <= frontier);
        p.certifiedThroughRound = throughRound;
        p.start.workPerThousandBlocks = 10_875;
        p.end.workPerThousandBlocks = 10_875;
        p.rounds = new RoundCheckpoint[](0);
    }
}

contract ShareDenominatorProofTest is Test {
    CertifiedEmptyHistoryForShares core;
    MockSQK token;
    PremiumModel model;
    CoverPool pool;
    CoreReader reader;
    PolicyBook book;

    function test_otherLpCanRedeemAfterAdversarialShareGrowth() public {
        vm.chainId(11_155_111);
        core = new CertifiedEmptyHistoryForShares();
        vm.warp(core.GENESIS());
        address administrator = makeAddr("administrator");
        token = new MockSQK(administrator);
        model = new PremiumModel(administrator);
        pool = new CoverPool(administrator, address(token));
        reader = new CoreReader(address(core));
        book = new PolicyBook(administrator, address(token), address(model), address(pool), address(reader));
        vm.startPrank(administrator);
        pool.setPolicyBook(address(book));
        // A supported, constant 10% premium. The same user is LP and buyer.
        model.setRate(6, 5000, 1000, 0);
        token.transfer(address(this), 1100 ether);
        vm.stopPrank();
        // From here, the test is an ordinary LP/buyer with no administrative role.
        token.approve(address(pool), type(uint256).max);
        token.approve(address(book), type(uint256).max);
        uint256 originalBalance = token.balanceOf(address(this));
        for (uint64 cycle; cycle < 3; ++cycle) {
            pool.deposit(1000 ether, 1);
            (, uint64 current,) = reader.snapshot();
            uint64 start = current + 1;
            uint256 id = book.openPolicy(start, 6, 5000, 1000 ether, 100 ether, block.timestamp);
            // Redeem exactly the free premium before the certified full payout.
            uint256 shares = _sharesForAssets(100 ether);
            assertEq(pool.redeem(shares, 100 ether), 100 ether);
            uint64 end = start + 5;
            core.certify(end);
            vm.warp(uint256(core.GENESIS()) + uint256(end) * 600);
            assertEq(book.settle(id), 1000 ether);
            assertEq(pool.totalAssets(), 0);
            assertEq(pool.reserved(), 0);
            assertEq(token.balanceOf(address(this)), originalBalance);
        }
        // One atom allows a positive redemption that burns arbitrary worthless shares.
        pool.deposit(1, 1);
        uint256 retained = (uint256(1) << 196) - pool.VIRTUAL_SHARES();
        assertEq(pool.redeem(pool.sharesOf(address(this)) - retained, 1), 1);
        assertEq(pool.totalAssets(), 0);
        assertEq(pool.totalShares() + pool.VIRTUAL_SHARES(), uint256(1) << 196);

        address victim = makeAddr("innocent LP");
        token.transfer(victim, 1 ether);
        vm.startPrank(victim);
        token.approve(address(pool), 1 ether);
        uint256 victimShares = pool.deposit(1 ether, 1);
        vm.stopPrank();

        // S + virtual = (A + 1) * 2**196. Top up A to 2**60 - 1.
        // totalShares itself still fits: it becomes 2**256 - 1_000_000.
        // A fixed implementation may reject this adversarial deposit; either way,
        // the innocent LP must retain access to their fully liquid capital.
        uint256 topUp = (uint256(1) << 60) - 1 - 1 ether;
        (bool deposited,) = address(pool).call(abi.encodeCall(pool.deposit, (topUp, 1)));
        if (deposited) assertEq(pool.totalAssets(), (uint256(1) << 60) - 1);
        assertEq(pool.reserved(), 0);
        assertGe(token.balanceOf(address(pool)), 1 ether);
        vm.prank(victim);
        assertEq(pool.redeem(victimShares, 1 ether), 1 ether);
    }

    function _sharesForAssets(uint256 assets) private view returns (uint256) {
        uint256 low;
        uint256 high = pool.sharesOf(address(this));
        while (low < high) {
            uint256 mid = low + (high - low) / 2;
            if (pool.previewRedeem(mid) < assets) low = mid + 1;
            else high = mid;
        }
        return low;
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockSQK} from "src/MockSQK.sol";
import {PremiumModel} from "src/PremiumModel.sol";
import {CoverPool} from "src/CoverPool.sol";
import {CoreReader} from "src/CoreReader.sol";
import {PolicyBook} from "src/PolicyBook.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal V3-shaped core: frontier 100, no active records, current round 101.
contract StubCore is ISqueekCore {
    uint64 public immutable genesis;
    uint64 public frontier = 100;

    constructor(uint64 genesis_) {
        genesis = genesis_;
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function configuration() external view returns (CoreConfiguration memory c) {
        c.genesisTimestamp = genesis;
        c.roundDuration = 600;
        c.maxRoundsPerBatch = 16;
        c.initialWorkPerThousandBlocks = 10_875;
    }

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

    function roundPage(uint64, uint64 throughRound, uint256) external pure returns (RoundPage memory p) {
        p.certifiedThroughRound = throughRound;
        p.start = LedgerPosition(0, 0, 10_875);
        p.end = p.start;
        p.rounds = new RoundCheckpoint[](0);
    }
}

/// @notice openPolicy accepts a start round that the core can never certify, so the whole free
/// liquidity of the pool is reserved forever for one flat premium. A start-round lead cap makes
/// this call revert and the test pass.
contract FarFutureLockTest is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    address internal owner = makeAddr("owner");
    address internal lp = makeAddr("lp");
    address internal attacker = makeAddr("attacker");
    MockSQK internal token;
    PremiumModel internal model;
    CoverPool internal pool;
    CoreReader internal reader;
    PolicyBook internal book;

    function setUp() public {
        vm.chainId(11_155_111);
        vm.warp(GENESIS + 100 * 600);
        StubCore core = new StubCore(GENESIS);
        token = new MockSQK(owner);
        model = new PremiumModel(owner);
        pool = new CoverPool(owner, address(token));
        reader = new CoreReader(address(core));
        book = new PolicyBook(owner, address(token), address(model), address(pool), address(reader));
        vm.startPrank(owner);
        pool.setPolicyBook(address(book));
        model.setRate(144, 3000, 500, 1000);
        token.mint(lp, 1000 ether);
        token.mint(attacker, 1000 ether);
        vm.stopPrank();
        vm.startPrank(lp);
        token.approve(address(pool), 1000 ether);
        pool.deposit(1000 ether, 1);
        vm.stopPrank();
    }

    function test_startRoundBeyondAnyReachableRoundIsRejected() public {
        // Current round is 101 and the frontier is 100. This window ends at round 2^64-1,
        // which at 600 s per round is ~3.5e14 years away: the reservation can never be released.
        uint64 start = type(uint64).max - 143;
        vm.startPrank(attacker);
        token.approve(address(book), type(uint256).max);
        vm.expectRevert();
        book.openPolicy(start, 144, 3000, 1000 ether, type(uint256).max, block.timestamp);
        vm.stopPrank();
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockSQK} from "src/MockSQK.sol";
import {PremiumModel} from "src/PremiumModel.sol";
import {CoverPool} from "src/CoverPool.sol";
import {CoreReader} from "src/CoreReader.sol";
import {PolicyBook} from "src/PolicyBook.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

contract CertifiedEmptyHistory is ISqueekCore {
    uint64 public constant GENESIS = 1_700_000_000;
    uint64 public frontier;

    function certify(uint64 value) external {
        frontier = value;
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function configuration() external pure returns (CoreConfiguration memory c) {
        c.genesisTimestamp = GENESIS;
        c.roundDuration = 600;
        c.maxRoundsPerBatch = 16;
    }

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

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (RoundPage memory p)
    {
        require(afterRound < throughRound && throughRound <= frontier);
        p.certifiedThroughRound = throughRound;
        p.start.workPerThousandBlocks = 10_875;
        p.end.workPerThousandBlocks = 10_875;
        p.rounds = new RoundCheckpoint[](0);
    }
}

contract RepeatedLossProofTest is Test {
    CertifiedEmptyHistory core;
    MockSQK token;
    PremiumModel model;
    CoverPool pool;
    CoreReader reader;
    PolicyBook book;

    function test_recapitalizationRemainsPossibleAfterThreeCoveredLosses() public {
        vm.chainId(11_155_111);
        core = new CertifiedEmptyHistory();
        vm.warp(core.GENESIS());
        address administrator = makeAddr("administrator");
        token = new MockSQK(administrator);
        model = new PremiumModel(administrator);
        pool = new CoverPool(administrator, address(token));
        reader = new CoreReader(address(core));
        book = new PolicyBook(administrator, address(token), address(model), address(pool), address(reader));
        vm.startPrank(administrator);
        pool.setPolicyBook(address(book));
        // A supported, constant 10% premium. The same user is LP and buyer.
        model.setRate(6, 5000, 1000, 0);
        token.transfer(address(this), 1100 ether);
        vm.stopPrank();
        // From here, the test is an ordinary LP/buyer with no administrative role.
        token.approve(address(pool), type(uint256).max);
        token.approve(address(book), type(uint256).max);
        uint256 originalBalance = token.balanceOf(address(this));
        for (uint64 cycle; cycle < 3; ++cycle) {
            pool.deposit(1000 ether, 1);
            (, uint64 current,) = reader.snapshot();
            uint64 start = current + 1;
            uint256 id = book.openPolicy(start, 6, 5000, 1000 ether, 100 ether, block.timestamp);
            // Redeem exactly the free premium before the certified full payout.
            uint256 shares = _sharesForAssets(100 ether);
            assertEq(pool.redeem(shares, 100 ether), 100 ether);
            uint64 end = start + 5;
            core.certify(end);
            vm.warp(uint256(core.GENESIS()) + uint256(end) * 600);
            assertEq(book.settle(id), 1000 ether);
            assertEq(pool.totalAssets(), 0);
            assertEq(pool.reserved(), 0);
            assertEq(token.balanceOf(address(this)), originalBalance);
        }
        // Expected: a funded user can recapitalize an empty pool, just as after the first loss.
        // Actual: arithmetic overflow in Math.mulDiv; the outstanding worthless shares grew each cycle.
        uint256 newShares = pool.deposit(1 ether, 1);
        assertGt(newShares, 0);
        assertEq(pool.totalAssets(), 1 ether);
    }

    function _sharesForAssets(uint256 assets) private view returns (uint256) {
        uint256 low;
        uint256 high = pool.sharesOf(address(this));
        while (low < high) {
            uint256 mid = low + (high - low) / 2;
            if (pool.previewRedeem(mid) < assets) low = mid + 1;
            else high = mid;
        }
        return low;
    }
}

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

import {Test} from "forge-std/Test.sol";
import {MockSQK} from "src/MockSQK.sol";
import {PremiumModel} from "src/PremiumModel.sol";
import {CoverPool} from "src/CoverPool.sol";
import {CoreReader} from "src/CoreReader.sol";
import {PolicyBook} from "src/PolicyBook.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal V3-shaped core with a settable frontier and no active records (every round is zero-work).
contract EmptyCore is ISqueekCore {
    uint64 public constant GENESIS = 1_700_000_000;
    uint64 public frontier = 100;

    function certify(uint64 value) external {
        frontier = value;
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function configuration() external pure returns (CoreConfiguration memory c) {
        c.genesisTimestamp = GENESIS;
        c.roundDuration = 600;
        c.maxRoundsPerBatch = 16;
    }

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

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (RoundPage memory p)
    {
        require(afterRound < throughRound && throughRound <= frontier, "bounds");
        p.certifiedThroughRound = throughRound;
        p.start.workPerThousandBlocks = 10_875;
        p.end.workPerThousandBlocks = 10_875;
        p.rounds = new RoundCheckpoint[](0);
    }
}

/// @notice Two LPs fund a policy equally. Once the whole window is certified the payout is fixed by public
/// history, but until someone calls settle() the pool still values shares with the doomed reservation and
/// redeem() only checks free assets. The first LP out leaves with its full pre-loss value plus half the
/// premium; the LP that stays carries the entire 1000 SQI payout. Fails now; passes once shares present
/// at the sale carry their share of the loss (haircut, settle-before-redeem, or a redemption lock).
contract ProofExitBeforeSettle is Test {
    uint64 internal constant START = 102;
    address internal owner = makeAddr("owner");
    address internal lpA = makeAddr("lpA");
    address internal lpB = makeAddr("lpB");
    address internal buyer = makeAddr("buyer");
    EmptyCore internal core;
    MockSQK internal token;
    PremiumModel internal model;
    CoverPool internal pool;
    CoreReader internal reader;
    PolicyBook internal book;

    function setUp() public {
        vm.chainId(11_155_111);
        core = new EmptyCore();
        vm.warp(uint256(core.GENESIS()) + 100 * 600);
        token = new MockSQK(owner);
        model = new PremiumModel(owner);
        pool = new CoverPool(owner, address(token));
        reader = new CoreReader(address(core));
        book = new PolicyBook(owner, address(token), address(model), address(pool), address(reader));
        vm.startPrank(owner);
        pool.setPolicyBook(address(book));
        model.setRate(6, 5000, 500, 1000);
        token.transfer(lpA, 1000 ether);
        token.transfer(lpB, 1000 ether);
        token.transfer(buyer, 1000 ether);
        vm.stopPrank();
        _deposit(lpA, 1000 ether);
        _deposit(lpB, 1000 ether);
    }

    function _deposit(address who, uint256 amount) internal {
        vm.startPrank(who);
        token.approve(address(pool), amount);
        pool.deposit(amount, 1);
        vm.stopPrank();
    }

    function test_firstLpOutCannotEscapeACertifiedLoss() public {
        (uint256 premium,) = book.quote(START, 6, 5000, 1000 ether);
        assertEq(premium, 100 ether);
        vm.startPrank(buyer);
        token.approve(address(book), premium);
        uint256 id = book.openPolicy(START, 6, 5000, 1000 ether, premium, block.timestamp);
        vm.stopPrank();
        assertEq(pool.totalAssets(), 2100 ether);
        assertEq(pool.reserved(), 1000 ether);

        // The whole window 102..107 is certified with no active records: six zero-work rounds, payout certain.
        core.certify(START + 5);
        vm.warp(uint256(core.GENESIS()) + uint256(START + 5) * 600);
        assertEq(reader.countZeroRounds(START, 6), 6);

        // lpA exits before anyone calls settle().
        uint256 sharesA = pool.sharesOf(lpA);
        vm.prank(lpA);
        (bool ok, bytes memory ret) = address(pool).call(abi.encodeCall(pool.redeem, (sharesA, 1)));
        uint256 gotA = ok ? abi.decode(ret, (uint256)) : 0;

        assertEq(book.settle(id), 1000 ether);
        uint256 valueB = pool.previewRedeem(pool.sharesOf(lpB));

        // Expected: both LPs funded the cover equally, so each ends near (2100 - 1000) / 2 = 550 SQI.
        // Actual on this code: lpA leaves with 1049.99 SQI and lpB is left with 50 SQI.
        if (ok) {
            assertLe(gotA, 600 ether, "first LP out escaped a loss that was already certain");
            assertGe(valueB, 500 ether, "remaining LP absorbed the whole payout");
        } else {
            // A fix that blocks the early exit must still let lpA out after settlement at the shared loss.
            vm.prank(lpA);
            uint256 later = pool.redeem(sharesA, 1);
            assertLe(later, 600 ether);
            assertGe(valueB, 500 ether);
        }
    }
}