// 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 {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ProjectRegistry, IIntake} from "src/ProjectRegistry.sol";
import {OracleAttestation} from "src/oracle/OracleAttestation.sol";

contract PlainIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {}

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

/// @dev A project whose owner() is the registry itself (an owner can hand a project to any address).
contract RegistryOwnedProject {
    address public owner;

    constructor(address owner_) {
        owner = owner_;
    }
}

contract Intake is IIntake {
    bytes32 internal constant ACTION = "oracle.request@oracle-1";

    struct Req {
        address target;
        bytes4 selector;
        bool completed;
    }

    mapping(bytes32 => Req) internal reqs;
    uint256 internal n;
    bytes32 public lastId;

    function priceOf(bytes32 action, address) external pure returns (uint256) {
        return action == ACTION ? 0.5e18 : 0;
    }

    function requestWithFailure(bytes32, bytes calldata, Callback calldata cb, bytes4, address asset, uint256 amount)
        external
        returns (bytes32 id)
    {
        IERC20(asset).transferFrom(msg.sender, address(0x7EA5), amount);
        id = keccak256(abi.encode(++n));
        reqs[id] = Req(cb.target, cb.selector, false);
        lastId = id;
    }

    function requests(bytes32 id) external view returns (address, address, bytes4, bool) {
        return (address(0), reqs[id].target, reqs[id].selector, reqs[id].completed);
    }

    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata sig) external returns (bool ok) {
        reqs[id].completed = true;
        (ok,) = reqs[id].target.call{gas: 200_000}(abi.encodeWithSelector(reqs[id].selector, id, a, sig));
    }
}

contract RegistrySelfBeneficiaryTest is Test {
    uint256 internal constant SIGNER_KEY = 0xA11CE;
    uint256 internal constant BOND = 20e18;

    PlainIMD internal imd;
    Intake internal intake;
    ProjectRegistry internal registry;
    RegistryOwnedProject internal project;
    address internal applicant = address(0xA1);
    address internal challenger = address(0xC1);

    function setUp() public {
        vm.warp(1_700_000_000);
        imd = new PlainIMD();
        intake = new Intake();
        registry = new ProjectRegistry(
            address(intake), address(imd), address(0x57ac), vm.addr(SIGNER_KEY), 1, BOND, 7 days
        );
        project = new RegistryOwnedProject(address(registry));
        imd.mint(applicant, 10e18);
        imd.mint(challenger, 100e18);
        vm.prank(applicant);
        imd.approve(address(registry), type(uint256).max);
        vm.prank(challenger);
        imd.approve(address(registry), type(uint256).max);
        imd.mint(address(project), 10e18);
        vm.prank(address(project));
        imd.approve(address(registry), type(uint256).max);
    }

    function _yes(uint256 nonce) internal view returns (OracleAttestation.Attestation memory a, bytes memory sig) {
        a = OracleAttestation.Attestation({
            requestId: bytes32(nonce),
            chainId: 1,
            questionHash: bytes32(uint256(0x11)),
            answerType: 0,
            answer: abi.encode(true),
            figure: 0,
            fromBlock: 0,
            toBlock: 0,
            blockHash: bytes32(0),
            panelJobId: bytes32(0),
            panelSize: 15,
            quorum: 11,
            agreed: 11,
            issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 1 days)
        });
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, registry.attestationDigest(a));
        sig = abi.encodePacked(r, s, v);
    }

    /// @dev Expected: the registry refuses itself as a beneficiary (or records the bond as owed so
    /// someone can claim it). Actual: the application is accepted, and a defended challenge pays the
    /// 20 IMD bond to the registry's own balance with no bondOwed entry, so nobody can ever take it.
    function test_bondPaidToRegistryItselfIsLostForever() public {
        // The registry is the project's owner, so only it (or the project) may apply: the project applies.
        vm.prank(address(project));
        registry.applyListing(address(project), "Venue", "https://venue.example/src", 50, address(registry));
        (OracleAttestation.Attestation memory a, bytes memory sig) = _yes(1);
        assertTrue(intake.deliver(intake.lastId(), a, sig));
        assertTrue(registry.isListed(address(project)));

        vm.warp(block.timestamp + 7 days);
        uint256 before = imd.balanceOf(address(registry));
        vm.prank(challenger);
        registry.challenge(address(project), "it does not meet the rules");
        (a, sig) = _yes(2);
        assertTrue(intake.deliver(intake.lastId(), a, sig));
        assertTrue(registry.isListed(address(project)), "defended");

        // The bond now sits in the registry with no owner: not owed to anyone, and no function moves it.
        assertEq(imd.balanceOf(address(registry)), before + BOND, "bond stays in the registry");
        assertEq(registry.bondOwed(address(registry)), 0, "and is not recorded as owed");
        // What should hold instead: the registry's balance is fully explained by open bonds and bondOwed.
        assertEq(imd.balanceOf(address(registry)), 0, "registry holds IMD nobody can claim");
    }

    function test_setBeneficiaryAcceptsRegistryItself() public {
        RegistryOwnedProject p2 = new RegistryOwnedProject(address(0));
        vm.prank(applicant);
        registry.applyListing(address(p2), "Venue", "https://venue.example/src", 50, applicant);
        (OracleAttestation.Attestation memory a, bytes memory sig) = _yes(3);
        assertTrue(intake.deliver(intake.lastId(), a, sig));
        vm.prank(applicant);
        vm.expectRevert(ProjectRegistry.ZeroAddress.selector);
        registry.setBeneficiary(address(p2), address(registry));
    }
}

