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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

contract CoreStubO {
    uint64 public genesis;
    uint64 public settled;
    uint96 public units;
    mapping(uint64 => uint96) public after_;

    constructor(uint64 g) { genesis = g; }
    function settle(uint64 round, uint64 blocks) external {
        units += uint96(blocks) * 1e9;
        for (uint64 r = settled + 1; r <= round; ++r) after_[r] = units;
        settled = round;
    }
    function state() external view returns (ISqueekCore.CoreState memory s) {
        s.settledThroughRound = settled;
        s.cumulativeBlockUnits = units;
        s.blockHeight = uint64(units / 1e9);
    }
    function configuration() external view returns (ISqueekCore.CoreConfiguration memory c) {
        c.genesisTimestamp = genesis;
        c.roundDuration = 600;
        c.blockUnitsPerBlock = 1e9;
    }
    function roundPage(uint64 a, uint64 t, uint256) external view returns (ISqueekCore.RoundPage memory p) {
        require(a <= t && t <= settled, "bounds");
        p.certifiedThroughRound = t;
        p.end.cumulativeBlockUnits = after_[t];
    }
}

/// A 1-wei first deposit makes accRewardPerShare huge (1e36 / 1000 shares per reward wei); afterwards
/// sharesOf * accRewardPerShare overflows for any ordinary deposit, so the farm is permanently unusable.
contract OverflowDoSTest is Test {
    uint64 constant GENESIS = 1_793_735_400;
    address owner = makeAddr("owner");
    address treasury = makeAddr("treasury");
    address attacker = makeAddr("attacker");
    address alice = makeAddr("alice");
    CoreStubO core;
    CheeseEmissionController controller;
    CheeseToken cheese;
    CheeseFarmETH farm;

    function setUp() public {
        vm.warp(GENESIS + 100 * 600 + 17);
        core = new CoreStubO(GENESIS);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, treasury, owner, address(controller));
        farm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(farm), 200); // the ETH Pool
        controller.activate();
        vm.stopPrank();
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
        vm.deal(attacker, 1 ether);
        vm.deal(alice, 100 ether);
    }

    function test_dustFirstDepositBricksFarm() public {
        vm.prank(attacker);
        farm.deposit{value: 1}(); // 1 wei -> 1000 shares
        assertEq(farm.totalShares(), 1000);

        // A day of SqueekCore rounds (144 rounds x 40 blocks, the documented target) while only the dust is staked.
        core.settle(core.settled() + 144, 144 * 40);
        vm.prank(attacker);
        farm.claim(attacker); // pulls the pool's emission: accRewardPerShare += amount * 1e36 / 1000

        // An honest 10 ETH deposit must succeed. It reverts with panic 0x11 (sharesOf * accRewardPerShare overflow).
        vm.prank(alice);
        uint256 shares = farm.deposit{value: 10 ether}();
        assertGt(shares, 0);
        assertEq(farm.sharesOf(alice), shares);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

contract CoreStubA {
    uint64 public genesis;
    uint64 public settled;
    uint96 public units;
    bool public down;
    mapping(uint64 => uint96) public after_;

    constructor(uint64 g) { genesis = g; }
    function setDown(bool d) external { down = d; }
    function settle(uint64 round, uint64 blocks) external {
        units += uint96(blocks) * 1e9;
        for (uint64 r = settled + 1; r <= round; ++r) after_[r] = units;
        settled = round;
    }
    function state() external view returns (ISqueekCore.CoreState memory s) {
        require(!down, "down");
        s.settledThroughRound = settled;
        s.cumulativeBlockUnits = units;
        s.blockHeight = uint64(units / 1e9);
    }
    function configuration() external view returns (ISqueekCore.CoreConfiguration memory c) {
        require(!down, "down");
        c.genesisTimestamp = genesis;
        c.roundDuration = 600;
        c.blockUnitsPerBlock = 1e9;
    }
    function roundPage(uint64 a, uint64 t, uint256) external view returns (ISqueekCore.RoundPage memory p) {
        require(!down, "down");
        require(a <= t && t <= settled, "bounds");
        p.certifiedThroughRound = t;
        p.end.cumulativeBlockUnits = after_[t];
    }
}

contract OutageDepositTest is Test {
    uint64 constant GENESIS = 1_793_735_400;
    address owner = makeAddr("owner");
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    CoreStubA core;
    CheeseEmissionController controller;
    CheeseToken cheese;
    CheeseFarmETH farm;

    function setUp() public {
        vm.warp(GENESIS + 100 * 600 + 17);
        core = new CoreStubA(GENESIS);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, treasury, owner, address(controller));
        farm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(farm), 200);
        controller.activate();
        vm.stopPrank();
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
    }

    function test_outageDeposit() public {
        vm.prank(alice);
        farm.deposit{value: 10 ether}();
        core.settle(core.settled() + 1, 1000); // 1000 blocks while only alice staked
        core.setDown(true);
        vm.prank(bob);
        // Accepted today although the 1000 blocks were not priced; a fixed farm refuses it (or prices them first).
        try farm.deposit{value: 10 ether}() {} catch {}
        core.setDown(false);
        vm.prank(alice); uint256 a = farm.claim(alice);
        vm.prank(bob); uint256 b = farm.claim(bob);
        emit log_named_uint("alice", a);
        emit log_named_uint("bob", b);
        assertEq(b, 0, "bob earned emission of blocks certified before his deposit");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

contract CoreStubB {
    uint64 public genesis;
    uint64 public settled;
    uint96 public units;
    bool public down;
    mapping(uint64 => uint96) public after_;

    constructor(uint64 g) { genesis = g; }
    function setDown(bool d) external { down = d; }
    function settle(uint64 round, uint64 blocks) external {
        units += uint96(blocks) * 1e9;
        for (uint64 r = settled + 1; r <= round; ++r) after_[r] = units;
        settled = round;
    }
    function state() external view returns (ISqueekCore.CoreState memory s) {
        require(!down, "down");
        s.settledThroughRound = settled;
        s.cumulativeBlockUnits = units;
        s.blockHeight = uint64(units / 1e9);
    }
    function configuration() external view returns (ISqueekCore.CoreConfiguration memory c) {
        require(!down, "down");
        c.genesisTimestamp = genesis;
        c.roundDuration = 600;
        c.blockUnitsPerBlock = 1e9;
    }
    function roundPage(uint64 a, uint64 t, uint256) external view returns (ISqueekCore.RoundPage memory p) {
        require(!down, "down");
        require(a <= t && t <= settled, "bounds");
        p.certifiedThroughRound = t;
        p.end.cumulativeBlockUnits = after_[t];
    }
}

contract PauseForfeitTest is Test {
    uint64 constant GENESIS = 1_793_735_400;
    address owner = makeAddr("owner");
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    CoreStubB core;
    CheeseEmissionController controller;
    CheeseToken cheese;
    CheeseFarmETH farm;

    function setUp() public {
        vm.warp(GENESIS + 100 * 600 + 17);
        core = new CoreStubB(GENESIS);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, treasury, owner, address(controller));
        farm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(farm), 200);
        controller.activate();
        vm.stopPrank();
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
    }

    function test_pauseForfeit() public {
        vm.prank(alice);
        farm.deposit{value: 10 ether}();
        core.settle(core.settled() + 1, 1000);
        vm.prank(owner);
        controller.pauseEmissions();
        uint256 shares = farm.sharesOf(alice);
        vm.startPrank(alice);
        farm.withdraw(shares);
        uint256 a = farm.claim(alice);
        vm.stopPrank();
        vm.prank(owner);
        controller.unpauseEmissions();
        vm.prank(bob);
        farm.deposit{value: 1 ether}();
        emit log_named_uint("alice claimed", a);
        emit log_named_uint("forfeited", controller.forfeitedEmission());
        assertGt(a, 0, "alice lost rewards for 1000 blocks certified before the pause");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

contract CoreStubR {
    uint64 public genesis;
    uint64 public settled;
    uint96 public units;
    mapping(uint64 => uint96) public after_;

    constructor(uint64 g) { genesis = g; }
    function settle(uint64 round, uint64 blocks) external {
        units += uint96(blocks) * 1e9;
        for (uint64 r = settled + 1; r <= round; ++r) after_[r] = units;
        settled = round;
    }
    function state() external view returns (ISqueekCore.CoreState memory s) {
        s.settledThroughRound = settled;
        s.cumulativeBlockUnits = units;
        s.blockHeight = uint64(units / 1e9);
    }
    function configuration() external view returns (ISqueekCore.CoreConfiguration memory c) {
        c.genesisTimestamp = genesis;
        c.roundDuration = 600;
        c.blockUnitsPerBlock = 1e9;
    }
    function roundPage(uint64 a, uint64 t, uint256) external view returns (ISqueekCore.RoundPage memory p) {
        require(a <= t && t <= settled, "bounds");
        p.certifiedThroughRound = t;
        p.end.cumulativeBlockUnits = after_[t];
    }
}

/// MasterChef debt rounding overpays by up to 1 wei per share change; the last claimer underflows rewardReserve.
contract RewardReserveUnderflowTest is Test {
    uint64 constant GENESIS = 1_793_735_400;
    address owner = makeAddr("owner");
    address treasury = makeAddr("treasury");
    CoreStubR core;
    CheeseEmissionController controller;
    CheeseToken cheese;
    CheeseFarmETH farm;

    function setUp() public {
        vm.warp(GENESIS + 100 * 600 + 17);
        core = new CoreStubR(GENESIS);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, treasury, owner, address(controller));
        farm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(farm), 200);
        controller.activate();
        vm.stopPrank();
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
    }

    function test_lastClaimUnderflows() public {
        address[3] memory u = [makeAddr("u0"), makeAddr("u1"), makeAddr("u2")];
        uint256[6] memory amt = [
            uint256(10000000000000000000),
            999999999000000000000413,
            999999999000000000000601,
            999999999000000000006234,
            999999999000001793735401,
            999999999000000000012429
        ];
        uint64[6] memory blocks = [uint64(3), 3, 3, 1, 2, 3];
        for (uint256 i; i < 6; ++i) {
            address who = u[i % 3];
            vm.deal(who, amt[i]);
            vm.prank(who);
            farm.deposit{value: amt[i]}();
            core.settle(core.settled() + 1, blocks[i]);
        }
        // Every staker must be able to claim what the farm reports; the third claim reverts with panic 0x11.
        for (uint256 i; i < 3; ++i) {
            vm.prank(u[i]);
            farm.claim(u[i]);
        }
        assertEq(farm.rewardReserve() + farm.claimedOf(u[0]) + farm.claimedOf(u[1]) + farm.claimedOf(u[2]),
            cheese.balanceOf(address(farm)) + farm.claimedOf(u[0]) + farm.claimedOf(u[1]) + farm.claimedOf(u[2]));
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal SqueekCore double: certifies rounds and completed blocks.
contract CoreDouble {
    uint64 public genesis;
    uint64 public settled;
    uint96 public units;
    mapping(uint64 => uint96) public after_;

    constructor(uint64 g) {
        genesis = g;
    }

    function settle(uint64 round, uint64 blocks) external {
        units += uint96(blocks) * 1e9;
        for (uint64 r = settled + 1; r <= round; ++r) {
            after_[r] = units;
        }
        settled = round;
    }

    function state() external view returns (ISqueekCore.CoreState memory s) {
        s.settledThroughRound = settled;
        s.cumulativeBlockUnits = units;
        s.blockHeight = uint64(units / 1e9);
    }

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

    function roundPage(uint64 a, uint64 t, uint256) external view returns (ISqueekCore.RoundPage memory p) {
        p.certifiedThroughRound = t;
        p.start.cumulativeBlockUnits = after_[a];
        p.end.cumulativeBlockUnits = after_[t];
    }
}

/// @notice Every depositor must be able to claim the rewards pendingRewards() reports. Per-account reward
///         debt is floored (CheeseFarm._deposit / withdraw / _harvestDebt), so the sum of what accounts can
///         claim exceeds rewardReserve by a wei; the last claimer's claim() underflows `rewardReserve -= amount`
///         and reverts, permanently once emission has completed.
contract RoundingOverclaimProof is Test {
    address owner = makeAddr("owner");
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    address carol = makeAddr("carol");
    CoreDouble core;
    CheeseEmissionController controller;
    CheeseToken cheese;
    CheeseFarmETH farm;

    function setUp() public {
        uint64 genesis = 1_793_735_400;
        vm.warp(genesis + 100 * 600 + 17);
        core = new CoreDouble(genesis);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, owner, owner, address(controller));
        farm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(farm), 200);
        controller.activate();
        vm.stopPrank();
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
        vm.deal(alice, 1 ether);
        vm.deal(bob, 10 ether);
        vm.deal(carol, 1 ether);
    }

    function _advance(uint64 blocks) internal {
        core.settle(core.settled() + 1, blocks);
    }

    function test_everyDepositorCanClaimAfterEmissionEnds() public {
        vm.prank(alice);
        farm.deposit{value: 12021}();
        _advance(16);
        vm.prank(bob);
        farm.deposit{value: 2376452954}();
        _advance(1);
        vm.prank(carol);
        farm.deposit{value: 2231}();
        vm.prank(alice);
        farm.withdraw(17);
        _advance(44);
        controller.checkpoint();
        // Emission ends: no further CHEESE will ever reach the farm.
        _advance(3 * 393_470);
        controller.checkpoint();
        assertTrue(controller.completed());

        uint256 owedAlice = farm.pendingRewards(alice);
        uint256 owedBob = farm.pendingRewards(bob);
        uint256 owedCarol = farm.pendingRewards(carol);
        vm.prank(carol);
        assertEq(farm.claim(carol), owedCarol);
        vm.prank(bob);
        assertEq(farm.claim(bob), owedBob);
        // Expected: alice receives what pendingRewards reported. Actual: panic 0x11 (rewardReserve underflow).
        vm.prank(alice);
        assertEq(farm.claim(alice), owedAlice);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal SqueekCore double: certifies rounds and completed blocks.
contract CoreDouble {
    uint64 public genesis;
    bool public down;
    uint64 public settled;
    uint96 public units;
    mapping(uint64 => uint96) public after_;

    constructor(uint64 g) {
        genesis = g;
    }

    function settle(uint64 round, uint64 blocks) external {
        units += uint96(blocks) * 1e9;
        for (uint64 r = settled + 1; r <= round; ++r) {
            after_[r] = units;
        }
        settled = round;
    }

    function setDown(bool d) external {
        down = d;
    }

    function state() external view returns (ISqueekCore.CoreState memory s) {
        require(!down, "core unavailable");
        s.settledThroughRound = settled;
        s.cumulativeBlockUnits = units;
        s.blockHeight = uint64(units / 1e9);
    }

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

    function roundPage(uint64 a, uint64 t, uint256) external view returns (ISqueekCore.RoundPage memory p) {
        p.certifiedThroughRound = t;
        p.start.cumulativeBlockUnits = after_[a];
        p.end.cumulativeBlockUnits = after_[t];
    }
}

/// @notice A depositor must never receive emission for Squeek blocks certified before their deposit. While
///         SqueekCore.state() reverts, CheeseFarm._deposit still accepts deposits (only emissionsPaused closes
///         them), pullRewards' best-effort _sync silently fails, and the blocks certified before the deposit are
///         priced later and spread over the late depositor's shares too.
contract OutageRetroactiveRewardProof is Test {
    address owner = makeAddr("owner");
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    CoreDouble core;
    CheeseEmissionController controller;
    CheeseToken cheese;
    CheeseFarmETH farm;

    function setUp() public {
        uint64 genesis = 1_793_735_400;
        vm.warp(genesis + 100 * 600 + 17);
        core = new CoreDouble(genesis);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, owner, owner, address(controller));
        farm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(farm), 200);
        controller.activate();
        vm.stopPrank();
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
        vm.deal(alice, 1 ether);
        vm.deal(bob, 100 ether);
    }

    function test_lateDepositorDuringOutageGetsNoEarlierEmission() public {
        vm.prank(alice);
        farm.deposit{value: 1 ether}();
        core.settle(core.settled() + 1, 1000); // certified while alice is the only depositor
        core.setDown(true);
        // Expected: the deposit is refused (or the earlier blocks are attributed to alice alone).
        vm.prank(bob);
        try farm.deposit{value: 99 ether}() {} catch {}
        core.setDown(false);
        controller.checkpoint();
        // Expected 0 for bob; actual ~99% of the 1000 blocks' pool emission.
        assertEq(farm.pendingRewards(bob), 0, "bob earned emission from blocks before their deposit");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";
import {SqueekIssuance} from "src/libraries/SqueekIssuance.sol";

/// @dev Minimal SqueekCore double: certifies rounds, completes blocks, and can be made unreadable.
contract OutageCore is ISqueekCore {
    uint64 public genesisTimestamp;
    uint64 public settledThroughRound;
    uint96 public cumulativeBlockUnits;
    bool public unavailable;
    mapping(uint64 => uint96) public unitsAfterRound;

    constructor(uint64 genesis) {
        genesisTimestamp = genesis;
    }

    function setUnavailable(bool v) external {
        unavailable = v;
    }

    function settle(uint64 round, uint64 newBlocks) external {
        cumulativeBlockUnits += uint96(newBlocks) * 1_000_000_000;
        for (uint64 r = settledThroughRound + 1; r <= round; ++r) {
            unitsAfterRound[r] = cumulativeBlockUnits;
        }
        settledThroughRound = round;
    }

    function state() external view returns (CoreState memory r) {
        require(!unavailable, "core unavailable");
        r.settledThroughRound = settledThroughRound;
        r.cumulativeBlockUnits = cumulativeBlockUnits;
        r.blockHeight = uint64(cumulativeBlockUnits / 1_000_000_000);
    }

    function configuration() external view returns (CoreConfiguration memory r) {
        require(!unavailable, "core unavailable");
        r.genesisTimestamp = genesisTimestamp;
        r.roundDuration = 600;
        r.blockUnitsPerBlock = 1_000_000_000;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256) external view returns (RoundPage memory r) {
        require(!unavailable, "core unavailable");
        require(throughRound <= settledThroughRound, "bounds");
        r.certifiedThroughRound = throughRound;
        r.start.cumulativeBlockUnits = unitsAfterRound[afterRound];
        r.end.cumulativeBlockUnits = unitsAfterRound[throughRound];
    }

    function blockInfo(uint64) external pure returns (BlockInfo memory) {
        revert("BlockNotSettled");
    }

    function paused() external pure returns (bool) {
        return false;
    }
}

/// @notice A depositor who joins while SqueekCore is unreadable receives emission for Squeek blocks that were
///         certified before the deposit. Deposits are closed while emissions are paused (the same "sync failed"
///         condition) but not when the sync fails because the Core is unreadable or regressed.
contract DepositDuringOutageTest is Test {
    uint64 constant GENESIS = 1_793_735_400;

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

    OutageCore core;
    CheeseEmissionController controller;
    CheeseToken cheese;
    CheeseFarmETH farm;

    function setUp() public {
        vm.warp(GENESIS + 100 * 600 + 17);
        core = new OutageCore(GENESIS);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, owner, owner, address(controller));
        farm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(farm), 200);
        controller.activate();
        vm.stopPrank();
        // certify through startRound - 1 with zero completed blocks so h0 == 0
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
        assertTrue(controller.startCaptured());
        vm.deal(alice, 10 ether);
        vm.deal(bob, 10 ether);
    }

    function test_depositorJoiningDuringCoreOutageGetsNoEarlierEmission() public {
        // alice is the only staker while 10 Squeek blocks are certified
        vm.prank(alice);
        farm.deposit{value: 1 ether}();
        core.settle(core.settledThroughRound() + 1, 10);

        // the Core becomes unreadable before anyone checkpoints; bob deposits during the outage
        core.setUnavailable(true);
        vm.prank(bob);
        (bool ok,) = address(farm).call{value: 1 ether}(abi.encodeWithSignature("deposit()"));
        // whether the deposit was accepted or refused, bob must never earn from blocks 1..10

        core.setUnavailable(false);
        controller.checkpoint();

        uint256 poolEmission = (SqueekIssuance.issued(10) * 200) / 1000;
        uint256 alicePending = farm.pendingRewards(alice);
        uint256 bobPending = farm.pendingRewards(bob);
        emit log_named_uint("deposit accepted", ok ? 1 : 0);
        emit log_named_uint("alice pending", alicePending);
        emit log_named_uint("bob pending", bobPending);
        assertEq(bobPending, 0, "bob earned emission for blocks certified before his deposit");
        assertEq(alicePending, poolEmission, "alice should receive the whole pool emission for blocks 1..10");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Core double whose state() can be switched to return data the controller's ABI cannot decode
///      (an upgraded proxy with a changed CoreState layout, or a proxy whose implementation was removed).
contract ShapeShiftCore {
    uint64 public genesisTimestamp;
    uint64 public settledThroughRound;
    uint96 public cumulativeBlockUnits;
    uint8 public mode; // 0 = normal, 1 = short return data, 2 = empty return data
    mapping(uint64 => uint96) public unitsAfterRound;

    constructor(uint64 genesis) {
        genesisTimestamp = genesis;
    }

    function setMode(uint8 m) external {
        mode = m;
    }

    function settle(uint64 round, uint64 newBlocks) external {
        cumulativeBlockUnits += uint96(newBlocks) * 1_000_000_000;
        for (uint64 r = settledThroughRound + 1; r <= round; ++r) {
            unitsAfterRound[r] = cumulativeBlockUnits;
        }
        settledThroughRound = round;
    }

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

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (ISqueekCore.RoundPage memory r)
    {
        r.certifiedThroughRound = throughRound;
        r.start.cumulativeBlockUnits = unitsAfterRound[afterRound];
        r.end.cumulativeBlockUnits = unitsAfterRound[throughRound];
    }

    // state() is served by the fallback so the return shape can change after "an upgrade"
    fallback(bytes calldata) external returns (bytes memory) {
        if (mode == 1) return abi.encode(uint256(1), uint256(2)); // 2 words, the decoder needs 8
        if (mode == 2) return "";
        ISqueekCore.CoreState memory s;
        s.settledThroughRound = settledThroughRound;
        s.cumulativeBlockUnits = cumulativeBlockUnits;
        s.blockHeight = uint64(cumulativeBlockUnits / 1_000_000_000);
        return abi.encode(s);
    }
}

/// @notice `_sync` catches reverts from SqueekCore but not return-data decoding failures; those propagate out of
///         pullRewards and block every farm withdraw and claim until the owner pauses emissions.
contract MalformedCoreTest is Test {
    uint64 constant GENESIS = 1_793_735_400;
    address owner = makeAddr("owner");
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");

    ShapeShiftCore core;
    CheeseEmissionController controller;
    CheeseToken cheese;
    CheeseFarmETH farm;

    function setUp() public {
        vm.warp(GENESIS + 100 * 600 + 17);
        core = new ShapeShiftCore(GENESIS);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, owner, owner, address(controller));
        farm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(farm), 200);
        controller.activate();
        vm.stopPrank();
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
        assertTrue(controller.startCaptured());
        vm.deal(alice, 10 ether);
        vm.prank(alice);
        farm.deposit{value: 1 ether}();
    }

    function test_shortReturnData_withdrawStillWorks() public {
        core.setMode(1);
        uint256 half = farm.sharesOf(alice) / 2;
        vm.prank(alice);
        farm.withdraw(half);
    }

    function test_emptyReturnData_withdrawStillWorks() public {
        core.setMode(2);
        uint256 half = farm.sharesOf(alice) / 2;
        vm.prank(alice);
        farm.withdraw(half);
    }

    function test_coreWithoutCode_withdrawAndClaimStillWork() public {
        vm.etch(address(core), "");
        uint256 half = farm.sharesOf(alice) / 2;
        vm.prank(alice);
        farm.withdraw(half);
        vm.prank(alice);
        farm.claim(alice);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal SqueekCore double: certifies rounds and completes blocks.
contract TinyCore is ISqueekCore {
    uint64 public genesisTimestamp;
    uint64 public settledThroughRound;
    uint96 public cumulativeBlockUnits;
    mapping(uint64 => uint96) public unitsAfterRound;

    constructor(uint64 genesis) {
        genesisTimestamp = genesis;
    }

    function settle(uint64 round, uint64 newBlocks) external {
        cumulativeBlockUnits += uint96(newBlocks) * 1_000_000_000;
        for (uint64 r = settledThroughRound + 1; r <= round; ++r) {
            unitsAfterRound[r] = cumulativeBlockUnits;
        }
        settledThroughRound = round;
    }

    function state() external view returns (CoreState memory result) {
        result.settledThroughRound = settledThroughRound;
        result.cumulativeBlockUnits = cumulativeBlockUnits;
        result.blockHeight = uint64(cumulativeBlockUnits / 1_000_000_000);
    }

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

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (RoundPage memory result)
    {
        result.certifiedThroughRound = throughRound;
        result.start.cumulativeBlockUnits = unitsAfterRound[afterRound];
        result.end.cumulativeBlockUnits = unitsAfterRound[throughRound];
    }

    function blockInfo(uint64) external pure returns (BlockInfo memory) {
        revert("BlockNotSettled");
    }

    function paused() external pure returns (bool) {
        return false;
    }
}

/// @notice A 1-wei first depositor makes `accRewardPerShare` grow by amount * 1e36 / 1000 per pull.
///         After one Squeek round the ETH farm refuses every deposit of a few ETH: `sharesOf * accRewardPerShare`
///         in CheeseFarm._deposit overflows uint256 and reverts. The accumulator never decreases, so the farm
///         is permanently unusable for ordinary deposits. Fails on the current code; passes once the
///         share * accumulator products use a 512-bit mulDiv (or ACC_PRECISION is lowered).
contract AccOverflowTest is Test {
    uint64 internal constant GENESIS = 1_793_735_400;

    address internal owner = makeAddr("owner");
    address internal treasury = makeAddr("treasury");
    address internal attacker = makeAddr("attacker");
    address internal victim = makeAddr("victim");

    TinyCore internal core;
    CheeseEmissionController internal controller;
    CheeseToken internal cheese;
    CheeseFarmETH internal ethFarm;

    function setUp() public {
        vm.warp(GENESIS + 100 * 600 + 17);
        core = new TinyCore(GENESIS);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, owner, owner, address(controller));
        ethFarm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(ethFarm), 200);
        controller.activate();
        vm.stopPrank();
        // certify through startRound - 1 with zero blocks so h0 == 0
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
        assertTrue(controller.startCaptured());
        vm.deal(attacker, 1 ether);
        vm.deal(victim, 100 ether);
    }

    function test_oneWeiFirstDepositorBricksDepositsAfterOneRound() public {
        // 1. attacker is the first depositor with 1 wei -> 1000 shares
        vm.prank(attacker);
        ethFarm.deposit{value: 1}();
        assertEq(ethFarm.totalShares(), 1000);

        // 2. one Squeek round of 40 blocks is certified (about ten minutes)
        core.settle(core.settledThroughRound() + 1, 40);

        // 3. the victim deposits 10 ETH. Expected: shares minted, deposit accepted.
        //    Actual: arithmetic overflow in `sharesOf[msg.sender] * accRewardPerShare` (panic 0x11).
        vm.prank(victim);
        uint256 shares = ethFarm.deposit{value: 10 ether}();
        assertGt(shares, 0, "victim should receive shares");
        assertEq(ethFarm.totalAssets(), 10 ether + 1);
    }

    function test_thresholdDropsWithEveryRound() public {
        vm.prank(attacker);
        ethFarm.deposit{value: 1}();
        // 24 rounds (~4 hours) with the 1-wei staker alone
        for (uint256 i; i < 24; ++i) {
            core.settle(core.settledThroughRound() + 1, 40);
            controller.checkpoint();
        }
        // even 0.5 ETH is refused now
        vm.prank(victim);
        uint256 shares = ethFarm.deposit{value: 0.5 ether}();
        assertGt(shares, 0, "0.5 ETH deposit should succeed");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal SqueekCore double: certifies rounds and completes blocks.
contract TinyCore is ISqueekCore {
    uint64 public genesisTimestamp;
    uint64 public settledThroughRound;
    uint96 public cumulativeBlockUnits;
    mapping(uint64 => uint96) public unitsAfterRound;

    constructor(uint64 genesis) {
        genesisTimestamp = genesis;
    }

    function settle(uint64 round, uint64 newBlocks) external {
        cumulativeBlockUnits += uint96(newBlocks) * 1_000_000_000;
        for (uint64 r = settledThroughRound + 1; r <= round; ++r) {
            unitsAfterRound[r] = cumulativeBlockUnits;
        }
        settledThroughRound = round;
    }

    function state() external view returns (CoreState memory result) {
        result.settledThroughRound = settledThroughRound;
        result.cumulativeBlockUnits = cumulativeBlockUnits;
        result.blockHeight = uint64(cumulativeBlockUnits / 1_000_000_000);
    }

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

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (RoundPage memory result)
    {
        result.certifiedThroughRound = throughRound;
        result.start.cumulativeBlockUnits = unitsAfterRound[afterRound];
        result.end.cumulativeBlockUnits = unitsAfterRound[throughRound];
    }

    function blockInfo(uint64) external pure returns (BlockInfo memory) {
        revert("BlockNotSettled");
    }

    function paused() external pure returns (bool) {
        return false;
    }
}

/// @notice A 1-wei first depositor makes `accRewardPerShare` grow by amount * 1e36 / 1000 per pull.
///         After one Squeek round the ETH farm refuses every deposit of a few ETH: `sharesOf * accRewardPerShare`
///         in CheeseFarm._deposit overflows uint256 and reverts. The accumulator never decreases, so the farm
///         is permanently unusable for ordinary deposits. Fails on the current code; passes once the
///         share * accumulator products use a 512-bit mulDiv (or ACC_PRECISION is lowered).
contract AccOverflowTest is Test {
    uint64 internal constant GENESIS = 1_793_735_400;

    address internal owner = makeAddr("owner");
    address internal treasury = makeAddr("treasury");
    address internal attacker = makeAddr("attacker");
    address internal victim = makeAddr("victim");

    TinyCore internal core;
    CheeseEmissionController internal controller;
    CheeseToken internal cheese;
    CheeseFarmETH internal ethFarm;

    function setUp() public {
        vm.warp(GENESIS + 100 * 600 + 17);
        core = new TinyCore(GENESIS);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, owner, owner, address(controller));
        ethFarm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(ethFarm), 200);
        controller.activate();
        vm.stopPrank();
        // certify through startRound - 1 with zero blocks so h0 == 0
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
        assertTrue(controller.startCaptured());
        vm.deal(attacker, 1 ether);
        vm.deal(victim, 100 ether);
    }

    function test_oneWeiFirstDepositorBricksDepositsAfterOneRound() public {
        // 1. attacker is the first depositor with 1 wei -> 1000 shares
        vm.prank(attacker);
        ethFarm.deposit{value: 1}();
        assertEq(ethFarm.totalShares(), 1000);

        // 2. one Squeek round of 40 blocks is certified (about ten minutes)
        core.settle(core.settledThroughRound() + 1, 40);

        // 3. the victim deposits 10 ETH. Expected: shares minted, deposit accepted.
        //    Actual: arithmetic overflow in `sharesOf[msg.sender] * accRewardPerShare` (panic 0x11).
        vm.prank(victim);
        uint256 shares = ethFarm.deposit{value: 10 ether}();
        assertGt(shares, 0, "victim should receive shares");
        assertEq(ethFarm.totalAssets(), 10 ether + 1);
    }

    function test_thresholdDropsWithEveryRound() public {
        vm.prank(attacker);
        ethFarm.deposit{value: 1}();
        // 24 rounds (~4 hours) with the 1-wei staker alone
        for (uint256 i; i < 24; ++i) {
            core.settle(core.settledThroughRound() + 1, 40);
            controller.checkpoint();
        }
        // even 0.5 ETH is refused now
        vm.prank(victim);
        uint256 shares = ethFarm.deposit{value: 0.5 ether}();
        assertGt(shares, 0, "0.5 ETH deposit should succeed");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

contract OverdraftCore is ISqueekCore {
    uint64 public genesisTimestamp;
    uint64 public settledThroughRound;
    uint96 public cumulativeBlockUnits;
    mapping(uint64 => uint96) public unitsAfterRound;

    constructor(uint64 genesis) {
        genesisTimestamp = genesis;
    }

    function settle(uint64 round, uint64 newBlocks) external {
        cumulativeBlockUnits += uint96(newBlocks) * 1_000_000_000;
        for (uint64 r = settledThroughRound + 1; r <= round; ++r) {
            unitsAfterRound[r] = cumulativeBlockUnits;
        }
        settledThroughRound = round;
    }

    function state() external view returns (CoreState memory result) {
        result.settledThroughRound = settledThroughRound;
        result.cumulativeBlockUnits = cumulativeBlockUnits;
        result.blockHeight = uint64(cumulativeBlockUnits / 1_000_000_000);
    }

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

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (RoundPage memory result)
    {
        result.certifiedThroughRound = throughRound;
        result.start.cumulativeBlockUnits = unitsAfterRound[afterRound];
        result.end.cumulativeBlockUnits = unitsAfterRound[throughRound];
    }

    function blockInfo(uint64) external pure returns (BlockInfo memory) {
        revert("BlockNotSettled");
    }

    function paused() external pure returns (bool) {
        return false;
    }
}

/// @notice Floored per-account reward debts let accounts jointly earn more than the farm pulled. Once emission
///         has completed nothing refills rewardReserve, so the last claimer's whole claim reverts forever.
///         Fails on the current code with panic 0x11 at `rewardReserve -= amount`; passes once the sum of
///         harvested rewards can no longer exceed the reserve (or the payout is clamped to it).
contract RewardOverdraftTest is Test {
    uint64 internal constant GENESIS = 1_793_735_400;
    address internal owner = makeAddr("owner");
    address internal treasury = makeAddr("treasury");
    OverdraftCore internal core;
    CheeseEmissionController internal controller;
    CheeseToken internal cheese;
    CheeseFarmETH internal farm;
    address[5] internal users;

    function setUp() public {
        vm.warp(GENESIS + 100 * 600 + 17);
        core = new OverdraftCore(GENESIS);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, owner, owner, address(controller));
        farm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(farm), 200);
        controller.activate();
        vm.stopPrank();
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
        users = [makeAddr("u0"), makeAddr("u1"), makeAddr("u2"), makeAddr("u3"), makeAddr("u4")];
        for (uint256 i; i < 5; ++i) {
            vm.deal(users[i], 1000 ether);
        }
    }

    /// Twelve ordinary deposits of 0.01 to 5 ETH by five accounts, 1 to 80 blocks apart, no dust and no withdrawal.
    function test_everyAccountCanClaimAfterEmissionEnds() public {
        for (uint256 k; k < 12; ++k) {
            uint256 r = uint256(keccak256(abi.encode(SEED, k)));
            vm.prank(users[r % 5]);
            farm.deposit{value: 0.01 ether + (r >> 16) % 5 ether}();
            core.settle(core.settledThroughRound() + 1, uint64(1 + (r >> 200) % 80));
        }
        core.settle(core.settledThroughRound() + 1, 3 * 393_470);
        controller.checkpoint();
        assertTrue(controller.completed(), "emission completed");
        for (uint256 i; i < 5; ++i) {
            uint256 pending = farm.pendingRewards(users[i]);
            vm.prank(users[i]);
            uint256 paid = farm.claim(users[i]); // reverts with panic 0x11 for the account left short
            // A fix that clamps may leave the rounding dust unpaid, nothing more.
            assertApproxEqAbs(paid, pending, 16, "claim pays what pendingRewards reports");
        }
    }

    uint256 internal constant SEED = 13;
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";

