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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";

import {HamsterMiningReserve} from "src/HamsterMiningReserve.sol";

/// @notice Minimal stand-ins (self-contained; nothing imported from other test files).
contract PSQK is ERC20 {
    constructor() ERC20("SQK", "SQK") {}

    function mint(address to, uint256 a) external {
        _mint(to, a);
    }
}

contract PCore {
    function implementationCodeVersion() external pure returns (uint256) {
        return 3;
    }
}

contract PEmission {
    function implementationCodeVersion() external pure returns (uint256) {
        return 9;
    }

    function checkpoint() external {}

    function checkpointStatus() external pure returns (bool, uint64, bool) {
        return (false, 1, true);
    }
}

contract PNft is ERC721 {
    uint256 public constant MAXIMUM_LEVEL = 10;
    address public mining;
    address public sqkCore;
    uint256 public next = 1;
    mapping(uint256 => uint256) public level;

    constructor(address m, address c) ERC721("Squeek", "SQUEEK") {
        mining = m;
        sqkCore = c;
    }

    function mint(address to) external returns (uint256 id) {
        id = next++;
        level[id] = 1;
        _mint(to, id);
    }

    function merge(uint256 survivor, uint256 donor) external {
        require(ownerOf(survivor) == msg.sender && ownerOf(donor) == msg.sender);
        require(level[survivor] == level[donor]);
        _burn(donor);
        level[survivor] += 1;
    }
}

/// @dev Staking stand-in: per-account power, claimable SQK, and a switch that makes `claim`
///      revert (an upstream pause / outage of the reward path).
contract PStaking is IERC721Receiver {
    PNft public immutable genesisNft;
    PSQK public immutable sqk;
    address public mining;
    bool public claimPaused;
    mapping(address => uint256) public accountPower;
    mapping(address => uint256) public claimable;
    mapping(uint256 => address) public stakerOf;

    constructor(PNft n, PSQK s, address m) {
        genesisNft = n;
        sqk = s;
        mining = m;
    }

    function genesis() external view returns (address) {
        return address(genesisNft);
    }

    function token() external view returns (address) {
        return address(sqk);
    }

    function setClaimPaused(bool v) external {
        claimPaused = v;
    }

    /// @notice Emission credits `account` with SQK (accrued by its power).
    function fund(address account, uint256 amount) external {
        sqk.mint(address(this), amount);
        claimable[account] += amount;
    }

    function powerOf(uint256 lvl) public pure returns (uint256) {
        return lvl == 1 ? 1000e18 : 2200e18;
    }

    function deposit(address, uint256[] calldata ids) external {
        for (uint256 i; i < ids.length; ++i) {
            genesisNft.transferFrom(msg.sender, address(this), ids[i]);
            stakerOf[ids[i]] = msg.sender;
            accountPower[msg.sender] += powerOf(genesisNft.level(ids[i]));
        }
    }

    function withdraw(address, uint256[] calldata ids) external {
        for (uint256 i; i < ids.length; ++i) {
            require(stakerOf[ids[i]] == msg.sender);
            delete stakerOf[ids[i]];
            accountPower[msg.sender] -= powerOf(genesisNft.level(ids[i]));
            genesisNft.safeTransferFrom(address(this), msg.sender, ids[i]);
        }
    }

    function claim(address account) external returns (uint256 amount) {
        require(!claimPaused, "staking: paused");
        amount = claimable[account];
        if (amount == 0) return 0;
        claimable[account] = 0;
        sqk.transfer(account, amount);
    }

    function onERC721Received(address, address, uint256, bytes calldata) external pure returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }
}