// 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 {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ProjectRegistry, IIntake} from "src/ProjectRegistry.sol";
import {OracleAttestation} from "src/oracle/OracleAttestation.sol";

/// @dev An IMD stand-in that refuses transfers to one blocked wallet (the way a token with a
/// block list would), so a bond becomes `bondOwed` instead of being paid at once.
contract BlockingIMD is ERC20 {
    address public blocked;

    constructor() ERC20("IMD", "IMD") {}

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

    function setBlocked(address who) external {
        blocked = who;
    }

    function _update(address from, address to, uint256 value) internal override {
        require(to != blocked, "blocked");
        super._update(from, to, value);
    }
}

contract MinimalIntake is IIntake {
    bytes32 public constant ACTION = "oracle.request@oracle-1";
    uint256 public count;
    bytes32 public lastId;

    struct Req {
        address payer;
        address target;
        bytes4 selector;
        bool completed;
    }

    mapping(bytes32 => Req) internal _reqs;

    function priceOf(bytes32 action, address) external pure returns (uint256) {
        return action == ACTION ? 0.5e18 : 0;
    }

    function requestWithFailure(
        bytes32,
        bytes calldata,
        Callback calldata callback,
        bytes4,
        address asset,
        uint256 amount
    ) external returns (bytes32 id) {
        IERC20(asset).transferFrom(msg.sender, address(0x7EA5), amount);
        id = keccak256(abi.encode(address(this), ++count));
        _reqs[id] = Req(msg.sender, callback.target, callback.selector, false);
        lastId = id;
    }

    function requests(bytes32 id) external view returns (address, address, bytes4, bool) {
        Req storage r = _reqs[id];
        return (r.payer, r.target, r.selector, r.completed);
    }

    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata sig)
        external
        returns (bool ok)
    {
        Req storage r = _reqs[id];
        r.completed = true;
        (ok,) = r.target.call{gas: 200_000}(abi.encodeWithSelector(r.selector, id, a, sig));
    }
}

contract Project {}

