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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {ForecastBounty} from "src/ForecastBounty.sol";
import {BountyRegistry} from "src/BountyRegistry.sol";
import {ResolverStake} from "src/ResolverStake.sol";
import {DisputeWindow} from "src/DisputeWindow.sol";
import {BountySubsidy} from "src/BountySubsidy.sol";
import {DeploymentConfig as C} from "src/DeploymentConfig.sol";

/// @notice A creator with exactly MIN_REWARD of capital drains BountySubsidy one grant per block:
///         create (deadline = now + 1) -> subsidize -> next block refundReward -> repeat.
///         Fails today (ten grants leave with zero cost); passes once a grant requires the bounty
///         to actually run (or the deadline-refund fast path no longer frees the subsidy slot).
contract SubsidyDrainTest is Test {
    LaunchToken token;
    ForecastBounty bounty;
    BountySubsidy subsidy;
    address attacker = makeAddr("attacker");
    address donor = makeAddr("donor");

    function setUp() public {
        token = new LaunchToken();
        BountyRegistry registry = new BountyRegistry();
        DisputeWindow disputes = new DisputeWindow(
            address(token), C.BOND, C.DISPUTE_WINDOW, C.disputeSigner1, C.disputeSigner2, C.disputeSigner3
        );
        ResolverStake stake = new ResolverStake(address(token), C.RESOLVER_STAKE, C.SLASH_BPS);
        bounty = new ForecastBounty(
            address(token), address(registry), address(stake), address(disputes), C.MIN_REWARD, C.BOND, C.MAX_ENTRIES
        );
        subsidy = new BountySubsidy(address(token), address(bounty), C.MIN_REWARD);
        // Requester funds the subsidy pool for ten grants.
        token.transfer(donor, 10 * C.SUBSIDY_AMOUNT);
        vm.startPrank(donor);
        token.approve(address(subsidy), type(uint256).max);
        subsidy.deposit(10 * C.SUBSIDY_AMOUNT);
        vm.stopPrank();
        // Attacker holds exactly one minimum reward.
        token.transfer(attacker, C.MIN_REWARD);
        vm.prank(attacker);
        token.approve(address(bounty), type(uint256).max);
    }

    function testOneRewardOfCapitalDrainsTheWholeSubsidyPoolInTenBlocks() public {
        vm.warp(1_000_000);
        uint256 id;
        for (uint256 i; i < 10; ++i) {
            vm.startPrank(attacker);
            if (id != 0) {
                // Previous bounty hit its deadline in this block: reclaim the reward at zero cost.
                try bounty.refundReward(id) {} catch {}
            }
            try bounty.createBounty("q", block.timestamp + 1, "src", C.MIN_REWARD) returns (uint256 newId) {
                id = newId;
                try subsidy.subsidize(id) {} catch {}
            } catch {}
            vm.stopPrank();
            vm.warp(block.timestamp + 1);
        }
        vm.prank(attacker);
        try bounty.refundReward(id) {} catch {}

        // Attacker still has the full reward capital back, and must not have extracted the pool.
        assertEq(token.balanceOf(attacker) >= C.MIN_REWARD, true, "reward capital lost");
        assertLe(subsidy.totalReleased(), C.SUBSIDY_AMOUNT, "subsidy pool drained by create/refund loop");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {ForecastBounty} from "src/ForecastBounty.sol";
import {BountyRegistry} from "src/BountyRegistry.sol";
import {ResolverStake} from "src/ResolverStake.sol";
import {DisputeWindow} from "src/DisputeWindow.sol";
import {DeploymentConfig as C} from "src/DeploymentConfig.sol";

/// @notice A resolver who resolves with a wrong value and, in the same block, disputes from a second
///         wallet with a bogus value (a) locks every honest challenger out (one dispute slot) and
///         (b) receives its own 20% slash plus both bonds when the panel overturns it.
///         Net cost of the wrong resolution: zero. Fails today; passes once a wrong resolution
///         costs the resolver value regardless of who filed the dispute.
contract SelfDisputeTest is Test {
    LaunchToken token;
    ForecastBounty bounty;
    ResolverStake stake;
    DisputeWindow disputes;
    address creator = makeAddr("creator");
    address alt = makeAddr("creator-second-wallet");
    address honest = makeAddr("honest-challenger");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    function setUp() public {
        token = new LaunchToken();
        BountyRegistry registry = new BountyRegistry();
        disputes = new DisputeWindow(
            address(token), C.BOND, C.DISPUTE_WINDOW, C.disputeSigner1, C.disputeSigner2, C.disputeSigner3
        );
        stake = new ResolverStake(address(token), C.RESOLVER_STAKE, C.SLASH_BPS);
        bounty = new ForecastBounty(
            address(token), address(registry), address(stake), address(disputes), C.MIN_REWARD, C.BOND, C.MAX_ENTRIES
        );
        _fund(creator);
        _fund(alt);
        _fund(honest);
        _fund(alice);
        _fund(bob);
    }

    function _fund(address who) internal {
        token.transfer(who, 100_000e18);
        vm.startPrank(who);
        token.approve(address(bounty), type(uint256).max);
        token.approve(address(stake), type(uint256).max);
        token.approve(address(disputes), type(uint256).max);
        vm.stopPrank();
    }

    function _family() internal view returns (uint256) {
        return token.balanceOf(creator) + token.balanceOf(alt) + stake.stakeOf(address(bounty), creator)
            + disputes.credit(creator) + disputes.credit(alt);
    }

    function testWrongResolutionCostsNothingWhenResolverSelfDisputes() public {
        vm.warp(1_000_000);
        vm.prank(creator);
        uint256 id = bounty.createBounty("q", block.timestamp + 1 days, "src", C.MIN_REWARD);
        vm.prank(alice);
        bounty.forecast(id, 10); // true answer will be 10
        vm.prank(bob);
        bounty.forecast(id, 20);
        vm.prank(creator);
        stake.deposit(address(bounty), C.RESOLVER_STAKE);

        uint256 familyBefore = _family(); // the reward is already escrowed and never returns to the creator
        vm.warp(block.timestamp + 1 days);
        // Wrong resolution: 20 makes bob the winner. Same block, second wallet squats the dispute slot.
        vm.prank(creator);
        bounty.resolve(id, 20);
        vm.prank(alt);
        disputes.dispute(address(bounty), id, 21);

        // Honest challenger who knows the answer is 10 is locked out.
        vm.prank(honest);
        vm.expectRevert(DisputeWindow.AlreadyDisputed.selector);
        disputes.dispute(address(bounty), id, 10);

        // Panel notices and overturns with the correct value.
        vm.prank(C.disputeSigner1);
        disputes.voteValue(address(bounty), id, 10);
        vm.prank(C.disputeSigner2);
        disputes.voteValue(address(bounty), id, 10);
        bounty.finalize(id);

        assertEq(bounty.getBounty(id).winner, alice, "panel corrected the winner");
        uint256 slash = C.RESOLVER_STAKE * C.SLASH_BPS / 10_000;
        // The brief: a wrong resolution costs the resolver real value. Here the resolver family must be
        // down by at least the slash. On the current code the family nets exactly zero.
        assertLe(_family() + slash, familyBefore, "resolver recovered its own slash and both bonds");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {ForecastBounty} from "src/ForecastBounty.sol";
import {BountyRegistry} from "src/BountyRegistry.sol";
import {ResolverStake} from "src/ResolverStake.sol";
import {DisputeWindow} from "src/DisputeWindow.sol";
import {BountySubsidy} from "src/BountySubsidy.sol";
import {DeploymentConfig as C} from "src/DeploymentConfig.sol";

/// One creator wallet, one 5,000 FORECAST reward reused, zero bounty duration: the whole
/// subsidy pool is extracted in ten consecutive blocks. The "no other subsidised bounty open"
/// limiter never binds because refundReward at the (one-second) deadline closes the slot.
contract SubsidyDrainTest is Test {
    LaunchToken token;
    ForecastBounty bounty;
    BountyRegistry registry;
    ResolverStake stake;
    DisputeWindow disputes;
    BountySubsidy subsidy;
    address creator = makeAddr("creator");
    address donor = makeAddr("donor");

    function setUp() public {
        token = new LaunchToken();
        registry = new BountyRegistry();
        disputes = new DisputeWindow(
            address(token), C.BOND, C.DISPUTE_WINDOW, C.disputeSigner1, C.disputeSigner2, C.disputeSigner3
        );
        stake = new ResolverStake(address(token), C.RESOLVER_STAKE, C.SLASH_BPS);
        bounty = new ForecastBounty(
            address(token), address(registry), address(stake), address(disputes), C.MIN_REWARD, C.BOND, C.MAX_ENTRIES
        );
        subsidy = new BountySubsidy(address(token), address(bounty), C.MIN_REWARD);
        token.transfer(creator, C.MIN_REWARD);
        token.transfer(donor, 1_000e18);
        vm.prank(creator);
        token.approve(address(bounty), type(uint256).max);
        vm.prank(donor);
        token.approve(address(subsidy), type(uint256).max);
        vm.warp(1_700_000_000);
    }

    function test_singleCreatorCannotDrainSubsidyPoolWithZeroDurationBounties() public {
        vm.prank(donor);
        subsidy.deposit(1_000e18); // ten grants
        uint256 before = token.balanceOf(creator);
        for (uint256 i; i < 10; ++i) {
            vm.startPrank(creator);
            uint256 id = bounty.createBounty("q", block.timestamp + 1, "src", C.MIN_REWARD);
            try subsidy.subsidize(id) {} catch {}
            vm.warp(block.timestamp + 1);
            bounty.refundReward(id);
            vm.stopPrank();
        }
        // Fails on the current code: the creator holds the entire 1,000 FORECAST pool and
        // its original 5,000 reward, having never kept a bounty open for more than one second.
        assertLt(token.balanceOf(creator) - before, 1_000e18, "whole pool extracted by one creator");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {ForecastBounty} from "src/ForecastBounty.sol";
import {BountyRegistry} from "src/BountyRegistry.sol";
import {ResolverStake} from "src/ResolverStake.sol";
import {DisputeWindow} from "src/DisputeWindow.sol";
import {DeploymentConfig as C} from "src/DeploymentConfig.sol";

/// A resolver that posts a wrong value occupies the single dispute slot from a second wallet in
/// the same block. The honest challenger is locked out with AlreadyDisputed, and when the panel
/// corrects the value the 20% slash and both bonds are paid to the resolver's own second wallet.
contract SelfDisputeTest is Test {
    LaunchToken token;
    ForecastBounty bounty;
    BountyRegistry registry;
    ResolverStake stake;
    DisputeWindow disputes;
    address creator = makeAddr("creator");
    address sock = makeAddr("sock");
    address alice = makeAddr("alice");
    address challenger = makeAddr("challenger");

    function setUp() public {
        token = new LaunchToken();
        registry = new BountyRegistry();
        disputes = new DisputeWindow(
            address(token), C.BOND, C.DISPUTE_WINDOW, C.disputeSigner1, C.disputeSigner2, C.disputeSigner3
        );
        stake = new ResolverStake(address(token), C.RESOLVER_STAKE, C.SLASH_BPS);
        bounty = new ForecastBounty(
            address(token), address(registry), address(stake), address(disputes), C.MIN_REWARD, C.BOND, C.MAX_ENTRIES
        );
        _fund(creator);
        _fund(sock);
        _fund(alice);
        _fund(challenger);
        vm.warp(1_700_000_000);
    }

    function _fund(address who) internal {
        token.transfer(who, 100_000e18);
        vm.startPrank(who);
        token.approve(address(bounty), type(uint256).max);
        token.approve(address(stake), type(uint256).max);
        token.approve(address(disputes), type(uint256).max);
        vm.stopPrank();
    }

    function test_wrongResolutionCostsTheResolverItsSlash() public {
        uint256 householdBefore = token.balanceOf(creator) + token.balanceOf(sock);
        vm.prank(creator);
        stake.deposit(address(bounty), C.RESOLVER_STAKE);
        vm.prank(creator);
        uint256 id = bounty.createBounty("q", block.timestamp + 1 days, "src", C.MIN_REWARD);
        vm.prank(alice);
        bounty.forecast(id, 100); // the true value
        vm.prank(sock);
        bounty.forecast(id, 50);
        vm.warp(block.timestamp + 1 days);
        vm.prank(creator);
        bounty.resolve(id, 50); // wrong on purpose: makes the sock the provisional winner
        vm.prank(sock);
        disputes.dispute(address(bounty), id, 51); // bogus correction fills the only slot

        // The honest challenger can no longer dispute at all.
        vm.prank(challenger);
        vm.expectRevert(DisputeWindow.AlreadyDisputed.selector);
        disputes.dispute(address(bounty), id, 100);

        // The panel does its job and agrees on the real value.
        vm.prank(C.disputeSigner1);
        disputes.voteValue(address(bounty), id, 100);
        vm.prank(C.disputeSigner2);
        disputes.voteValue(address(bounty), id, 100);
        bounty.finalize(id);
        assertEq(bounty.getBounty(id).winner, alice);

        // Settle every position the creator household holds.
        vm.prank(sock);
        disputes.withdrawPayout(); // 2 * BOND
        vm.prank(sock);
        bounty.withdrawBond(id);
        uint256 remaining = stake.stakeOf(address(bounty), creator);
        vm.prank(creator);
        stake.withdraw(address(bounty), remaining);
        uint256 householdAfter = token.balanceOf(creator) + token.balanceOf(sock);

        // Fails on the current code: the household is down only the reward it would have refunded
        // anyway. A wrong resolution that was successfully disputed cost it no slash and no bond.
        assertGe(
            householdBefore - householdAfter,
            C.MIN_REWARD + (C.RESOLVER_STAKE * C.SLASH_BPS) / 10_000,
            "slash recovered by the resolver's own second wallet"
        );
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {ForecastBounty} from "src/ForecastBounty.sol";
import {BountyRegistry} from "src/BountyRegistry.sol";
import {ResolverStake} from "src/ResolverStake.sol";
import {DisputeWindow} from "src/DisputeWindow.sol";

/// @notice An honest resolution plus one unanswered 100-FORECAST dispute converts the winner's
/// reward into a creator refund. The disputer's bond is returned, so cancelling a payout costs gas only.
contract PanelTimeoutCancelsWinnerTest is Test {
    LaunchToken token;
    ForecastBounty bounty;
    BountyRegistry registry;
    ResolverStake stake;
    DisputeWindow disputes;

    address creator = makeAddr("creator");
    address winner = makeAddr("winner");
    address loser = makeAddr("loser");
    address griefer = makeAddr("griefer");
    address s1 = makeAddr("s1");
    address s2 = makeAddr("s2");
    address s3 = makeAddr("s3");

    uint256 constant MIN_REWARD = 5_000e18;
    uint256 constant BOND = 100e18;
    uint256 constant STAKE = 25_000e18;

    function setUp() public {
        token = new LaunchToken();
        registry = new BountyRegistry();
        disputes = new DisputeWindow(address(token), BOND, 48 hours, s1, s2, s3);
        stake = new ResolverStake(address(token), STAKE, 2_000);
        bounty = new ForecastBounty(address(token), address(registry), address(stake), address(disputes), MIN_REWARD, BOND, 500);
        _fund(creator);
        _fund(winner);
        _fund(loser);
        _fund(griefer);
    }

    function _fund(address who) internal {
        token.transfer(who, 100_000e18);
        vm.startPrank(who);
        token.approve(address(bounty), type(uint256).max);
        token.approve(address(stake), type(uint256).max);
        token.approve(address(disputes), type(uint256).max);
        vm.stopPrank();
    }

    function testUnansweredDisputeStripsTheHonestWinner() public {
        vm.prank(creator);
        uint256 id = bounty.createBounty("value?", block.timestamp + 1 days, "source", MIN_REWARD);
        vm.prank(winner);
        bounty.forecast(id, 100);
        vm.prank(loser);
        bounty.forecast(id, 500);
        vm.prank(creator);
        stake.deposit(address(bounty), STAKE);

        vm.warp(block.timestamp + 1 days);
        vm.prank(creator);
        bounty.resolve(id, 100); // honest: winner is exactly right
        assertEq(bounty.getBounty(id).winner, winner);

        // Any wallet posts 100 FORECAST with an arbitrary wrong value.
        vm.prank(griefer);
        disputes.dispute(address(bounty), id, 999);

        // Panel never votes (it is unpaid and has no incentive). Seven days pass.
        vm.warp(block.timestamp + 7 days);
        bounty.finalize(id);
        // On the current code the griefer's 100 bond is fully credited back here (TimedOut returns both bonds),
        // so cancelling the payout cost gas only. Not asserted, so that a fix which forfeits it still passes.

        // Expected: a challenge that never reached a majority leaves the original resolution standing and the winner is paid.
        // Actual: the bounty is Refunded, claim() reverts and the creator takes the reward back.
        vm.prank(winner);
        bounty.claim(id);
        assertEq(bounty.getBounty(id).winner, winner);
        assertTrue(bounty.getBounty(id).rewardPaid);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {ForecastBounty} from "src/ForecastBounty.sol";
import {BountyRegistry} from "src/BountyRegistry.sol";
import {ResolverStake} from "src/ResolverStake.sol";
import {DisputeWindow} from "src/DisputeWindow.sol";

/// @dev Second address under the creator's control; only needed because dispute() rejects msg.sender == resolver.
contract Helper {
    function dispute(LaunchToken token, DisputeWindow w, address market, uint256 id, int256 v) external {
        token.approve(address(w), type(uint256).max);
        w.dispute(market, id, v);
    }

    function withdraw(DisputeWindow w) external {
        w.withdrawPayout();
    }
}

/// @dev A creator that is a contract. It resolves and, in the same transaction, fills the only dispute slot.
contract CreatorBot {
    LaunchToken immutable token;
    ForecastBounty immutable bounty;
    DisputeWindow immutable disputes;
    Helper public immutable helper;

    constructor(LaunchToken t, ForecastBounty b, DisputeWindow d) {
        token = t;
        bounty = b;
        disputes = d;
        helper = new Helper();
        t.approve(address(b), type(uint256).max);
        t.approve(address(b.resolverStake()), type(uint256).max);
    }

    function create() external returns (uint256) {
        return bounty.createBounty("value?", block.timestamp + 1 days, "source", 5_000e18);
    }

    function stakeUp() external {
        bounty.resolverStake().deposit(address(bounty), 25_000e18);
    }

    function resolveAndSelfDispute(uint256 id, int256 wrong, int256 filler) external {
        bounty.resolve(id, wrong);
        token.transfer(address(helper), 100e18);
        helper.dispute(token, disputes, address(bounty), id, filler);
    }
}

contract SingleDisputeSlotTest is Test {
    LaunchToken token;
    ForecastBounty bounty;
    BountyRegistry registry;
    ResolverStake stake;
    DisputeWindow disputes;
    CreatorBot bot;

    address honest = makeAddr("honest");
    address shill = makeAddr("shill");
    address s1 = makeAddr("s1");
    address s2 = makeAddr("s2");
    address s3 = makeAddr("s3");

    function setUp() public {
        token = new LaunchToken();
        registry = new BountyRegistry();
        disputes = new DisputeWindow(address(token), 100e18, 48 hours, s1, s2, s3);
        stake = new ResolverStake(address(token), 25_000e18, 2_000);
        bounty = new ForecastBounty(address(token), address(registry), address(stake), address(disputes), 5_000e18, 100e18, 500);
        _fund(honest);
        _fund(shill);
        bot = new CreatorBot(token, bounty, disputes);
        token.transfer(address(bot), 40_000e18);
    }

    function _fund(address who) internal {
        token.transfer(who, 100_000e18);
        vm.startPrank(who);
        token.approve(address(bounty), type(uint256).max);
        token.approve(address(disputes), type(uint256).max);
        vm.stopPrank();
    }

    function _setupWrongResolution() internal returns (uint256 id) {
        id = bot.create();
        bot.stakeUp();
        vm.prank(honest);
        bounty.forecast(id, 100); // honest forecaster: exactly right
        vm.prank(shill);
        bounty.forecast(id, 1_000); // creator's shill
        vm.warp(block.timestamp + 1 days);
        // Atomic: wrong resolution (shill wins) + filler dispute from the creator's helper.
        bot.resolveAndSelfDispute(id, 1_000, 2_000);
        assertEq(bounty.getBounty(id).winner, shill);
    }

    function testResolverOccupiesTheOnlyDisputeSlot() public {
        uint256 id = _setupWrongResolution();
        // Brief: "a 48-hour window lets any wallet dispute". Expected: the honest wallet can dispute with the truth.
        // Actual: AlreadyDisputed; the resolver has pre-empted the single slot.
        vm.prank(honest);
        disputes.dispute(address(bounty), id, 100);
    }

}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {ForecastBounty} from "src/ForecastBounty.sol";
import {BountyRegistry} from "src/BountyRegistry.sol";
import {ResolverStake} from "src/ResolverStake.sol";
import {DisputeWindow} from "src/DisputeWindow.sol";
import {BountySubsidy} from "src/BountySubsidy.sol";

/// @notice One wallet drains the whole donated subsidy pool with a create -> subsidize -> refund loop.
/// Each cycle takes two blocks, recycles the same 5,000 reward, never pays a forecaster, and nets 100 FORECAST.
contract SubsidyDrainTest is Test {
    LaunchToken token;
    ForecastBounty bounty;
    BountyRegistry registry;
    ResolverStake stake;
    DisputeWindow disputes;
    BountySubsidy subsidy;

    address drainer = makeAddr("drainer");
    address donor = makeAddr("donor");

    function setUp() public {
        token = new LaunchToken();
        registry = new BountyRegistry();
        disputes = new DisputeWindow(address(token), 100e18, 48 hours, makeAddr("s1"), makeAddr("s2"), makeAddr("s3"));
        stake = new ResolverStake(address(token), 25_000e18, 2_000);
        bounty = new ForecastBounty(address(token), address(registry), address(stake), address(disputes), 5_000e18, 100e18, 500);
        subsidy = new BountySubsidy(address(token), address(bounty), 5_000e18);
        token.transfer(donor, 1_000e18);
        token.transfer(drainer, 5_000e18);
        vm.prank(donor);
        token.approve(address(subsidy), type(uint256).max);
        vm.prank(donor);
        subsidy.deposit(1_000e18);
        vm.prank(drainer);
        token.approve(address(bounty), type(uint256).max);
    }

    function testCreateSubsidizeRefundLoopDrainsThePool() public {
        uint256 start = token.balanceOf(drainer);
        for (uint256 i; i < 10; ++i) {
            vm.startPrank(drainer);
            uint256 id = bounty.createBounty("q", block.timestamp + 1, "s", 5_000e18);
            try subsidy.subsidize(id) {} catch {}
            vm.warp(block.timestamp + 1);
            bounty.refundReward(id); // Open -> Refunded, which isClosed() treats as freeing the slot
            vm.stopPrank();
        }
        // Actual on this code: the drainer is up 1,000 FORECAST, the pool is empty, no forecaster was ever paid.
        // Expected: a creator that never lets a subsidised bounty settle can extract at most one grant.
        assertLe(token.balanceOf(drainer) - start, 100e18);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {ForecastBounty} from "src/ForecastBounty.sol";
import {BountyRegistry} from "src/BountyRegistry.sol";
import {ResolverStake} from "src/ResolverStake.sol";
import {DisputeWindow} from "src/DisputeWindow.sol";
import {BountySubsidy} from "src/BountySubsidy.sol";
import {DeploymentConfig as C} from "src/DeploymentConfig.sol";

/// @notice A creator with exactly MIN_REWARD of capital drains BountySubsidy one grant per block:
///         create (deadline = now + 1) -> subsidize -> next block refundReward -> repeat.
///         Fails today (ten grants leave with zero cost); passes once a grant requires the bounty
///         to actually run (or the deadline-refund fast path no longer frees the subsidy slot).
contract SubsidyDrainTest is Test {
    LaunchToken token;
    ForecastBounty bounty;
    BountySubsidy subsidy;
    address attacker = makeAddr("attacker");
    address donor = makeAddr("donor");

    function setUp() public {
        token = new LaunchToken();
        BountyRegistry registry = new BountyRegistry();
        DisputeWindow disputes = new DisputeWindow(
            address(token), C.BOND, C.DISPUTE_WINDOW, C.disputeSigner1, C.disputeSigner2, C.disputeSigner3
        );
        ResolverStake stake = new ResolverStake(address(token), C.RESOLVER_STAKE, C.SLASH_BPS);
        bounty = new ForecastBounty(
            address(token), address(registry), address(stake), address(disputes), C.MIN_REWARD, C.BOND, C.MAX_ENTRIES
        );
        subsidy = new BountySubsidy(address(token), address(bounty), C.MIN_REWARD);
        // Requester funds the subsidy pool for ten grants.
        token.transfer(donor, 10 * C.SUBSIDY_AMOUNT);
        vm.startPrank(donor);
        token.approve(address(subsidy), type(uint256).max);
        subsidy.deposit(10 * C.SUBSIDY_AMOUNT);
        vm.stopPrank();
        // Attacker holds exactly one minimum reward.
        token.transfer(attacker, C.MIN_REWARD);
        vm.prank(attacker);
        token.approve(address(bounty), type(uint256).max);
    }

    function testOneRewardOfCapitalDrainsTheWholeSubsidyPoolInTenBlocks() public {
        vm.warp(1_000_000);
        uint256 id;
        for (uint256 i; i < 10; ++i) {
            vm.startPrank(attacker);
            if (id != 0) {
                // Previous bounty hit its deadline in this block: reclaim the reward at zero cost.
                try bounty.refundReward(id) {} catch {}
            }
            try bounty.createBounty("q", block.timestamp + 1, "src", C.MIN_REWARD) returns (uint256 newId) {
                id = newId;
                try subsidy.subsidize(id) {} catch {}
            } catch {}
            vm.stopPrank();
            vm.warp(block.timestamp + 1);
        }
        vm.prank(attacker);
        try bounty.refundReward(id) {} catch {}

        // Attacker still has the full reward capital back, and must not have extracted the pool.
        assertEq(token.balanceOf(attacker) >= C.MIN_REWARD, true, "reward capital lost");
        assertLe(subsidy.totalReleased(), C.SUBSIDY_AMOUNT, "subsidy pool drained by create/refund loop");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {ForecastBounty} from "src/ForecastBounty.sol";
import {BountyRegistry} from "src/BountyRegistry.sol";
import {ResolverStake} from "src/ResolverStake.sol";
import {DisputeWindow} from "src/DisputeWindow.sol";
import {DeploymentConfig as C} from "src/DeploymentConfig.sol";

/// A resolver that posts a wrong value occupies the single dispute slot from a second wallet in
/// the same block. The honest challenger is locked out with AlreadyDisputed, and when the panel
/// corrects the value the 20% slash and both bonds are paid to the resolver's own second wallet.
contract SelfDisputeTest is Test {
    LaunchToken token;
    ForecastBounty bounty;
    BountyRegistry registry;
    ResolverStake stake;
    DisputeWindow disputes;
    address creator = makeAddr("creator");
    address sock = makeAddr("sock");
    address alice = makeAddr("alice");
    address challenger = makeAddr("challenger");

    function setUp() public {
        token = new LaunchToken();
        registry = new BountyRegistry();
        disputes = new DisputeWindow(
            address(token), C.BOND, C.DISPUTE_WINDOW, C.disputeSigner1, C.disputeSigner2, C.disputeSigner3
        );
        stake = new ResolverStake(address(token), C.RESOLVER_STAKE, C.SLASH_BPS);
        bounty = new ForecastBounty(
            address(token), address(registry), address(stake), address(disputes), C.MIN_REWARD, C.BOND, C.MAX_ENTRIES
        );
        _fund(creator);
        _fund(sock);
        _fund(alice);
        _fund(challenger);
        vm.warp(1_700_000_000);
    }

    function _fund(address who) internal {
        token.transfer(who, 100_000e18);
        vm.startPrank(who);
        token.approve(address(bounty), type(uint256).max);
        token.approve(address(stake), type(uint256).max);
        token.approve(address(disputes), type(uint256).max);
        vm.stopPrank();
    }

    function test_wrongResolutionCostsTheResolverItsSlash() public {
        uint256 householdBefore = token.balanceOf(creator) + token.balanceOf(sock);
        vm.prank(creator);
        stake.deposit(address(bounty), C.RESOLVER_STAKE);
        vm.prank(creator);
        uint256 id = bounty.createBounty("q", block.timestamp + 1 days, "src", C.MIN_REWARD);
        vm.prank(alice);
        bounty.forecast(id, 100); // the true value
        vm.prank(sock);
        bounty.forecast(id, 50);
        vm.warp(block.timestamp + 1 days);
        vm.prank(creator);
        bounty.resolve(id, 50); // wrong on purpose: makes the sock the provisional winner
        vm.prank(sock);
        disputes.dispute(address(bounty), id, 51); // bogus correction fills the only slot

        // The honest challenger can no longer dispute at all.
        vm.prank(challenger);
        vm.expectRevert(DisputeWindow.AlreadyDisputed.selector);
        disputes.dispute(address(bounty), id, 100);

        // The panel does its job and agrees on the real value.
        vm.prank(C.disputeSigner1);
        disputes.voteValue(address(bounty), id, 100);
        vm.prank(C.disputeSigner2);
        disputes.voteValue(address(bounty), id, 100);
        bounty.finalize(id);
        assertEq(bounty.getBounty(id).winner, alice);

        // Settle every position the creator household holds.
        vm.prank(sock);
        disputes.withdrawPayout(); // 2 * BOND
        vm.prank(sock);
        bounty.withdrawBond(id);
        uint256 remaining = stake.stakeOf(address(bounty), creator);
        vm.prank(creator);
        stake.withdraw(address(bounty), remaining);
        uint256 householdAfter = token.balanceOf(creator) + token.balanceOf(sock);

        // Fails on the current code: the household is down only the reward it would have refunded
        // anyway. A wrong resolution that was successfully disputed cost it no slash and no bond.
        assertGe(
            householdBefore - householdAfter,
            C.MIN_REWARD + (C.RESOLVER_STAKE * C.SLASH_BPS) / 10_000,
            "slash recovered by the resolver's own second wallet"
        );
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {ForecastBounty} from "src/ForecastBounty.sol";
import {BountyRegistry} from "src/BountyRegistry.sol";
import {ResolverStake} from "src/ResolverStake.sol";
import {DisputeWindow} from "src/DisputeWindow.sol";
import {DeploymentConfig as C} from "src/DeploymentConfig.sol";

/// Spec: "A resolver whose resolution is successfully disputed loses SLASH_BPS (20%) of its stake, paid to the disputer."
contract SlashRoutingTest is Test {
    LaunchToken token;
    ForecastBounty bounty;
    ResolverStake stake;
    DisputeWindow disputes;
    address creator = makeAddr("creator");
    address alice = makeAddr("alice");
    address challenger = makeAddr("challenger");
    uint256 constant SLASH = (C.RESOLVER_STAKE * C.SLASH_BPS) / 10_000;

    function setUp() public {
        token = new LaunchToken();
        BountyRegistry registry = new BountyRegistry();
        disputes = new DisputeWindow(
            address(token), C.BOND, C.DISPUTE_WINDOW, C.disputeSigner1, C.disputeSigner2, C.disputeSigner3
        );
        stake = new ResolverStake(address(token), C.RESOLVER_STAKE, C.SLASH_BPS);
        bounty = new ForecastBounty(
            address(token), address(registry), address(stake), address(disputes), C.MIN_REWARD, C.BOND, C.MAX_ENTRIES
        );
        address[3] memory users = [creator, alice, challenger];
        for (uint256 i; i < 3; ++i) {
            token.transfer(users[i], 100_000e18);
            vm.startPrank(users[i]);
            token.approve(address(bounty), type(uint256).max);
            token.approve(address(stake), type(uint256).max);
            token.approve(address(disputes), type(uint256).max);
            vm.stopPrank();
        }
        vm.prank(creator);
        stake.deposit(address(bounty), C.RESOLVER_STAKE);
    }

    function _wealth(address who) internal view returns (uint256) {
        return token.balanceOf(who) + stake.stakeOf(address(bounty), who);
    }

    /// The resolver forecasts on its own bounty, resolves with a wrong value, and the panel selects a third value
    /// that the resolver's own forecast is closest to. The slash is routed to the corrected winner: the resolver.
    function testOverturnedResolverMustLoseSlashEvenWhenItIsTheCorrectedWinner() public {
        vm.prank(creator);
        uint256 id = bounty.createBounty("q", block.timestamp + 1 days, "s", C.MIN_REWARD);
        vm.prank(creator);
        bounty.forecast(id, 50);
        vm.prank(alice);
        bounty.forecast(id, 0);
        vm.warp(block.timestamp + 1 days);
        vm.prank(creator);
        bounty.resolve(id, 0); // wrong: alice provisionally wins
        vm.prank(challenger);
        disputes.dispute(address(bounty), id, 100); // corrected value 100
        vm.prank(C.disputeSigner1);
        disputes.voteValue(address(bounty), id, 49); // panel: true value 49
        vm.prank(C.disputeSigner2);
        disputes.voteValue(address(bounty), id, 49);
        uint256 before = _wealth(creator);
        bounty.finalize(id);
        assertEq(uint8(disputes.getCase(address(bounty), id).outcome), uint8(DisputeWindow.Outcome.Overturned));
        assertEq(bounty.getBounty(id).winner, creator);
        // Expected: the successfully disputed resolver loses 20% of its stake. Actual: the slash comes back to it.
        assertEq(_wealth(creator), before - SLASH, "overturned resolver kept its slash");
    }

    /// An overturned resolution of a bounty with no entries has no corrected winner, so no slash happens at all.
    function testOverturnedResolutionOfEmptyBountyMustStillSlash() public {
        vm.prank(creator);
        uint256 id = bounty.createBounty("q", block.timestamp + 1 days, "s", C.MIN_REWARD);
        vm.warp(block.timestamp + 1 days);
        vm.prank(creator);
        bounty.resolve(id, 5);
        vm.prank(challenger);
        disputes.dispute(address(bounty), id, 7);
        vm.prank(C.disputeSigner1);
        disputes.voteValue(address(bounty), id, 9);
        vm.prank(C.disputeSigner3);
        disputes.voteValue(address(bounty), id, 9);
        bounty.finalize(id);
        assertEq(uint8(disputes.getCase(address(bounty), id).outcome), uint8(DisputeWindow.Outcome.Overturned));
        // Expected: stake reduced by the slash. Actual: the full stake is intact.
        assertEq(stake.stakeOf(address(bounty), creator), C.RESOLVER_STAKE - SLASH, "overturned resolver unslashed");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {ForecastBounty} from "src/ForecastBounty.sol";
import {BountyRegistry} from "src/BountyRegistry.sol";
import {ResolverStake} from "src/ResolverStake.sol";
import {DisputeWindow} from "src/DisputeWindow.sol";
import {DeploymentConfig as C} from "src/DeploymentConfig.sol";

/// Spec: "A resolver whose resolution is successfully disputed loses SLASH_BPS (20%) of its stake, paid to the disputer."
contract SlashRoutingTest is Test {
    LaunchToken token;
    ForecastBounty bounty;
    ResolverStake stake;
    DisputeWindow disputes;
    address creator = makeAddr("creator");
    address alice = makeAddr("alice");
    address challenger = makeAddr("challenger");
    uint256 constant SLASH = (C.RESOLVER_STAKE * C.SLASH_BPS) / 10_000;

    function setUp() public {
        token = new LaunchToken();
        BountyRegistry registry = new BountyRegistry();
        disputes = new DisputeWindow(
            address(token), C.BOND, C.DISPUTE_WINDOW, C.disputeSigner1, C.disputeSigner2, C.disputeSigner3
        );
        stake = new ResolverStake(address(token), C.RESOLVER_STAKE, C.SLASH_BPS);
        bounty = new ForecastBounty(
            address(token), address(registry), address(stake), address(disputes), C.MIN_REWARD, C.BOND, C.MAX_ENTRIES
        );
        address[3] memory users = [creator, alice, challenger];
        for (uint256 i; i < 3; ++i) {
            token.transfer(users[i], 100_000e18);
            vm.startPrank(users[i]);
            token.approve(address(bounty), type(uint256).max);
            token.approve(address(stake), type(uint256).max);
            token.approve(address(disputes), type(uint256).max);
            vm.stopPrank();
        }
        vm.prank(creator);
        stake.deposit(address(bounty), C.RESOLVER_STAKE);
    }

    function _wealth(address who) internal view returns (uint256) {
        return token.balanceOf(who) + stake.stakeOf(address(bounty), who);
    }

    /// The resolver forecasts on its own bounty, resolves with a wrong value, and the panel selects a third value
    /// that the resolver's own forecast is closest to. The slash is routed to the corrected winner: the resolver.
    function testOverturnedResolverMustLoseSlashEvenWhenItIsTheCorrectedWinner() public {
        vm.prank(creator);
        uint256 id = bounty.createBounty("q", block.timestamp + 1 days, "s", C.MIN_REWARD);
        vm.prank(creator);
        bounty.forecast(id, 50);
        vm.prank(alice);
        bounty.forecast(id, 0);
        vm.warp(block.timestamp + 1 days);
        vm.prank(creator);
        bounty.resolve(id, 0); // wrong: alice provisionally wins
        vm.prank(challenger);
        disputes.dispute(address(bounty), id, 100); // corrected value 100
        vm.prank(C.disputeSigner1);
        disputes.voteValue(address(bounty), id, 49); // panel: true value 49
        vm.prank(C.disputeSigner2);
        disputes.voteValue(address(bounty), id, 49);
        uint256 before = _wealth(creator);
        bounty.finalize(id);
        assertEq(uint8(disputes.getCase(address(bounty), id).outcome), uint8(DisputeWindow.Outcome.Overturned));
        assertEq(bounty.getBounty(id).winner, creator);
        // Expected: the successfully disputed resolver loses 20% of its stake. Actual: the slash comes back to it.
        assertEq(_wealth(creator), before - SLASH, "overturned resolver kept its slash");
    }

    /// An overturned resolution of a bounty with no entries has no corrected winner, so no slash happens at all.
    function testOverturnedResolutionOfEmptyBountyMustStillSlash() public {
        vm.prank(creator);
        uint256 id = bounty.createBounty("q", block.timestamp + 1 days, "s", C.MIN_REWARD);
        vm.warp(block.timestamp + 1 days);
        vm.prank(creator);
        bounty.resolve(id, 5);
        vm.prank(challenger);
        disputes.dispute(address(bounty), id, 7);
        vm.prank(C.disputeSigner1);
        disputes.voteValue(address(bounty), id, 9);
        vm.prank(C.disputeSigner3);
        disputes.voteValue(address(bounty), id, 9);
        bounty.finalize(id);
        assertEq(uint8(disputes.getCase(address(bounty), id).outcome), uint8(DisputeWindow.Outcome.Overturned));
        // Expected: stake reduced by the slash. Actual: the full stake is intact.
        assertEq(stake.stakeOf(address(bounty), creator), C.RESOLVER_STAKE - SLASH, "overturned resolver unslashed");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {ForecastBounty} from "src/ForecastBounty.sol";
import {BountyRegistry} from "src/BountyRegistry.sol";
import {ResolverStake} from "src/ResolverStake.sol";
import {DisputeWindow} from "src/DisputeWindow.sol";
import {DeploymentConfig as C} from "src/DeploymentConfig.sol";

/// A resolver that forecast on its own bounty resolves to a wrong value. A challenger disputes with a
/// value the panel does not adopt; the panel agrees on a third value for which the resolver's own entry
/// is closest. The outcome is Overturned, yet the 20% slash is transferred to the resolver itself.
contract ProofResolverSelfSlash is Test {
    LaunchToken token;
    ForecastBounty bounty;
    BountyRegistry registry;
    ResolverStake stake;
    DisputeWindow disputes;
    address creator = makeAddr("creator");
    address alice = makeAddr("alice");
    address challenger = makeAddr("challenger");

    function setUp() public {
        token = new LaunchToken();
        registry = new BountyRegistry();
        disputes = new DisputeWindow(
            address(token), C.BOND, C.DISPUTE_WINDOW, C.disputeSigner1, C.disputeSigner2, C.disputeSigner3
        );
        stake = new ResolverStake(address(token), C.RESOLVER_STAKE, C.SLASH_BPS);
        bounty = new ForecastBounty(
            address(token), address(registry), address(stake), address(disputes), C.MIN_REWARD, C.BOND, C.MAX_ENTRIES
        );
        _fund(creator);
        _fund(alice);
        _fund(challenger);
    }

    function _fund(address who) internal {
        token.transfer(who, 100_000e18);
        vm.startPrank(who);
        token.approve(address(bounty), type(uint256).max);
        token.approve(address(stake), type(uint256).max);
        token.approve(address(disputes), type(uint256).max);
        vm.stopPrank();
    }

    function testOverturnedResolverLosesItsSlash() public {
        vm.prank(creator);
        stake.deposit(address(bounty), C.RESOLVER_STAKE);
        vm.prank(creator);
        uint256 id = bounty.createBounty("q", block.timestamp + 1 days, "s", C.MIN_REWARD);
        vm.prank(creator);
        bounty.forecast(id, 50);
        vm.prank(alice);
        bounty.forecast(id, 0);
        vm.warp(block.timestamp + 1 days);
        vm.prank(creator);
        bounty.resolve(id, 0); // wrong resolution: alice is the provisional winner
        vm.prank(challenger);
        disputes.dispute(address(bounty), id, 100);

        // Resolver's position after resolving: wallet + stake. The resolution bond is already spent.
        uint256 resolverBefore = token.balanceOf(creator) + stake.stakeOf(address(bounty), creator);

        vm.prank(C.disputeSigner1);
        disputes.voteValue(address(bounty), id, 49);
        vm.prank(C.disputeSigner2);
        disputes.voteValue(address(bounty), id, 49);
        bounty.finalize(id);

        assertEq(
            uint8(disputes.getCase(address(bounty), id).outcome),
            uint8(DisputeWindow.Outcome.Overturned),
            "panel overturned the resolution"
        );
        uint256 slash = C.RESOLVER_STAKE * C.SLASH_BPS / 10_000;
        uint256 resolverAfter = token.balanceOf(creator) + stake.stakeOf(address(bounty), creator);
        // Expected: a successfully disputed resolver loses the slash. Actual on this tree: the slash is
        // transferred to the resolver's own wallet because its entry is the corrected winner.
        assertEq(resolverBefore - resolverAfter, slash, "overturned resolver must lose SLASH_BPS of its stake");
    }
}