/// @title Unsettled rewards are shared with a depositor who entered while `staking.claim` reverted.
/// @dev The brief's guarantee: "Settle-before-every-balance-change ... so no deposit/transfer can snipe
///      unsettled rewards". `_settle()` swallows a reverting `staking.claim`, so `deposit` mints shares
///      without having settled, and the SQK that accrued entirely before the deposit is later split by the
///      post-deposit supply.
contract UnsettledRewardSnipeTest is Test {
    address owner = makeAddr("owner");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    PSQK sqk;
    PCore core;
    PEmission emission;
    PNft nft;
    PStaking staking;
    HamsterMiningReserve vault;

    function setUp() public {
        sqk = new PSQK();
        core = new PCore();
        emission = new PEmission();
        nft = new PNft(address(emission), address(core));
        staking = new PStaking(nft, sqk, address(emission));
        vault = new HamsterMiningReserve(
            owner, address(nft), address(staking), address(emission), address(core), address(sqk)
        );
        vm.prank(alice);
        nft.setApprovalForAll(address(vault), true);
        vm.prank(bob);
        nft.setApprovalForAll(address(vault), true);
    }

    function _one(uint256 a) internal pure returns (uint256[] memory ids) {
        ids = new uint256[](1);
        ids[0] = a;
    }

    function test_depositDuringClaimOutageCannotTakeEarlierRewards() public {
        // 1. Alice is the only holder: 1 L1 -> 1000e18 shares.
        uint256 a = nft.mint(alice);
        vm.prank(alice);
        vault.deposit(_one(a));

        // 2. 90 SQK accrue to the vault's staking account while alice is the sole holder.
        staking.fund(address(vault), 90e18);

        // 3. The upstream claim path is down (reverts). The vault's `_settle` swallows this.
        staking.setClaimPaused(true);

        // 4. Bob deposits two L1s (2000e18 power) during the outage.
        uint256 b1 = nft.mint(bob);
        uint256 b2 = nft.mint(bob);
        uint256[] memory bids = new uint256[](2);
        bids[0] = b1;
        bids[1] = b2;
        vm.prank(bob);
        bool bobEntered;
        try vault.deposit(bids) {
            bobEntered = true;
        } catch {
            // A fixed vault may instead refuse to change balances while it cannot settle. Acceptable.
            bobEntered = false;
        }

        // 5. Claim path comes back; anyone harvests.
        staking.setClaimPaused(false);
        vault.harvest();

        // Everything that accrued before bob's deposit belongs to alice. Bob must get none of it.
        assertEq(vault.pendingRewards(alice), 90e18, "alice must keep the 90 SQK that accrued before bob");
        if (bobEntered) {
            assertEq(vault.pendingRewards(bob), 0, "bob must not receive rewards accrued before his deposit");
        }
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";

import {HamsterMiningReserve} from "src/HamsterMiningReserve.sol";

/// @notice Proof for: `_settle()` wraps `staking.claim(address(this))` in try/catch but declares
///         `returns (uint256)`. Solidity decodes the return data outside the catch, so a staking
///         implementation whose `claim` returns no data (a legitimate upgrade of the unverified
///         Squeekchain proxy) makes `_settle` revert, and with it deposit, transfer, transferFrom,
///         claimRewards, harvest, poke and mergeStep. SQK already inside the vault becomes
///         unreachable. README states that a broken `claim` never blocks claims of received SQK.
///
///         Fails on the current code (harvest / claimRewards / transfer revert with empty data).
///         Passes once `_settle` ignores the return data of `claim` (e.g. a raw `call` or a
///         `try` without a `returns` clause).
contract SQK is ERC20 {
    constructor() ERC20("SQK", "SQK") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

contract Squeek is ERC721 {
    mapping(uint256 => uint256) public level;

    constructor() ERC721("Squeek", "SQUEEK") {}

    function mint(address to, uint256 id) external {
        level[id] = 1;
        _mint(to, id);
    }
}

contract Emission {
    function checkpoint() external {}
}

/// @dev Staking surface whose `claim(address)` returns nothing. Everything else behaves like v9.
contract VoidClaimStaking {
    Squeek public immutable nft;
    SQK public immutable sqk;
    mapping(address => uint256) public accountPower;
    mapping(address => uint256) public claimable;

    constructor(Squeek nft_, SQK sqk_) {
        nft = nft_;
        sqk = sqk_;
    }

    function deposit(address, uint256[] calldata ids) external {
        for (uint256 i; i < ids.length; ++i) {
            nft.transferFrom(msg.sender, address(this), ids[i]);
            accountPower[msg.sender] += 1000e18;
        }
    }

    function withdraw(address, uint256[] calldata) external {}

    function fund(address account, uint256 amount) external {
        sqk.mint(address(this), amount);
        claimable[account] += amount;
    }

    /// @dev Pays accrued SQK but returns no value.
    function claim(address account) external {
        uint256 amount = claimable[account];
        if (amount == 0) return;
        claimable[account] = 0;
        sqk.transfer(account, amount);
    }
}

contract VoidClaimBricksSettleTest is Test {
    address owner = makeAddr("owner");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    SQK sqk;
    Squeek nft;
    Emission emission;
    VoidClaimStaking staking;
    HamsterMiningReserve vault;

    function setUp() public {
        sqk = new SQK();
        nft = new Squeek();
        emission = new Emission();
        staking = new VoidClaimStaking(nft, sqk);
        vault = new HamsterMiningReserve(
            owner, address(nft), address(staking), address(emission), address(0xC0DE), address(sqk)
        );
        nft.mint(alice, 1);
        vm.prank(alice);
        nft.setApprovalForAll(address(vault), true);
    }

    function test_voidClaimDoesNotBlockVault() public {
        // The first deposit already runs _settle(); with a void-returning claim it must still work.
        uint256[] memory ids = new uint256[](1);
        ids[0] = 1;
        vm.prank(alice);
        vault.deposit(ids);
        assertEq(vault.balanceOf(alice), 1000e18);

        // Rewards accrue and are pulled in by the vault on settle.
        staking.fund(address(vault), 10e18);
        vault.harvest();

        // Holder can still claim what the vault received, and still exit by transfer.
        vm.prank(alice);
        uint256 paid = vault.claimRewards();
        assertEq(paid, 10e18);
        assertEq(sqk.balanceOf(alice), 10e18);

        vm.prank(alice);
        vault.transfer(bob, 1000e18);
        assertEq(vault.balanceOf(bob), 1000e18);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {HamsterMiningReserve} from "src/HamsterMiningReserve.sol";

// Minimal deterministic graph, without forks, storage edits or imports from other tests.
contract DeferredRewardToken {
    mapping(address => uint256) public balanceOf;
    function mint(address to, uint256 amount) external { balanceOf[to] += amount; }
    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract DeferredRewardNFT {
    mapping(uint256 => address) public ownerOf;
    mapping(address => mapping(address => bool)) public isApprovedForAll;
    function mint(address to, uint256 id) external { ownerOf[id] = to; }
    function setApprovalForAll(address operator, bool approved) external {
        isApprovedForAll[msg.sender][operator] = approved;
    }
    function transferFrom(address from, address to, uint256 id) external {
        require(ownerOf[id] == from, "owner");
        require(msg.sender == from || isApprovedForAll[from][msg.sender], "approval");
        ownerOf[id] = to;
    }
}

contract DeferredRewardEmission {
    function checkpoint() external {}
}

contract DeferredRewardStaking {
    DeferredRewardNFT public immutable nft;
    DeferredRewardToken public immutable token;
    mapping(address => uint256) public accountPower;
    mapping(address => uint256) public claimable;
    bool public unavailable;
    constructor(DeferredRewardNFT n, DeferredRewardToken t) { nft = n; token = t; }
    function deposit(address collection, uint256[] calldata ids) external {
        require(collection == address(nft), "collection");
        for (uint256 i; i < ids.length; ++i) {
            nft.transferFrom(msg.sender, address(this), ids[i]);
            accountPower[msg.sender] += 1000e18;
        }
    }
    function accrue(address account, uint256 amount) external {
        token.mint(address(this), amount);
        claimable[account] += amount;
    }
    function setUnavailable(bool value) external { unavailable = value; }
    function claim(address account) external returns (uint256 amount) {
        require(!unavailable, "temporary claim outage");
        amount = claimable[account];
        claimable[account] = 0;
        token.transfer(account, amount);
    }
}

contract DeferredRewardsProof is Test {
    HamsterMiningReserve vault;
    DeferredRewardToken token;
    DeferredRewardNFT nft;
    DeferredRewardStaking staking;
    address alice;
    address bob;

    function setUp() public {
        alice = makeAddr("original holder");
        bob = makeAddr("new holder");
        nft = new DeferredRewardNFT();
        token = new DeferredRewardToken();
        staking = new DeferredRewardStaking(nft, token);
        DeferredRewardEmission emission = new DeferredRewardEmission();
        vault = new HamsterMiningReserve(
            address(this), address(nft), address(staking), address(emission), address(emission), address(token)
        );
        nft.mint(alice, 1);
        nft.mint(bob, 2);
        vm.prank(alice);
        nft.setApprovalForAll(address(vault), true);
        vm.prank(bob);
        nft.setApprovalForAll(address(vault), true);
        uint256[] memory ids = new uint256[](1);
        ids[0] = 1;
        vm.prank(alice);
        vault.deposit(ids);
        staking.accrue(address(vault), 100e18);
        staking.setUnavailable(true);
    }

    function test_newDepositorCannotCaptureRewardsFromBeforeTheirDeposit() public {
        uint256[] memory ids = new uint256[](1);
        ids[0] = 2;
        // A fix may reject the balance change until settlement is possible, or preserve
        // the original entitlement while allowing it. Both satisfy the specification.
        vm.prank(bob);
        (bool accepted,) = address(vault).call(abi.encodeCall(vault.deposit, (ids)));
        if (!accepted) assertEq(nft.ownerOf(2), bob, "rejected deposit must return Bob's NFT");
        staking.setUnavailable(false);
        vm.prank(alice);
        uint256 alicePaid = vault.claimRewards();
        vm.prank(bob);
        uint256 bobPaid = vault.claimRewards();
        emit log_named_uint("Alice received", alicePaid);
        emit log_named_uint("Bob received", bobPaid);
        assertEq(alicePaid, 100e18, "Alice must retain all rewards earned before Bob deposited");
        assertEq(bobPaid, 0, "Bob did not hold shares when the rewards accrued");
    }

    function test_transferCannotMoveAlreadyEarnedRewardsToNewHolder() public {
        uint256 shares = vault.balanceOf(alice);
        vm.prank(alice);
        (bool accepted,) = address(vault).call(abi.encodeCall(vault.transfer, (bob, shares)));
        if (!accepted) assertEq(vault.balanceOf(alice), shares, "rejected transfer must preserve Alice's shares");
        staking.setUnavailable(false);
        vm.prank(alice);
        uint256 alicePaid = vault.claimRewards();
        vm.prank(bob);
        uint256 bobPaid = vault.claimRewards();
        emit log_named_uint("Alice received", alicePaid);
        emit log_named_uint("Bob received", bobPaid);
        assertEq(alicePaid, 100e18, "Exit transfers future rewards, not the exiting holder's accrued SQK");
        assertEq(bobPaid, 0, "Transfer recipient must not receive previously accrued rewards");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {HamsterMiningReserve} from "src/HamsterMiningReserve.sol";

contract ProofReward {
    mapping(address => uint256) public balanceOf;

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract ProofNft {
    mapping(uint256 => address) public ownerOf;
    mapping(address => mapping(address => bool)) public isApprovedForAll;

    function mint(address to, uint256 id) external {
        require(ownerOf[id] == address(0), "already minted");
        ownerOf[id] = to;
    }

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

    function setApprovalForAll(address operator, bool approved) external {
        isApprovedForAll[msg.sender][operator] = approved;
    }

    function transferFrom(address from, address to, uint256 id) external {
        require(ownerOf[id] == from, "not owner");
        require(msg.sender == from || isApprovedForAll[from][msg.sender], "not approved");
        ownerOf[id] = to;
    }
}

contract ProofEmission {
    function checkpoint() external {}
}

contract ProofStaking {
    ProofNft public immutable nft;
    ProofReward public immutable reward;
    mapping(address => uint256) public accountPower;
    mapping(address => uint256) public claimable;
    bool public claimDisabled;

    constructor(ProofNft nft_, ProofReward reward_) {
        nft = nft_;
        reward = reward_;
    }

    function setClaimDisabled(bool disabled) external {
        claimDisabled = disabled;
    }

    function fund(address account, uint256 amount) external {
        reward.mint(address(this), amount);
        claimable[account] += amount;
    }

    function deposit(address collection, uint256[] calldata ids) external {
        require(collection == address(nft), "wrong collection");
        for (uint256 i; i < ids.length; ++i) {
            nft.transferFrom(msg.sender, address(this), ids[i]);
            accountPower[msg.sender] += 1000e18;
        }
    }

    function claim(address account) external returns (uint256 amount) {
        require(!claimDisabled, "temporary claim outage");
        amount = claimable[account];
        claimable[account] = 0;
        reward.transfer(account, amount);
    }
}

contract DelayedRewardsProofTest is Test {
    ProofReward reward;
    ProofNft nft;
    ProofStaking staking;
    HamsterMiningReserve vault;
    address alice;
    address bob;

    function setUp() public {
        alice = makeAddr("original depositor");
        bob = makeAddr("later holder");
        reward = new ProofReward();
        nft = new ProofNft();
        staking = new ProofStaking(nft, reward);
        ProofEmission emission = new ProofEmission();
        // Core is not called in these reward paths; no live graph is used in this proof.
        vault = new HamsterMiningReserve(
            address(this), address(nft), address(staking), address(emission), address(emission), address(reward)
        );
        nft.mint(alice, 1);
        nft.mint(bob, 2);
        vm.prank(alice);
        nft.setApprovalForAll(address(vault), true);
        vm.prank(bob);
        nft.setApprovalForAll(address(vault), true);
        vm.prank(alice);
        vault.deposit(_one(1));
        // Only Alice has shares when all 100 SQK accrue. No rewards accrue later.
        staking.fund(address(vault), 100e18);
        assertEq(vault.pendingRewards(alice), 100e18);
        staking.setClaimDisabled(true);
    }

    function _one(uint256 id) internal pure returns (uint256[] memory ids) {
        ids = new uint256[](1);
        ids[0] = id;
    }

    function _recoverAndCheckOriginalEntitlement() internal {
        staking.setClaimDisabled(false);
        vault.harvest();
        vm.prank(alice);
        uint256 alicePaid = vault.claimRewards();
        vm.prank(bob);
        uint256 bobPaid = vault.claimRewards();
        assertEq(alicePaid, 100e18, "original holder must keep rewards earned before balance change");
        assertEq(bobPaid, 0, "later holder must not receive old rewards");
        assertEq(reward.balanceOf(alice), 100e18);
        assertEq(reward.balanceOf(bob), 0);
    }

    function test_depositDuringClaimOutageCannotTakeEarlierRewards() public {
        vm.prank(bob);
        // A fix may either reject the mutation or preserve old reward ownership.
        (bool accepted,) = address(vault).call(abi.encodeCall(vault.deposit, (_one(2))));
        if (accepted) {
            assertGt(vault.balanceOf(bob), 0);
        } else {
            assertEq(vault.balanceOf(bob), 0);
            assertEq(nft.ownerOf(2), bob);
        }
        _recoverAndCheckOriginalEntitlement();
    }

    function test_transferDuringClaimOutageCannotMoveEarlierRewards() public {
        uint256 shares = vault.balanceOf(alice);
        vm.prank(alice);
        (bool accepted,) = address(vault).call(abi.encodeCall(vault.transfer, (bob, shares)));
        if (accepted) {
            assertEq(vault.balanceOf(bob), shares);
        } else {
            assertEq(vault.balanceOf(alice), shares);
            assertEq(vault.balanceOf(bob), 0);
        }
        _recoverAndCheckOriginalEntitlement();
    }
}

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

import {Test} from "forge-std/Test.sol";
import {HamsterMiningReserve} from "src/HamsterMiningReserve.sol";

contract ProofReward {
    mapping(address => uint256) public balanceOf;

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract ProofNft {
    mapping(uint256 => address) public ownerOf;
    mapping(address => mapping(address => bool)) public isApprovedForAll;

    function mint(address to, uint256 id) external {
        require(ownerOf[id] == address(0), "already minted");
        ownerOf[id] = to;
    }

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

    function setApprovalForAll(address operator, bool approved) external {
        isApprovedForAll[msg.sender][operator] = approved;
    }

    function transferFrom(address from, address to, uint256 id) external {
        require(ownerOf[id] == from, "not owner");
        require(msg.sender == from || isApprovedForAll[from][msg.sender], "not approved");
        ownerOf[id] = to;
    }
}

contract ProofEmission {
    function checkpoint() external {}
}

contract ProofStaking {
    ProofNft public immutable nft;
    ProofReward public immutable reward;
    mapping(address => uint256) public accountPower;
    mapping(address => uint256) public claimable;
    bool public claimDisabled;

    constructor(ProofNft nft_, ProofReward reward_) {
        nft = nft_;
        reward = reward_;
    }

    function setClaimDisabled(bool disabled) external {
        claimDisabled = disabled;
    }

    function fund(address account, uint256 amount) external {
        reward.mint(address(this), amount);
        claimable[account] += amount;
    }

    function deposit(address collection, uint256[] calldata ids) external {
        require(collection == address(nft), "wrong collection");
        for (uint256 i; i < ids.length; ++i) {
            nft.transferFrom(msg.sender, address(this), ids[i]);
            accountPower[msg.sender] += 1000e18;
        }
    }

    function claim(address account) external returns (uint256 amount) {
        require(!claimDisabled, "temporary claim outage");
        amount = claimable[account];
        claimable[account] = 0;
        reward.transfer(account, amount);
    }
}

contract DelayedRewardsProofTest is Test {
    ProofReward reward;
    ProofNft nft;
    ProofStaking staking;
    HamsterMiningReserve vault;
    address alice;
    address bob;

    function setUp() public {
        alice = makeAddr("original depositor");
        bob = makeAddr("later holder");
        reward = new ProofReward();
        nft = new ProofNft();
        staking = new ProofStaking(nft, reward);
        ProofEmission emission = new ProofEmission();
        // Core is not called in these reward paths; no live graph is used in this proof.
        vault = new HamsterMiningReserve(
            address(this), address(nft), address(staking), address(emission), address(emission), address(reward)
        );
        nft.mint(alice, 1);
        nft.mint(bob, 2);
        vm.prank(alice);
        nft.setApprovalForAll(address(vault), true);
        vm.prank(bob);
        nft.setApprovalForAll(address(vault), true);
        vm.prank(alice);
        vault.deposit(_one(1));
        // Only Alice has shares when all 100 SQK accrue. No rewards accrue later.
        staking.fund(address(vault), 100e18);
        assertEq(vault.pendingRewards(alice), 100e18);
        staking.setClaimDisabled(true);
    }

    function _one(uint256 id) internal pure returns (uint256[] memory ids) {
        ids = new uint256[](1);
        ids[0] = id;
    }

    function _recoverAndCheckOriginalEntitlement() internal {
        staking.setClaimDisabled(false);
        vault.harvest();
        vm.prank(alice);
        uint256 alicePaid = vault.claimRewards();
        vm.prank(bob);
        uint256 bobPaid = vault.claimRewards();
        assertEq(alicePaid, 100e18, "original holder must keep rewards earned before balance change");
        assertEq(bobPaid, 0, "later holder must not receive old rewards");
        assertEq(reward.balanceOf(alice), 100e18);
        assertEq(reward.balanceOf(bob), 0);
    }

    function test_depositDuringClaimOutageCannotTakeEarlierRewards() public {
        vm.prank(bob);
        // A fix may either reject the mutation or preserve old reward ownership.
        (bool accepted,) = address(vault).call(abi.encodeCall(vault.deposit, (_one(2))));
        if (accepted) {
            assertGt(vault.balanceOf(bob), 0);
        } else {
            assertEq(vault.balanceOf(bob), 0);
            assertEq(nft.ownerOf(2), bob);
        }
        _recoverAndCheckOriginalEntitlement();
    }

    function test_transferDuringClaimOutageCannotMoveEarlierRewards() public {
        uint256 shares = vault.balanceOf(alice);
        vm.prank(alice);
        (bool accepted,) = address(vault).call(abi.encodeCall(vault.transfer, (bob, shares)));
        if (accepted) {
            assertEq(vault.balanceOf(bob), shares);
        } else {
            assertEq(vault.balanceOf(alice), shares);
            assertEq(vault.balanceOf(bob), 0);
        }
        _recoverAndCheckOriginalEntitlement();
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";

import {HamsterMiningReserve} from "src/HamsterMiningReserve.sol";

/// @notice Proof for: `_settle()` wraps `staking.claim(address(this))` in try/catch but declares
///         `returns (uint256)`. Solidity decodes the return data outside the catch, so a staking
///         implementation whose `claim` returns no data (a legitimate upgrade of the unverified
///         Squeekchain proxy) makes `_settle` revert, and with it deposit, transfer, transferFrom,
///         claimRewards, harvest, poke and mergeStep. SQK already inside the vault becomes
///         unreachable. README states that a broken `claim` never blocks claims of received SQK.
///
///         Fails on the current code (harvest / claimRewards / transfer revert with empty data).
///         Passes once `_settle` ignores the return data of `claim` (e.g. a raw `call` or a
///         `try` without a `returns` clause).
contract SQK is ERC20 {
    constructor() ERC20("SQK", "SQK") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

contract Squeek is ERC721 {
    mapping(uint256 => uint256) public level;

    constructor() ERC721("Squeek", "SQUEEK") {}

    function mint(address to, uint256 id) external {
        level[id] = 1;
        _mint(to, id);
    }
}

contract Emission {
    function checkpoint() external {}
}

/// @dev Staking surface whose `claim(address)` returns nothing. Everything else behaves like v9.
contract VoidClaimStaking {
    Squeek public immutable nft;
    SQK public immutable sqk;
    mapping(address => uint256) public accountPower;
    mapping(address => uint256) public claimable;

    constructor(Squeek nft_, SQK sqk_) {
        nft = nft_;
        sqk = sqk_;
    }

    function deposit(address, uint256[] calldata ids) external {
        for (uint256 i; i < ids.length; ++i) {
            nft.transferFrom(msg.sender, address(this), ids[i]);
            accountPower[msg.sender] += 1000e18;
        }
    }

    function withdraw(address, uint256[] calldata) external {}

    function fund(address account, uint256 amount) external {
        sqk.mint(address(this), amount);
        claimable[account] += amount;
    }

    /// @dev Pays accrued SQK but returns no value.
    function claim(address account) external {
        uint256 amount = claimable[account];
        if (amount == 0) return;
        claimable[account] = 0;
        sqk.transfer(account, amount);
    }
}

contract VoidClaimBricksSettleTest is Test {
    address owner = makeAddr("owner");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    SQK sqk;
    Squeek nft;
    Emission emission;
    VoidClaimStaking staking;
    HamsterMiningReserve vault;

    function setUp() public {
        sqk = new SQK();
        nft = new Squeek();
        emission = new Emission();
        staking = new VoidClaimStaking(nft, sqk);
        vault = new HamsterMiningReserve(
            owner, address(nft), address(staking), address(emission), address(0xC0DE), address(sqk)
        );
        nft.mint(alice, 1);
        vm.prank(alice);
        nft.setApprovalForAll(address(vault), true);
    }

    function test_voidClaimDoesNotBlockVault() public {
        // The first deposit already runs _settle(); with a void-returning claim it must still work.
        uint256[] memory ids = new uint256[](1);
        ids[0] = 1;
        vm.prank(alice);
        vault.deposit(ids);
        assertEq(vault.balanceOf(alice), 1000e18);

        // Rewards accrue and are pulled in by the vault on settle.
        staking.fund(address(vault), 10e18);
        vault.harvest();

        // Holder can still claim what the vault received, and still exit by transfer.
        vm.prank(alice);
        uint256 paid = vault.claimRewards();
        assertEq(paid, 10e18);
        assertEq(sqk.balanceOf(alice), 10e18);

        vm.prank(alice);
        vault.transfer(bob, 1000e18);
        assertEq(vault.balanceOf(bob), 1000e18);
    }
}