contract ClaimBondSelfTransferTest is Test {
    uint256 internal constant SIGNER_KEY = 0xA11CE;
    uint256 internal constant BOND = 20e18;
    uint64 internal constant COOLDOWN = 7 days;

    BlockingIMD internal imd;
    MinimalIntake internal intake;
    ProjectRegistry internal reg;
    address internal project;
    address internal owner = address(0xB0B);
    address internal challenger = address(0xC0FFEE);

    function setUp() public virtual {
        imd = new BlockingIMD();
        intake = new MinimalIntake();
        reg = new ProjectRegistry(
            address(intake), address(imd), address(0x57AC), vm.addr(SIGNER_KEY), 1, BOND, COOLDOWN
        );
        project = address(new Project());
        imd.mint(owner, 100e18);
        imd.mint(challenger, 100e18);
        vm.prank(owner);
        imd.approve(address(reg), type(uint256).max);
        vm.prank(challenger);
        imd.approve(address(reg), type(uint256).max);
    }

    function _list() internal {
        vm.prank(owner);
        bytes32 id = reg.applyListing(project, "Proj", "https://example.org/p", 50, owner);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256("oracle-request-1");
        a.chainId = 1;
        a.questionHash = keccak256("q");
        a.answerType = 0;
        a.answer = abi.encode(true);
        a.fromBlock = uint64(block.number);
        a.toBlock = uint64(block.number);
        a.panelJobId = keccak256("job");
        a.panelSize = 15;
        a.quorum = 11;
        a.agreed = 11;
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, reg.attestationDigest(a));
        assertTrue(intake.deliver(id, a, abi.encodePacked(r, s, v)));
        assertTrue(reg.isListed(project));
    }

    /// @dev A challenger the token blocks gets its bond recorded in `bondOwed` when the question
    /// expires. `claimBond(address(registry))` then zeroes the debt with a token self-transfer:
    /// the 20 IMD stay in the registry and nobody can ever take them out. `applyListing` and
    /// `setBeneficiary` refuse the registry as a recipient for exactly this reason; `claimBond`
    /// does not. The test expects the same refusal and so fails on the current code.
    function test_claimBondToRegistryStrandsTheBond() public {
        _list();
        vm.warp(block.timestamp + COOLDOWN);
        vm.prank(challenger);
        reg.challengeForBeneficiary(project, "Check the fee guard.", owner);
        assertEq(imd.balanceOf(address(reg)), BOND, "bond escrowed");

        imd.setBlocked(challenger);
        vm.warp(block.timestamp + 1 days + 1);
        reg.expire(project);
        assertEq(reg.bondOwed(challenger), BOND, "bond owed to the blocked challenger");

        vm.prank(challenger);
        vm.expectRevert(ProjectRegistry.InvalidBeneficiary.selector);
        reg.claimBond(address(reg));

        // What should hold once the registry refuses itself as a claim target:
        assertEq(reg.bondOwed(challenger), BOND, "debt untouched");
        assertEq(imd.balanceOf(address(reg)), BOND, "bond still claimable");
    }
}

// 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 {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ProjectRegistry, IIntake} from "src/ProjectRegistry.sol";
import {OracleAttestation} from "src/oracle/OracleAttestation.sol";

contract BlockIMD is ERC20 {
    mapping(address => bool) public blocked;

    constructor() ERC20("IMD", "IMD") {}

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

    function setBlocked(address w, bool on) external {
        blocked[w] = on;
    }

    function _update(address from, address to, uint256 v) internal override {
        require(!blocked[to], "blocked");
        super._update(from, to, v);
    }
}

contract Intake is IIntake {
    struct Req {
        address target;
        bytes4 sel;
        bytes4 fail;
        bool done;
    }

    mapping(bytes32 => Req) public r;
    uint256 n;

    function priceOf(bytes32, address) external pure returns (uint256) {
        return 0.5e18;
    }

    function requestWithFailure(bytes32, bytes calldata, Callback calldata cb, bytes4 f, address asset, uint256 amt)
        external
        returns (bytes32 id)
    {
        IERC20(asset).transferFrom(msg.sender, address(0xBEEF), amt);
        id = keccak256(abi.encode(++n));
        r[id] = Req(cb.target, cb.selector, f, false);
    }

    function requests(bytes32 id) external view returns (address, address, bytes4, bool) {
        return (address(0), r[id].target, r[id].sel, r[id].done);
    }

    function fail(bytes32 id) external {
        r[id].done = true;
        (bool ok,) = r[id].target.call{gas: 200_000}(
            abi.encodeWithSelector(r[id].fail, id, uint8(2), bytes32("disagreed"), uint16(0), uint16(0), bytes(""))
        );
        require(ok);
    }
}

