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

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

/// @dev Minimal 18-decimal ERC-20 standing in for the launch-2 HAMSTER token.
contract Hamster {
    string public constant name = "HAMSTER";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

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

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

/// @notice Finding: any HAMSTER holder can permanently block TEAM's one-shot bindToken by sending
/// 1 wei of HAMSTER to the vault before TEAM binds. bindToken requires balanceOf(vault) == 8e26
/// exactly, there is no rescue path for donations, and nothing else in the vault can ever set
/// `token`, so the 800M allocation, mining, staking and boost claims are bricked forever.
contract BindGriefTest is Test {
    address internal constant TEAM = address(bytes20(hex"6cba4751742f6989fa224b2dc5d5d52fcef98a34"));
    HamsterVault internal vault;
    Hamster internal hamster;
    address internal sniper = makeAddr("sniper");

    function setUp() public {
        vm.chainId(1);
        HamsterBoost boost = new HamsterBoost();
        vault = new HamsterVault(TEAM, address(boost));
        hamster = new Hamster();
        // Launch 2: 1B supply, exactly 800M to the vault, 200M to the pool (here: a buyer).
        hamster.mint(address(vault), 800_000_000 ether);
        hamster.mint(sniper, 200_000_000 ether);
    }

    function test_oneWeiDonationBeforeBindBricksVaultForever() public {
        // A trader who bought any HAMSTER front-runs TEAM's bindToken with a 1 wei transfer.
        vm.prank(sniper);
        hamster.transfer(address(vault), 1);

        // The honest launch state: correct token, correct supply, the full 800M delivered.
        assertEq(hamster.totalSupply(), 1_000_000_000 ether);
        assertGe(hamster.balanceOf(address(vault)), 800_000_000 ether);

        // Expected: TEAM can still bind the genuine token (excess is a donation, as everywhere
        // else in the vault). Actual: bindToken reverts InvalidAmount, now and forever.
        vm.prank(TEAM);
        vault.bindToken(address(hamster));
        assertEq(vault.token(), address(hamster), "vault must bind the genuine launch-2 token");
    }
}

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

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

contract Token {
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

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

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

/// @dev Minimal v2-shaped game: one account loses in window 0, finalized on demand.
contract Game {
    address public constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint64 public constant genesis = 1791847200;
    uint256 public nextFinalizeWindow;
    uint256 public cumulative;
    mapping(uint256 => mapping(address => uint256)) public lossOf;
    mapping(uint256 => uint256) public totalEligibleLoss;
    mapping(uint256 => uint256) public cumulativeLossBefore;
    mapping(uint256 => uint256) public cumulativeLossAfter;
    mapping(address => uint256) public balances;

    function windowStart(uint256 k) external pure returns (uint64) {
        return uint64(genesis + k * 1 hours);
    }

    function windowEnd(uint256 k) public pure returns (uint64) {
        return uint64(genesis + (k + 1) * 1 hours);
    }

    function setLoss(uint256 k, address who, uint256 amount) external {
        totalEligibleLoss[k] = totalEligibleLoss[k] - lossOf[k][who] + amount;
        lossOf[k][who] = amount;
    }

    function finalize(uint256 maxWindows) external {
        for (uint256 i; i < maxWindows; ++i) {
            uint256 k = nextFinalizeWindow;
            if (windowEnd(k) > block.timestamp) break;
            cumulativeLossBefore[k] = cumulative;
            cumulative += totalEligibleLoss[k];
            cumulativeLossAfter[k] = cumulative;
            ++nextFinalizeWindow;
        }
    }

    function withdraw() external {}
    function depositJackpot(uint256) external {}
    function fundOracleReserve(uint256) external {}
}

/// @notice Finding: withdrawVested(account, ids) has no caller check, so any competing staker can
/// force-withdraw another holder's vested-but-unwithdrawn grant principal every block. The brief
/// says vested-unwithdrawn balances count as stake weight; the attacker strips that weight from
/// the victim (24h warm-up to re-stake) and raises its own pro-rata IMD share.
contract VestedGriefTest is Test {
    address internal constant TEAM = address(bytes20(hex"6cba4751742f6989fa224b2dc5d5d52fcef98a34"));
    address internal constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    address internal constant V2 = 0xe33AB493249a2Df0D8c4a71aC54F46d1F7778367;
    uint64 internal constant GENESIS = 1791847200;
    HamsterVault internal vault;
    Token internal hamster;
    Game internal game;
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");

    function setUp() public {
        vm.chainId(1);
        vm.warp(uint256(GENESIS) + 2 hours);
        vm.etch(IMD, address(new Token()).code);
        vm.etch(V2, address(new Game()).code);
        game = Game(V2);
        HamsterBoost boost = new HamsterBoost();
        vault = new HamsterVault(TEAM, address(boost));
        hamster = new Token();
        hamster.mint(address(vault), 800_000_000 ether);
        hamster.mint(bob, 200_000_000 ether);
        vm.prank(TEAM);
        vault.bindToken(address(hamster));
        vm.prank(bob);
        hamster.approve(address(vault), type(uint256).max);
    }

    function test_thirdPartyCannotStripVestedStakeWeight() public {
        // Alice lost 100 IMD in window 0; her retroactive claim creates a 7-day grant.
        game.setLoss(0, alice, 100 ether);
        game.finalize(1);
        uint256[] memory w = new uint256[](1);
        uint256 granted = vault.claimMined(V2, w, alice);
        assertGt(granted, 0);
        // Bob stakes the same amount; both lots warm up together.
        vm.prank(bob);
        vault.stake(granted);
        vm.warp(block.timestamp + 24 hours);
        vault.checkpoint(128);
        vault.checkpointAccount(alice, 128);
        (uint256 aliceWeightBefore,,,,) = vault.accounts(alice);
        assertEq(aliceWeightBefore, granted, "grant counts as stake weight once warmed up");

        // Bob, not Alice, withdraws Alice's vested slice (1/7 after one day).
        uint256[] memory ids = new uint256[](1);
        vm.prank(bob);
        (bool ok,) = address(vault).call(abi.encodeCall(vault.withdrawVested, (alice, ids)));
        (uint256 aliceWeightAfter,,,,) = vault.accounts(alice);

        // Expected: a stranger cannot change Alice's position; her vested-unwithdrawn balance keeps
        // earning until she withdraws it herself. Actual: the call succeeds and Alice's weight drops
        // by granted/7 while Bob's share of every IMD stream rises accordingly.
        assertTrue(!ok || aliceWeightAfter == aliceWeightBefore, "third party stripped vested stake weight");
    }
}

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

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

/// @notice Finding: sweepDormantBoost "moves" the dormant 50M boost bucket into mining by raising
/// miningAllocation to 800M, but the emission curve and the commit cap in _prepareWindow stay at
/// the 750M constant, so the 50M can never be committed to any window: it is locked forever.
contract SweepLockTest is Test {
    address internal constant TEAM = address(bytes20(hex"6cba4751742f6989fa224b2dc5d5d52fcef98a34"));
    HamsterVault internal vault;

    function setUp() public {
        vm.chainId(1);
        vm.warp(1791847200 + 2 hours);
        HamsterBoost boost = new HamsterBoost();
        vault = new HamsterVault(TEAM, address(boost));
    }

    function test_sweptBoostBucketIsReachableByMining() public {
        vm.warp(vault.deployedAt() + 365 days);
        vault.sweepDormantBoost();
        (uint256 miningUncommitted,, uint256 boostUncommitted,) = vault.bucketsLeft();
        assertEq(boostUncommitted, 0);
        assertEq(miningUncommitted, 800_000_000 ether, "bucket view reports 800M available to mining");
        // Expected after the brief's sweep: everything reported as uncommitted mining supply can be
        // emitted by the curve. Actual: the curve saturates at 750M for any loss, so 50M is unreachable.
        assertEq(
            vault.emissionCurve(type(uint256).max),
            miningUncommitted + vault.miningCommitted(),
            "curve can never emit the swept 50M"
        );
    }
}

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

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

contract Tok {
    uint256 public totalSupply;
    uint8 public constant decimals = 18;
    mapping(address => uint256) public balanceOf;
    function mint(address to, uint256 a) external { totalSupply += a; balanceOf[to] += a; }
    function transfer(address to, uint256 a) external returns (bool) { balanceOf[msg.sender] -= a; balanceOf[to] += a; return true; }
}

contract Game {
    uint64 constant G = 1791847200;
    uint256 public nextFinalizeWindow = 2;
    function IMD() external pure returns (address) { return 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7; }
    function windowStart(uint256 k) external pure returns (uint64) { return uint64(G + k * 1 hours); }
    function windowEnd(uint256 k) external pure returns (uint64) { return uint64(G + (k + 1) * 1 hours); }
    function lossOf(uint256 k, address) external pure returns (uint256) { return k == 0 ? 100 * 18_750 ether : 0; }
    function totalEligibleLoss(uint256 k) external pure returns (uint256) { return k == 0 ? 100 * 18_750 ether : 0; }
    function cumulativeLossBefore(uint256 k) external pure returns (uint256) { return k == 0 ? 0 : 100 * 18_750 ether; }
    function cumulativeLossAfter(uint256) external pure returns (uint256) { return 100 * 18_750 ether; }
}

/// After the 365-day sweep "moves the 50M into mining", mining must be able to emit it.
contract SweepProof is Test {
    function test_sweptBoostBucketIsMinable() public {
        vm.chainId(1);
        vm.warp(1791847200 + 3 hours);
        vm.etch(0xe33AB493249a2Df0D8c4a71aC54F46d1F7778367, address(new Game()).code);
        vm.store(0xe33AB493249a2Df0D8c4a71aC54F46d1F7778367, 0, bytes32(uint256(2)));
        HamsterVault vault = new HamsterVault(address(0xBEEF), address(new HamsterBoost()));
        Tok t = new Tok();
        t.mint(address(vault), 800_000_000 ether);
        t.mint(address(1), 200_000_000 ether);
        vm.prank(address(0xBEEF));
        vault.bindToken(address(t));
        vm.warp(vault.deployedAt() + 365 days);
        vault.sweepDormantBoost();
        uint256[] memory ws = new uint256[](1);
        address miner = address(0xA11CE);
        vault.claimMined(0xe33AB493249a2Df0D8c4a71aC54F46d1F7778367, ws, miner);
        (uint256 uncommitted,,,) = vault.bucketsLeft();
        // Expected: the swept 50M is emitted by mining (uncommitted reaches 0 once all loss is mined).
        // Actual: committed stops at 750M and bucketsLeft reports 50M uncommitted forever.
        assertEq(vault.miningCommitted(), 800_000_000 ether, "swept 50M never becomes minable");
        assertEq(uncommitted, 0);
    }
}

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

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

contract GriefToken {
    uint256 public totalSupply;
    uint8 public constant decimals = 18;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

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

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

/// @notice A 1 wei HAMSTER donation to the vault before TEAM binds makes bindToken revert forever,
/// locking the 800M remainder in an unbound vault with no withdrawal path.
contract BindGriefTest is Test {
    address internal constant TEAM = address(0xBEEF);

    function test_oneWeiDonationMustNotBrickBinding() public {
        vm.chainId(1);
        HamsterBoost boost = new HamsterBoost();
        HamsterVault vault = new HamsterVault(TEAM, address(boost));
        GriefToken token = new GriefToken();
        address attacker = makeAddr("attacker");
        // Launch 2: 1B supply, exactly 800M remainder to the vault, 200M to the pool/others.
        token.mint(address(vault), 800_000_000 ether);
        token.mint(attacker, 200_000_000 ether);

        // Attacker front-runs TEAM's bind with a 1 wei transfer to the vault.
        vm.prank(attacker);
        token.transfer(address(vault), 1);

        // TEAM must still be able to bind: the excess is an unsolicited donation, not a reason
        // to strand 800M HAMSTER forever. Currently reverts InvalidAmount.
        vm.prank(TEAM);
        vault.bindToken(address(token));
        assertEq(vault.token(), address(token));
    }
}

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

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

contract SweepToken {
    uint256 public totalSupply;
    uint8 public constant decimals = 18;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

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

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

contract SweepGame {
    address public constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint64 public constant genesis = 1791847200;
    uint256 public nextFinalizeWindow;
    uint256 public cumulativeLoss;
    mapping(uint256 => mapping(address => uint256)) public lossOf;
    mapping(uint256 => uint256) public totalEligibleLoss;
    mapping(uint256 => uint256) public cumulativeLossBefore;
    mapping(uint256 => uint256) public cumulativeLossAfter;
    mapping(address => uint256) public balances;

    function windowStart(uint256 k) external pure returns (uint64) {
        return uint64(genesis + k * 1 hours);
    }

    function windowEnd(uint256 k) public pure returns (uint64) {
        return uint64(genesis + (k + 1) * 1 hours);
    }

    function setLoss(uint256 k, address who, uint256 amount) external {
        totalEligibleLoss[k] = totalEligibleLoss[k] - lossOf[k][who] + amount;
        lossOf[k][who] = amount;
    }

    function finalize(uint256 maxWindows) external {
        for (uint256 i; i < maxWindows; ++i) {
            uint256 k = nextFinalizeWindow;
            if (windowEnd(k) > block.timestamp) break;
            cumulativeLossBefore[k] = cumulativeLoss;
            cumulativeLoss += totalEligibleLoss[k];
            cumulativeLossAfter[k] = cumulativeLoss;
            ++nextFinalizeWindow;
        }
    }

    function withdraw() external {}
    function depositJackpot(uint256) external {}
    function fundOracleReserve(uint256) external {}
}

/// @notice After sweepDormantBoost the 50M boost bucket is "moved into mining", but the emission
/// curve still saturates at 750M, so the 50M can never be committed to any window: it is locked
/// forever in an immutable contract with no rescue path.
contract SweepLockTest is Test {
    address internal constant TEAM = address(0xBEEF);
    address internal constant V2 = 0xe33AB493249a2Df0D8c4a71aC54F46d1F7778367;
    uint256 internal constant GENESIS = 1791847200;

    function test_sweptBoostBucketMustBeMinable() public {
        vm.chainId(1);
        vm.warp(GENESIS + 2 hours);
        SweepGame template = new SweepGame();
        vm.etch(V2, address(template).code);
        SweepGame game = SweepGame(V2);
        HamsterBoost boost = new HamsterBoost();
        HamsterVault vault = new HamsterVault(TEAM, address(boost));
        SweepToken token = new SweepToken();
        token.mint(address(vault), 800_000_000 ether);
        token.mint(address(this), 200_000_000 ether);
        vm.prank(TEAM);
        vault.bindToken(address(token));

        // Boost never activated: after 365 days anyone sweeps the 50M into mining.
        vm.warp(GENESIS + 2 hours + 365 days);
        vault.sweepDormantBoost();
        assertEq(vault.miningAllocation(), 800_000_000 ether);

        // Saturate the curve: 2,000,000 IMD of eligible loss in window 0 (h >= 90 halvings).
        address alice = makeAddr("alice");
        game.setLoss(0, alice, 2_000_000 ether);
        game.finalize(1);
        uint256[] memory windows = new uint256[](1);
        windows[0] = 0;
        vault.claimMined(V2, windows, alice);

        // Everything the curve can ever emit has now been committed. The swept 50M must be part of
        // what mining can emit; currently it is stranded as an uncommittable "reserve".
        (uint256 miningUncommitted,,,) = vault.bucketsLeft();
        assertLt(miningUncommitted, 1 ether, "swept 50M is not minable");
    }
}

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

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

/// @dev Minimal 1B-supply token: 800M minted to the vault, the remainder to a trader.
contract DustToken {
    uint256 public totalSupply;
    uint8 public constant decimals = 18;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(address vault, address trader) {
        totalSupply = 1_000_000_000 ether;
        balanceOf[vault] = 800_000_000 ether;
        balanceOf[trader] = 200_000_000 ether;
    }

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

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

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }
}

contract BindDustTest is Test {
    address internal constant TEAM = address(0x6CBA4751742F6989fA224B2dC5d5d52fCef98a34);

    function test_oneWeiDonationBeforeBindPermanentlyBricksBinding() public {
        vm.chainId(1);
        HamsterBoost boost = new HamsterBoost();
        HamsterVault vault = new HamsterVault(TEAM, address(boost));
        address trader = makeAddr("trader");
        DustToken token = new DustToken(address(vault), trader);

        // Anyone holding 1 wei of HAMSTER sends it to the vault before TEAM's bindToken lands.
        vm.prank(trader);
        token.transfer(address(vault), 1);

        // Expected: the vault binds (the 1 wei is an unsolicited donation, which the vault already
        // tolerates after binding). Actual: InvalidAmount, and no path ever removes the 1 wei, so
        // the vault can never bind and the 800M HAMSTER are locked forever.
        vm.prank(TEAM);
        vault.bindToken(address(token));
        assertEq(vault.token(), address(token), "vault must bind with a dust donation present");
    }
}

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

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

/// @dev Minimal 18-decimal ERC-20 standing in for the launch-2 HAMSTER token.
contract Hamster {
    string public constant name = "HAMSTER";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

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

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

/// @notice Finding: any HAMSTER holder can permanently block TEAM's one-shot bindToken by sending
/// 1 wei of HAMSTER to the vault before TEAM binds. bindToken requires balanceOf(vault) == 8e26
/// exactly, there is no rescue path for donations, and nothing else in the vault can ever set
/// `token`, so the 800M allocation, mining, staking and boost claims are bricked forever.
contract BindGriefTest is Test {
    address internal constant TEAM = address(bytes20(hex"6cba4751742f6989fa224b2dc5d5d52fcef98a34"));
    HamsterVault internal vault;
    Hamster internal hamster;
    address internal sniper = makeAddr("sniper");

    function setUp() public {
        vm.chainId(1);
        HamsterBoost boost = new HamsterBoost();
        vault = new HamsterVault(TEAM, address(boost));
        hamster = new Hamster();
        // Launch 2: 1B supply, exactly 800M to the vault, 200M to the pool (here: a buyer).
        hamster.mint(address(vault), 800_000_000 ether);
        hamster.mint(sniper, 200_000_000 ether);
    }

    function test_oneWeiDonationBeforeBindBricksVaultForever() public {
        // A trader who bought any HAMSTER front-runs TEAM's bindToken with a 1 wei transfer.
        vm.prank(sniper);
        hamster.transfer(address(vault), 1);

        // The honest launch state: correct token, correct supply, the full 800M delivered.
        assertEq(hamster.totalSupply(), 1_000_000_000 ether);
        assertGe(hamster.balanceOf(address(vault)), 800_000_000 ether);

        // Expected: TEAM can still bind the genuine token (excess is a donation, as everywhere
        // else in the vault). Actual: bindToken reverts InvalidAmount, now and forever.
        vm.prank(TEAM);
        vault.bindToken(address(hamster));
        assertEq(vault.token(), address(hamster), "vault must bind the genuine launch-2 token");
    }
}

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

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

contract SweepToken {
    uint256 public totalSupply;
    uint8 public constant decimals = 18;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

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

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

contract SweepGame {
    address public constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint64 public constant genesis = 1791847200;
    uint256 public nextFinalizeWindow;
    uint256 public cumulativeLoss;
    mapping(uint256 => mapping(address => uint256)) public lossOf;
    mapping(uint256 => uint256) public totalEligibleLoss;
    mapping(uint256 => uint256) public cumulativeLossBefore;
    mapping(uint256 => uint256) public cumulativeLossAfter;
    mapping(address => uint256) public balances;

    function windowStart(uint256 k) external pure returns (uint64) {
        return uint64(genesis + k * 1 hours);
    }

    function windowEnd(uint256 k) public pure returns (uint64) {
        return uint64(genesis + (k + 1) * 1 hours);
    }

    function setLoss(uint256 k, address who, uint256 amount) external {
        totalEligibleLoss[k] = totalEligibleLoss[k] - lossOf[k][who] + amount;
        lossOf[k][who] = amount;
    }

    function finalize(uint256 maxWindows) external {
        for (uint256 i; i < maxWindows; ++i) {
            uint256 k = nextFinalizeWindow;
            if (windowEnd(k) > block.timestamp) break;
            cumulativeLossBefore[k] = cumulativeLoss;
            cumulativeLoss += totalEligibleLoss[k];
            cumulativeLossAfter[k] = cumulativeLoss;
            ++nextFinalizeWindow;
        }
    }

    function withdraw() external {}
    function depositJackpot(uint256) external {}
    function fundOracleReserve(uint256) external {}
}

/// @notice After sweepDormantBoost the 50M boost bucket is "moved into mining", but the emission
/// curve still saturates at 750M, so the 50M can never be committed to any window: it is locked
/// forever in an immutable contract with no rescue path.
contract SweepLockTest is Test {
    address internal constant TEAM = address(0xBEEF);
    address internal constant V2 = 0xe33AB493249a2Df0D8c4a71aC54F46d1F7778367;
    uint256 internal constant GENESIS = 1791847200;

    function test_sweptBoostBucketMustBeMinable() public {
        vm.chainId(1);
        vm.warp(GENESIS + 2 hours);
        SweepGame template = new SweepGame();
        vm.etch(V2, address(template).code);
        SweepGame game = SweepGame(V2);
        HamsterBoost boost = new HamsterBoost();
        HamsterVault vault = new HamsterVault(TEAM, address(boost));
        SweepToken token = new SweepToken();
        token.mint(address(vault), 800_000_000 ether);
        token.mint(address(this), 200_000_000 ether);
        vm.prank(TEAM);
        vault.bindToken(address(token));

        // Boost never activated: after 365 days anyone sweeps the 50M into mining.
        vm.warp(GENESIS + 2 hours + 365 days);
        vault.sweepDormantBoost();
        assertEq(vault.miningAllocation(), 800_000_000 ether);

        // Saturate the curve: 2,000,000 IMD of eligible loss in window 0 (h >= 90 halvings).
        address alice = makeAddr("alice");
        game.setLoss(0, alice, 2_000_000 ether);
        game.finalize(1);
        uint256[] memory windows = new uint256[](1);
        windows[0] = 0;
        vault.claimMined(V2, windows, alice);

        // Everything the curve can ever emit has now been committed. The swept 50M must be part of
        // what mining can emit; currently it is stranded as an uncommittable "reserve".
        (uint256 miningUncommitted,,,) = vault.bucketsLeft();
        assertLt(miningUncommitted, 1 ether, "swept 50M is not minable");
    }
}

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

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

contract ProofToken {
    uint256 public totalSupply;
    uint8 public constant decimals = 18;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

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

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        if (allowance[from][msg.sender] != type(uint256).max) allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract ProofGame {
    address public constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint64 public immutable genesis;
    uint256 public nextFinalizeWindow;
    uint256 public cumulativeLoss;
    mapping(uint256 => mapping(address => uint256)) public lossOf;
    mapping(uint256 => uint256) public totalEligibleLoss;
    mapping(uint256 => uint256) public cumulativeLossBefore;
    mapping(uint256 => uint256) public cumulativeLossAfter;
    mapping(address => uint256) public balances;

    constructor(uint64 genesis_) {
        genesis = genesis_;
    }

    function windowStart(uint256 k) external view returns (uint64) {
        return uint64(genesis + k * 1 hours);
    }

    function windowEnd(uint256 k) public view returns (uint64) {
        return uint64(genesis + (k + 1) * 1 hours);
    }

    function setLoss(uint256 k, address who, uint256 amount) external {
        totalEligibleLoss[k] = totalEligibleLoss[k] - lossOf[k][who] + amount;
        lossOf[k][who] = amount;
    }

    function finalize(uint256 maxWindows) external {
        for (uint256 i; i < maxWindows; ++i) {
            uint256 k = nextFinalizeWindow;
            if (windowEnd(k) > block.timestamp) break;
            cumulativeLossBefore[k] = cumulativeLoss;
            cumulativeLoss += totalEligibleLoss[k];
            cumulativeLossAfter[k] = cumulativeLoss;
            ++nextFinalizeWindow;
        }
    }

    function withdraw() external {}
    function depositJackpot(uint256) external {}
    function fundOracleReserve(uint256) external {}
}

/// A 365-day dormant-boost sweep that happens after a capped new-game day has been cached
/// (capDays stores raw/allowance on the base curve) but before all of that day's windows are
/// prepared makes the remaining windows price their raw budget on the extended curve while the
/// cached denominator `raw` stays on the base curve. The day then emits more than its 2M cap.
contract SweepAfterCachedCapDayProof is Test {
    address constant TEAM = 0x6CBA4751742F6989fA224B2dC5d5d52fCef98a34;
    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    address constant V2 = 0xe33AB493249a2Df0D8c4a71aC54F46d1F7778367;
    uint64 constant GENESIS = 1791847200;

    function test_cappedDayNeverExceeds2MAcrossSweep() public {
        vm.chainId(1);
        vm.etch(IMD, address(new ProofToken()).code);
        vm.etch(V2, address(new ProofGame(GENESIS)).code);
        // Deploy so that the 365-day sweep falls inside a successor's 14-day cap period.
        vm.warp(uint256(GENESIS) - 360 days);
        HamsterBoost boost = new HamsterBoost();
        HamsterVault vault = new HamsterVault(TEAM, address(boost));
        ProofToken hamster = new ProofToken();
        hamster.mint(address(vault), 800_000_000 ether);
        hamster.mint(address(this), 200_000_000 ether);
        vm.prank(TEAM);
        vault.bindToken(address(hamster));

        vm.warp(uint256(GENESIS) + 2 hours);
        ProofGame next = new ProofGame(GENESIS);
        vm.prank(TEAM);
        vault.scheduleGame(address(next));
        vm.warp(block.timestamp + 48 hours);
        vault.executeGame();
        uint256 day = block.timestamp / 1 days + 1;
        uint256 first = (day * 1 days - GENESIS + 1 hours - 1) / 1 hours;
        address alice = makeAddr("alice");
        address bob = makeAddr("bob");
        // 300 IMD of loss on one capped day: raw 6M, capped to 2M.
        next.setLoss(first, alice, 150 ether);
        next.setLoss(first + 1, bob, 150 ether);
        vm.warp((day + 1) * 1 days + 1 hours);
        ProofGame(V2).finalize(1000);
        next.finalize(1000);
        vault.resolveGame(address(next));
        // Anyone caches the capped day (any claim on a later day does this too).
        boost.prepareCap(address(vault), address(next), 16);
        (,,, uint256 raw, uint256 allowance) = boost.capDays(address(vault), address(next), day);
        assertEq(raw, 6_000_000 ether);
        assertEq(allowance, 2_000_000 ether);

        _catchUp(vault);
        // Alice claims before the sweep and gets exactly half the capped day.
        assertEq(vault.claimMined(address(next), _one(first), alice), 1_000_000 ether);

        // Day 365: nobody activated the boost; anyone sweeps.
        assertLt(block.timestamp, vault.deployedAt() + 365 days);
        vm.warp(vault.deployedAt() + 365 days);
        vault.sweepDormantBoost();
        _catchUp(vault);

        // Bob's window carries the same loss in the same capped day: it must not pay more than
        // the 1M remaining in the day's 2M allowance.
        uint256 paid = vault.claimMined(address(next), _one(first + 1), bob);
        assertLe(paid, 1_000_000 ether, "bob paid more than the day's remaining cap");
        assertLe(1_000_000 ether + paid, 2_000_000 ether, "capped day emitted more than 2M");
    }

    function _catchUp(HamsterVault vault) internal {
        for (uint256 i; i < 64 && !vault.checkpoint(128); ++i) {}
    }

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

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

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

contract SCToken {
    uint256 public totalSupply;
    uint8 public constant decimals = 18;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

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

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        if (allowance[from][msg.sender] != type(uint256).max) allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract SCGame {
    address public constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint64 public immutable genesis;
    uint256 public nextFinalizeWindow;
    uint256 public cumulativeLoss;
    mapping(uint256 => mapping(address => uint256)) public lossOf;
    mapping(uint256 => uint256) public totalEligibleLoss;
    mapping(uint256 => uint256) public cumulativeLossBefore;
    mapping(uint256 => uint256) public cumulativeLossAfter;
    mapping(address => uint256) public balances;

    constructor(uint64 genesis_) {
        genesis = genesis_;
    }

    function windowStart(uint256 k) external view returns (uint64) {
        return uint64(genesis + k * 1 hours);
    }

    function windowEnd(uint256 k) public view returns (uint64) {
        return uint64(genesis + (k + 1) * 1 hours);
    }

    function setLoss(uint256 k, address who, uint256 amount) external {
        totalEligibleLoss[k] = totalEligibleLoss[k] - lossOf[k][who] + amount;
        lossOf[k][who] = amount;
    }

    function finalize(uint256 maxWindows) external {
        for (uint256 i; i < maxWindows; ++i) {
            uint256 k = nextFinalizeWindow;
            if (windowEnd(k) > block.timestamp) break;
            cumulativeLossBefore[k] = cumulativeLoss;
            cumulativeLoss += totalEligibleLoss[k];
            cumulativeLossAfter[k] = cumulativeLoss;
            ++nextFinalizeWindow;
        }
    }

    function withdraw() external {}
    function depositJackpot(uint256) external {}
    function fundOracleReserve(uint256) external {}
}

/// A dormant-boost sweep that lands inside a successor's 14-day cap period, after a capped day
/// has been cached, lets that day pay more than its 2M allowance and makes a window's payout
/// depend on whether it was claimed before or after the sweep.
contract SweepCapTest is Test {
    address internal constant TEAM = address(0xBEEF);
    address internal constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    address internal constant V2 = 0xe33AB493249a2Df0D8c4a71aC54F46d1F7778367;
    uint64 internal constant GENESIS = 1791847200;

    HamsterVault vault;
    HamsterBoost boost;
    SCToken hamster;
    SCGame v2;
    SCGame next;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);

    function setUp() public {
        vm.chainId(1);
        vm.etch(IMD, address(new SCToken()).code);
        vm.etch(V2, address(new SCGame(GENESIS)).code);
        v2 = SCGame(V2);
        // Deploy 360 days before v2 genesis so that deployedAt + 365 days falls 5 days after
        // genesis, inside the successor's cap period.
        vm.warp(uint256(GENESIS) - 360 days);
        boost = new HamsterBoost();
        vault = new HamsterVault(TEAM, address(boost));
        vm.warp(uint256(GENESIS) + 2 hours);
        hamster = new SCToken();
        hamster.mint(address(vault), 800_000_000 ether);
        hamster.mint(alice, 200_000_000 ether);
        vm.prank(TEAM);
        vault.bindToken(address(hamster));
        next = new SCGame(GENESIS);
    }

    function test_sweepAfterCachedCappedDayOverpaysTheDay() public {
        vm.prank(TEAM);
        vault.scheduleGame(address(next));
        vm.warp(uint256(GENESIS) + 50 hours);
        vault.executeGame();
        uint256 switchedAt = block.timestamp;
        uint256 day = switchedAt / 1 days + 1;
        uint256 first = (day * 1 days - GENESIS + 1 hours - 1) / 1 hours;
        next.setLoss(first, alice, 150 ether);
        next.setLoss(first + 1, bob, 150 ether);
        vm.warp((day + 1) * 1 days + 2 hours);
        v2.finalize(1000);
        next.finalize(1000);
        vault.resolveGame(address(next));
        boost.prepareCap(address(vault), address(next), 16);
        (, uint256 pos, uint256 lossStart, uint256 raw, uint256 allowance) = boost.capDays(address(vault), address(next), day);
        assertEq(raw, 6_000_000 ether, "raw day budget");
        assertEq(allowance, 2_000_000 ether, "allowance");

        uint256[] memory w = new uint256[](1);
        w[0] = first;
        uint256 paidAlice = vault.claimMined(address(next), w, alice);
        assertEq(paidAlice, 1_000_000 ether, "alice half of the allowance");
        (uint256 bobBefore,) = vault.windowBudget(address(next), first + 1);
        assertEq(bobBefore, 1_000_000 ether, "bob's window before the sweep");

        // The 365-day sweep lands inside the cap period, after the day was cached.
        vm.warp(vault.deployedAt() + 365 days);
        vault.sweepDormantBoost();

        (uint256 bobAfter,) = vault.windowBudget(address(next), first + 1);
        w[0] = first + 1;
        uint256 paidBob = vault.claimMined(address(next), w, bob);
        assertEq(paidBob, bobAfter);
        // Expected: the day pays at most its 2M allowance, and an identical window pays the same
        // whether claimed before or after the sweep.
        assertLe(paidAlice + paidBob, allowance, "capped day pays more than its allowance");
        assertEq(paidBob, paidAlice, "identical windows differ by claim time");
    }
}