contract RefusesEth {
    receive() external payable {
        revert("no ETH");
    }
}

/// @notice The owner can freeze all ETH-farm principal: withdraw pushes the Treasury's cut first and reverts the
///         whole withdrawal when that push fails. With ownership renounced the freeze cannot be undone.
///         Fails on the current code with NativeTransferFailed; passes once a failed Treasury payment no longer
///         blocks the withdrawer (for example a pull balance for the Treasury).
contract TreasuryFreezeTest is Test {
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("alice");
    CheeseEmissionController internal controller;
    CheeseFarmETH internal farm;

    function setUp() public {
        // No Core read happens before activate(), so any non-zero address serves.
        controller = new CheeseEmissionController(owner, address(0xC0DE), makeAddr("treasury"));
        farm = new CheeseFarmETH(owner, address(controller));
        vm.deal(alice, 10 ether);
    }

    function test_ownerCannotFreezePrincipalThroughTreasury() public {
        vm.prank(alice);
        farm.deposit{value: 10 ether}();

        RefusesEth bad = new RefusesEth();
        vm.startPrank(owner);
        controller.setTreasury(address(bad));
        controller.renounceOwnership();
        vm.stopPrank();

        uint256 shares = farm.sharesOf(alice);
        vm.prank(alice);
        uint256 paid = farm.withdraw(shares);
        assertEq(paid, 8.5 ether, "85% paid");
        assertEq(alice.balance, 8.5 ether, "alice received her 85%");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

contract CoreStubA {
    uint64 public genesis;
    uint64 public settled;
    uint96 public units;
    bool public down;
    mapping(uint64 => uint96) public after_;

    constructor(uint64 g) { genesis = g; }
    function setDown(bool d) external { down = d; }
    function settle(uint64 round, uint64 blocks) external {
        units += uint96(blocks) * 1e9;
        for (uint64 r = settled + 1; r <= round; ++r) after_[r] = units;
        settled = round;
    }
    function state() external view returns (ISqueekCore.CoreState memory s) {
        require(!down, "down");
        s.settledThroughRound = settled;
        s.cumulativeBlockUnits = units;
        s.blockHeight = uint64(units / 1e9);
    }
    function configuration() external view returns (ISqueekCore.CoreConfiguration memory c) {
        require(!down, "down");
        c.genesisTimestamp = genesis;
        c.roundDuration = 600;
        c.blockUnitsPerBlock = 1e9;
    }
    function roundPage(uint64 a, uint64 t, uint256) external view returns (ISqueekCore.RoundPage memory p) {
        require(!down, "down");
        require(a <= t && t <= settled, "bounds");
        p.certifiedThroughRound = t;
        p.end.cumulativeBlockUnits = after_[t];
    }
}

contract OutageDepositTest is Test {
    uint64 constant GENESIS = 1_793_735_400;
    address owner = makeAddr("owner");
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    CoreStubA core;
    CheeseEmissionController controller;
    CheeseToken cheese;
    CheeseFarmETH farm;

    function setUp() public {
        vm.warp(GENESIS + 100 * 600 + 17);
        core = new CoreStubA(GENESIS);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, treasury, owner, address(controller));
        farm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(farm), 200);
        controller.activate();
        vm.stopPrank();
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
    }

    function test_outageDeposit() public {
        vm.prank(alice);
        farm.deposit{value: 10 ether}();
        core.settle(core.settled() + 1, 1000); // 1000 blocks while only alice staked
        core.setDown(true);
        vm.prank(bob);
        // Accepted today although the 1000 blocks were not priced; a fixed farm refuses it (or prices them first).
        try farm.deposit{value: 10 ether}() {} catch {}
        core.setDown(false);
        vm.prank(alice); uint256 a = farm.claim(alice);
        vm.prank(bob); uint256 b = farm.claim(bob);
        emit log_named_uint("alice", a);
        emit log_named_uint("bob", b);
        assertEq(b, 0, "bob earned emission of blocks certified before his deposit");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @dev SqueekCore stand-in with the live ABI. `bombBytes != 0` simulates a broken or compromised Core upgrade
///      whose state() returns that many bytes of zeroes.
contract CoreDouble {
    uint64 internal genesis;
    uint64 internal settled;
    uint96 internal units;
    uint256 internal bombBytes;

    constructor(uint64 genesis_) {
        genesis = genesis_;
    }

    function settle(uint64 round, uint64 blocks) external {
        settled = round;
        units = uint96(blocks) * 1e9;
    }

    function bomb(uint256 bytes_) external {
        bombBytes = bytes_;
    }

    function state() external view returns (ISqueekCore.CoreState memory s) {
        uint256 b = bombBytes;
        if (b != 0) {
            assembly {
                return(0, b)
            }
        }
        s.settledThroughRound = settled;
        s.cumulativeBlockUnits = units;
        s.blockHeight = uint64(units / 1e9);
    }

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

    function roundPage(uint64, uint64 through, uint256) external view returns (ISqueekCore.RoundPage memory p) {
        p.certifiedThroughRound = through;
        p.end.cumulativeBlockUnits = units;
    }
}

/// @notice A SqueekCore whose state() returns a very large payload makes the controller's raw staticcall copy
///         all of it into memory, and the quadratic memory cost exhausts the 1/64 of gas the caller kept. Every
///         path that syncs then runs out of gas: withdraw, claim, checkpoint and, since the revision that syncs
///         first, pauseEmissions too, so the guardian's emergency pause no longer frees principal.
contract ReturnBombTest is Test {
    address owner = makeAddr("owner");
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");
    CoreDouble core;
    CheeseEmissionController controller;
    CheeseFarmETH ethFarm;

    function setUp() public {
        uint64 genesis = 1_793_735_400;
        vm.warp(genesis + 100 * 600 + 17);
        core = new CoreDouble(genesis);
        vm.startPrank(owner);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        CheeseToken token = new CheeseToken(owner, treasury, owner, address(controller));
        ethFarm = new CheeseFarmETH(owner, address(controller));
        controller.bindToken(address(token));
        controller.addPool(address(ethFarm), 200);
        controller.activate();
        vm.stopPrank();
        uint64 start = controller.startRound();
        core.settle(start - 1, 0);
        controller.checkpoint();
        vm.deal(alice, 10 ether);
        vm.prank(alice);
        ethFarm.deposit{value: 1 ether}();
        core.settle(start, 10);
        controller.checkpoint();
        // Core now answers state() with 2 MiB of zeroes.
        core.bomb(2 << 20);
    }

    /// @dev Fails today (OutOfGas inside the withdrawal); passes once the Core read copies at most the expected
    ///      CORE_STATE_BYTES of return data (bounded returndatacopy) and treats any other size as unavailable.
    function test_withdrawSurvivesReturnBombingCore() public {
        uint256 shares = ethFarm.sharesOf(alice);
        uint256 before = alice.balance;
        vm.prank(alice);
        ethFarm.withdraw{gas: 30_000_000}(shares);
        assertEq(alice.balance - before, 0.85 ether, "85% of principal returned");
    }

    /// @dev The emergency stop must not depend on SqueekCore behaving.
    function test_guardianPauseSurvivesReturnBombingCore() public {
        vm.prank(owner);
        controller.pauseEmissions{gas: 30_000_000}();
        assertTrue(controller.emissionsPaused());
    }
}

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

import {Test} from "forge-std/Test.sol";
import {CheeseToken} from "src/CheeseToken.sol";
import {CheeseEmissionController} from "src/CheeseEmissionController.sol";
import {CheeseFarmETH} from "src/farms/CheeseFarmETH.sol";
import {ISqueekCore} from "src/interfaces/ISqueekCore.sol";

/// @notice Minimal SqueekCore double: certifies rounds and completes blocks.
contract CoreDouble is ISqueekCore {
    uint64 public genesisTimestamp;
    uint64 public settledThroughRound;
    uint96 public cumulativeBlockUnits;
    mapping(uint64 => uint96) public unitsAfterRound;

    constructor(uint64 genesis) {
        genesisTimestamp = genesis;
    }

    function settle(uint64 round, uint64 newBlocks) external {
        cumulativeBlockUnits += uint96(newBlocks) * 1_000_000_000;
        for (uint64 r = settledThroughRound + 1; r <= round; ++r) {
            unitsAfterRound[r] = cumulativeBlockUnits;
        }
        settledThroughRound = round;
    }

    function state() external view returns (CoreState memory result) {
        result.settledThroughRound = settledThroughRound;
        result.cumulativeBlockUnits = cumulativeBlockUnits;
        result.blockHeight = uint64(cumulativeBlockUnits / 1_000_000_000);
    }

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

    function roundPage(uint64 afterRound, uint64 throughRound, uint256) external view returns (RoundPage memory result) {
        result.certifiedThroughRound = throughRound;
        result.start.cumulativeBlockUnits = unitsAfterRound[afterRound];
        result.end.cumulativeBlockUnits = unitsAfterRound[throughRound];
    }

    function blockInfo(uint64) external pure returns (BlockInfo memory) {
        revert();
    }

    function paused() external pure returns (bool) {
        return false;
    }
}

/// @notice A SqueekCore whose every call expands memory to 2 MiB, burns the forwarded gas down to ~65k and then
///         returns the whole 2 MiB. The caller keeps 1/64 of its gas and must copy 2 MiB of return data (~8.6M
///         gas), so it runs out of gas however much the transaction supplies.
///
///         Bytecode: PUSH1 0 PUSH3 0x1FFFE0 MSTORE | JUMPDEST GAS PUSH3 0xFFFF LT PUSH1 7 JUMPI |
///                   PUSH3 0x200000 PUSH1 0 RETURN
contract ReturnBombCoreTest is Test {
    uint64 internal constant GENESIS = 1_793_735_400;
    bytes internal constant BOMB = hex"6000621fffe0525b5a6200ffff10600757622000006000f3";

    address internal owner = makeAddr("owner");
    address internal treasury = makeAddr("treasury");
    address internal alice = makeAddr("alice");

    CoreDouble internal core;
    CheeseEmissionController internal controller;
    CheeseToken internal cheese;
    CheeseFarmETH internal farm;

    function setUp() public {
        vm.warp(GENESIS + 100 * 600 + 17);
        core = new CoreDouble(GENESIS);
        controller = new CheeseEmissionController(owner, address(core), treasury);
        cheese = new CheeseToken(owner, owner, owner, address(controller));
        farm = new CheeseFarmETH(owner, address(controller));
        vm.startPrank(owner);
        controller.bindToken(address(cheese));
        controller.addPool(address(farm), 200);
        controller.activate();
        vm.stopPrank();
        core.settle(controller.startRound() - 1, 0);
        controller.checkpoint();
        assertTrue(controller.startCaptured());

        vm.deal(alice, 10 ether);
        vm.prank(alice);
        farm.deposit{value: 1 ether}();
        core.settle(core.settledThroughRound() + 1, 10);
        controller.checkpoint();
        assertGt(farm.pendingRewards(alice), 0);
    }

    function test_returnBombCoreDoesNotBlockWithdrawClaimOrPause() public {
        vm.etch(address(core), BOMB);

        // Sanity: a bare call to the bomb succeeds when the caller can afford the copy but burns the gas.
        (bool ok, bytes memory data) = address(core).staticcall{gas: 20_000_000}(abi.encodeCall(ISqueekCore.state, ()));
        assertTrue(ok);
        assertEq(data.length, 0x200000);

        // The brief: Squeekchain unavailability must never block withdrawals; owner emergency procedures work.
        uint256 shares = farm.sharesOf(alice);
        vm.prank(alice);
        uint256 paid = farm.withdraw{gas: 30_000_000}(shares);
        assertEq(paid, 0.85 ether, "85% of principal paid");

        vm.prank(alice);
        uint256 claimed = farm.claim{gas: 30_000_000}(alice);
        assertGt(claimed, 0, "accrued rewards claimable");

        vm.prank(owner);
        controller.pauseEmissions{gas: 30_000_000}();
        assertTrue(controller.emissionsPaused(), "emergency pause works");
    }
}