contract Project {
    function owner() external pure returns (address) {
        return address(0);
    }
}

/// Shows that `claimBond(address(this))` moves an owed bond into the registry itself, where no
/// function can ever release it. Fails on the current code (the transfer succeeds and the bond is
/// stranded); passes once `claimBond` refuses the registry's own address like `applyListing` and
/// `setBeneficiary` already do.
contract ClaimBondSelfTest is Test {
    BlockIMD imd = new BlockIMD();
    Intake intake = new Intake();
    ProjectRegistry reg;
    address challenger = makeAddr("challenger");
    address project = address(new Project());

    function setUp() public {
        reg = new ProjectRegistry(address(intake), address(imd), address(0x5747), address(0xA11CE), 1, 20e18, 7 days);
        imd.mint(challenger, 100e18);
        vm.prank(challenger);
        imd.approve(address(reg), type(uint256).max);
        // list the project directly by storage so a challenge can be opened
        // slot 0 of _projects[project]: ask(0) listed(1) at byte 1
        bytes32 slot = keccak256(abi.encode(project, uint256(5)));
        bytes32 word = vm.load(address(reg), slot);
        word = bytes32(uint256(word) | (uint256(1) << 8));
        vm.store(address(reg), slot, word);
        assertTrue(reg.isListed(project));
    }

    function test_claimBondToRegistryStrandsBond() public {
        vm.prank(challenger);
        bytes32 id = reg.challengeForBeneficiary(project, "reason", address(0));
        imd.setBlocked(challenger, true);
        intake.fail(id); // bond refused -> owed
        assertEq(reg.bondOwed(challenger), 20e18);
        imd.setBlocked(challenger, false);

        uint256 held = imd.balanceOf(address(reg));
        vm.prank(challenger);
        vm.expectRevert();
        reg.claimBond(address(reg));

        // (expected after the fix) the bond is still owed, still claimable elsewhere, and the
        // registry's balance did not absorb it.
        assertEq(reg.bondOwed(challenger), 20e18);
        assertEq(imd.balanceOf(address(reg)), held);
        vm.prank(challenger);
        reg.claimBond(challenger);
        assertEq(imd.balanceOf(challenger), 100e18 - 0.5e18);
        assertEq(imd.balanceOf(address(reg)), 0);
    }
}

// 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 {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ProjectRegistry, IIntake} from "src/ProjectRegistry.sol";
import {OracleAttestation} from "src/oracle/OracleAttestation.sol";

/// @dev An IMD stand-in that refuses transfers to one blocked wallet (the way a token with a
/// block list would), so a bond becomes `bondOwed` instead of being paid at once.
contract BlockingIMD is ERC20 {
    address public blocked;

    constructor() ERC20("IMD", "IMD") {}

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

    function setBlocked(address who) external {
        blocked = who;
    }

    function _update(address from, address to, uint256 value) internal override {
        require(to != blocked, "blocked");
        super._update(from, to, value);
    }
}

contract MinimalIntake is IIntake {
    bytes32 public constant ACTION = "oracle.request@oracle-1";
    uint256 public count;
    bytes32 public lastId;

    struct Req {
        address payer;
        address target;
        bytes4 selector;
        bool completed;
    }

    mapping(bytes32 => Req) internal _reqs;

    function priceOf(bytes32 action, address) external pure returns (uint256) {
        return action == ACTION ? 0.5e18 : 0;
    }

    function requestWithFailure(
        bytes32,
        bytes calldata,
        Callback calldata callback,
        bytes4,
        address asset,
        uint256 amount
    ) external returns (bytes32 id) {
        IERC20(asset).transferFrom(msg.sender, address(0x7EA5), amount);
        id = keccak256(abi.encode(address(this), ++count));
        _reqs[id] = Req(msg.sender, callback.target, callback.selector, false);
        lastId = id;
    }

    function requests(bytes32 id) external view returns (address, address, bytes4, bool) {
        Req storage r = _reqs[id];
        return (r.payer, r.target, r.selector, r.completed);
    }

    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata sig)
        external
        returns (bool ok)
    {
        Req storage r = _reqs[id];
        r.completed = true;
        (ok,) = r.target.call{gas: 200_000}(abi.encodeWithSelector(r.selector, id, a, sig));
    }
}

contract Project {}

contract ClaimBondSelfTransferTest is Test {
    uint256 internal constant SIGNER_KEY = 0xA11CE;
    uint256 internal constant BOND = 20e18;
    uint64 internal constant COOLDOWN = 7 days;

    BlockingIMD internal imd;
    MinimalIntake internal intake;
    ProjectRegistry internal reg;
    address internal project;
    address internal owner = address(0xB0B);
    address internal challenger = address(0xC0FFEE);

    function setUp() public virtual {
        imd = new BlockingIMD();
        intake = new MinimalIntake();
        reg = new ProjectRegistry(
            address(intake), address(imd), address(0x57AC), vm.addr(SIGNER_KEY), 1, BOND, COOLDOWN
        );
        project = address(new Project());
        imd.mint(owner, 100e18);
        imd.mint(challenger, 100e18);
        vm.prank(owner);
        imd.approve(address(reg), type(uint256).max);
        vm.prank(challenger);
        imd.approve(address(reg), type(uint256).max);
    }

    function _list() internal {
        vm.prank(owner);
        bytes32 id = reg.applyListing(project, "Proj", "https://example.org/p", 50, owner);
        OracleAttestation.Attestation memory a;
        a.requestId = keccak256("oracle-request-1");
        a.chainId = 1;
        a.questionHash = keccak256("q");
        a.answerType = 0;
        a.answer = abi.encode(true);
        a.fromBlock = uint64(block.number);
        a.toBlock = uint64(block.number);
        a.panelJobId = keccak256("job");
        a.panelSize = 15;
        a.quorum = 11;
        a.agreed = 11;
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, reg.attestationDigest(a));
        assertTrue(intake.deliver(id, a, abi.encodePacked(r, s, v)));
        assertTrue(reg.isListed(project));
    }

    /// @dev A challenger the token blocks gets its bond recorded in `bondOwed` when the question
    /// expires. `claimBond(address(registry))` then zeroes the debt with a token self-transfer:
    /// the 20 IMD stay in the registry and nobody can ever take them out. `applyListing` and
    /// `setBeneficiary` refuse the registry as a recipient for exactly this reason; `claimBond`
    /// does not. The test expects the same refusal and so fails on the current code.
    function test_claimBondToRegistryStrandsTheBond() public {
        _list();
        vm.warp(block.timestamp + COOLDOWN);
        vm.prank(challenger);
        reg.challengeForBeneficiary(project, "Check the fee guard.", owner);
        assertEq(imd.balanceOf(address(reg)), BOND, "bond escrowed");

        imd.setBlocked(challenger);
        vm.warp(block.timestamp + 1 days + 1);
        reg.expire(project);
        assertEq(reg.bondOwed(challenger), BOND, "bond owed to the blocked challenger");

        vm.prank(challenger);
        vm.expectRevert(ProjectRegistry.InvalidBeneficiary.selector);
        reg.claimBond(address(reg));

        // What should hold once the registry refuses itself as a claim target:
        assertEq(reg.bondOwed(challenger), BOND, "debt untouched");
        assertEq(imd.balanceOf(address(reg)), BOND, "bond still claimable");
    }
}