// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;
import {Test} from "forge-std/Test.sol";
import {PublisherGateway} from "src/PublisherGateway.sol";
import {FINCR} from "src/FINCR.sol";
import {FounderFundedMining} from "src/FounderFundedMining.sol";
import {RobinhoodJobController, INativeJobMining} from "src/RobinhoodJobController.sol";
import {FinancierMiningWithMarket} from "src/FinancierMiningWithMarket.sol";
import {AttestedAgentRounds as Rounds} from "src/AttestedAgentRounds.sol";
import {IAgentWorkVerifier as W} from "src/interfaces/IAgentWorkVerifier.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface ISeatIntake {
    function setPrice(bytes32, address, uint256) external;
    function setPayTo(address) external;
    function setWriter(address) external;
    function setCallbackGas(uint64) external;
    function complete(bytes32, uint8, bytes32, string calldata, bytes calldata) external;
}

/// A current financier commissions a second job one second before period end. The publisher
/// cannot admit/bind it before `c.end` (bindJob requires block.timestamp < c.end), so
/// RobinhoodJobController.finalizeRound reverts for the whole period and the honest agent's
/// already-accepted work is quarantined on expiry. Fails on this code; passes once a late
/// commission is either refused or no longer able to block settlement of the other jobs.
contract LateCommissionBlocksRoundTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant INTAKE = 0xa43e6F75ee006411F79Ac1C84120606C2330DE82;
    address constant FOUNDER = 0xbcF19c0821A245383c127570615896Abac9e424F;
    address constant ALICE = address(101);
    address constant OWNER = address(301);
    address constant ATTESTER = address(700);
    bytes32 constant JOB = keccak256("SYNTHETIC FINANCIER job UUID");
    PublisherGateway gateway;
    FINCR token;
    FounderFundedMining miner;
    RobinhoodJobController controller;
    Rounds rounds;
    bytes32 request;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.etch(IMD, vm.parseBytes(vm.readLine("test/fixtures/task16/imd-runtime.hex")));
        vm.etch(INTAKE, vm.parseBytes(vm.readLine("test/fixtures/task16/intake-runtime.hex")));
        vm.etch(0x8366a39CC670B4001A1121B8F6A443A643e40951, vm.parseBytes(vm.readLine("test/fixtures/task23/manager-runtime.hex")));
        vm.etch(0x19Bec7C2E1b2aadAf67b259744751a9960d66000, vm.parseBytes(vm.readLine("test/fixtures/task23/guard-runtime.hex")));
        vm.store(IMD, 0, bytes32(uint256(uint160(address(this)))));
        (bool ok,) = IMD.call(abi.encodeWithSignature("enableTransfers()"));
        require(ok);
        vm.store(INTAKE, 0, bytes32(uint256(uint160(address(this)))));
        ISeatIntake(INTAKE).setPrice("job.open@job-1", IMD, 0.5 ether);
        ISeatIntake(INTAKE).setPayTo(address(800));
        ISeatIntake(INTAKE).setWriter(address(this));
        ISeatIntake(INTAKE).setCallbackGas(200_000);
        token = new FINCR(1e27);
        vm.prank(FOUNDER);
        gateway = new PublisherGateway(ATTESTER);
        vm.prank(FOUNDER);
        controller = new RobinhoodJobController(address(gateway));
        vm.prank(FOUNDER);
        gateway.bindController(controller, address(controller).codehash);
        vm.prank(FOUNDER);
        gateway.setPaused(false);
        FinancierMiningWithMarket.Config memory c = FinancierMiningWithMarket.Config(
            address(token), IMD, 1e27, 10 ether, 0.5 ether, FOUNDER, 0x74421cdb9e6ad159358c4af7C59CFAE472A0541e,
            address(controller), controller.SPECIFICATION(), 1 days, 1 days, 1 hours, 0.1 ether
        );
        vm.prank(FOUNDER);
        miner = new FounderFundedMining(c);
        vm.prank(FOUNDER);
        controller.bindMiner(INativeJobMining(address(miner)));
        rounds = miner.agentRounds();
        deal(IMD, ALICE, 100 ether);
        vm.prank(ALICE);
        IERC20(IMD).approve(address(miner), type(uint256).max);
        token.transfer(address(miner), 4e26);
        vm.prank(FOUNDER);
        miner.arm();
        vm.prank(ALICE);
        miner.bid(0, 10 ether, block.timestamp);
    }

    function testLateCommissionCannotQuarantineHonestAcceptedWork() public {
        // Honest path: job commissioned, admitted and bound early in the period, completed successfully.
        vm.prank(ALICE);
        request = controller.commission(0, 0);
        bytes32 bodyHash = keccak256(controller.body(0, 0));
        vm.prank(ATTESTER);
        gateway.bindJob(0, Rounds.Admission(request, JOB, bodyHash, block.timestamp, block.timestamp, keccak256("admission")));
        vm.warp(block.timestamp + 10);
        bytes32 hash = keccak256("SYNTHETIC nonempty completed result");
        ISeatIntake(INTAKE).complete(request, 0, hash, "uri", abi.encode(request, hash, "uri"));

        W.Context memory c = rounds.context(0);
        // Financier (any bidder) commissions another category one second before period end.
        // Work budget (protocol IMD) pays; the publisher cannot bind it before c.end.
        vm.warp(c.end - 1);
        vm.prank(ALICE);
        try controller.commission(0, 1) {} catch {}

        // Period closes; publisher locks snapshot and finalizes with the one honest accepted agent.
        vm.warp(c.end);
        Rounds.Snapshot memory s = Rounds.Snapshot(
            26_000_000, keccak256("hdr"), c.end - 15 minutes, keccak256("owners"), keccak256("accepted")
        );
        vm.prank(ATTESTER);
        gateway.lockSnapshot(0, s);
        W.Contribution[] memory a = new W.Contribution[](1);
        Rounds.OwnerEvidence[] memory o = new Rounds.OwnerEvidence[](1);
        uint256 boundAt = rounds.jobBoundAt(JOB);
        a[0] = W.Contribution(
            1, rounds.IDENTITY_REGISTRY(), 51_000, OWNER, OWNER, JOB, keccak256("receipt"), keccak256("submission"),
            keccak256("artifact"), boundAt + 2, s.timestamp, c.deadline
        );
        o[0] = Rounds.OwnerEvidence(100, false, 0, 0, boundAt + 1);
        bytes32 commitment = rounds.settlementCommitment(0, a, s, o);
        vm.prank(ATTESTER);
        gateway.finalizeRound(0, a, s, o, commitment); // reverts InvalidSettlement on current code
        vm.prank(OWNER);
        assertEq(rounds.claim(0), miner.agentAllocation(0, 1 days));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;
import {Test} from "forge-std/Test.sol";
import {PublisherGateway} from "src/PublisherGateway.sol";
import {FINCR} from "src/FINCR.sol";
import {FounderFundedMining} from "src/FounderFundedMining.sol";
import {RobinhoodJobController, INativeJobMining} from "src/RobinhoodJobController.sol";
import {FinancierMiningWithMarket} from "src/FinancierMiningWithMarket.sol";
import {AttestedAgentRounds as Rounds} from "src/AttestedAgentRounds.sol";

/// Deployment order is only enforced one way: PublisherGateway.bindController rejects a controller
/// that already has a miner, but RobinhoodJobController.bindMiner and FounderFundedMining.arm never
/// check that the immutable publisher (the gateway) has actually been bound to this controller.
/// If the founder binds the miner first, the gateway can never bind, no publisher call can ever
/// reach the controller, every agent round expires to quarantine, and 80M FINCR (20% of the
/// 400M reserve) is stranded in the miner with no recovery path. Fails on this code; passes once
/// bindMiner (or arm) refuses while the gateway is not bound to this controller.
contract MisorderedBindingStrandsAgentsTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant INTAKE = 0xa43e6F75ee006411F79Ac1C84120606C2330DE82;
    address constant FOUNDER = 0xbcF19c0821A245383c127570615896Abac9e424F;
    address constant OPERATOR = 0x174818c4FEcB65472522Ff8C7677F5A567cB3020;

    function testMinerCannotArmWhileGatewayIsUnboundToController() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.etch(IMD, vm.parseBytes(vm.readLine("test/fixtures/task16/imd-runtime.hex")));
        vm.etch(INTAKE, vm.parseBytes(vm.readLine("test/fixtures/task16/intake-runtime.hex")));
        vm.etch(0x8366a39CC670B4001A1121B8F6A443A643e40951, vm.parseBytes(vm.readLine("test/fixtures/task23/manager-runtime.hex")));
        vm.etch(0x19Bec7C2E1b2aadAf67b259744751a9960d66000, vm.parseBytes(vm.readLine("test/fixtures/task23/guard-runtime.hex")));
        FINCR token = new FINCR(1e27);
        vm.prank(FOUNDER);
        PublisherGateway gateway = new PublisherGateway(OPERATOR);
        vm.prank(FOUNDER);
        RobinhoodJobController controller = new RobinhoodJobController(address(gateway));
        FinancierMiningWithMarket.Config memory c = FinancierMiningWithMarket.Config(
            address(token), IMD, 1e27, 10 ether, 0.5 ether, FOUNDER, 0x74421cdb9e6ad159358c4af7C59CFAE472A0541e,
            address(controller), controller.SPECIFICATION(), 1 days, 1 days, 1 hours, 0.1 ether
        );
        vm.prank(FOUNDER);
        FounderFundedMining miner = new FounderFundedMining(c);

        // Wrong order: miner bound before the gateway binding.
        vm.prank(FOUNDER);
        try controller.bindMiner(INativeJobMining(address(miner))) {} catch {}

        // Gateway binding is now impossible forever (bindController requires candidate.miner() == 0).
        vm.prank(FOUNDER);
        try gateway.bindController(controller, address(controller).codehash) {} catch {}

        token.transfer(address(miner), 4e26);
        vm.prank(FOUNDER);
        try miner.arm() {} catch {}

        // Nobody can ever call the controller as publisher: the gateway holds no controller,
        // and the controller's immutable publisher is the gateway, not an EOA.
        bool publisherReachable = address(gateway.controller()) == address(controller);
        // Defect: the reserve is armed while the agent settlement path is unreachable.
        assertFalse(miner.armed() && !publisherReachable, "armed with permanently unreachable publisher");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;
import {Test} from "forge-std/Test.sol";
import {PublisherGateway} from "src/PublisherGateway.sol";
import {FINCR} from "src/FINCR.sol";
import {FounderFundedMining} from "src/FounderFundedMining.sol";
import {RobinhoodJobController, INativeJobMining} from "src/RobinhoodJobController.sol";
import {FinancierMiningWithMarket} from "src/FinancierMiningWithMarket.sol";
import {AttestedAgentRounds as Rounds} from "src/AttestedAgentRounds.sol";
import {IIMDIntakeViews} from "src/interfaces/IIMDIntakeViews.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface ISeatIntake {
    function setPrice(bytes32, address, uint256) external;
    function setPayTo(address) external;
    function setWriter(address) external;
    function setCallbackGas(uint64) external;
    function complete(bytes32, uint8, bytes32, string calldata, bytes calldata) external;
}

/// The pinned Intake runtime marks a request completed even when the payer callback reverts and
/// refuses a second completion. FounderFundedMining.onResult reverts for any uri longer than 2048
/// bytes (and for a zero resultHash; onFailure reverts for any status other than 1/2), so one such
/// official result leaves `completions[request].recorded == false` forever. finalizeRound then
/// reverts for the whole period and its agent budget is quarantined on expiry. Fails on this code;
/// passes once the callback records every official completion instead of reverting.
contract RevertingCallbackStrandsRoundTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant INTAKE = 0xa43e6F75ee006411F79Ac1C84120606C2330DE82;
    address constant FOUNDER = 0xbcF19c0821A245383c127570615896Abac9e424F;
    address constant ALICE = address(101);
    address constant ATTESTER = address(700);
    bytes32 constant JOB = keccak256("SYNTHETIC FINANCIER job UUID");
    PublisherGateway gateway;
    FINCR token;
    FounderFundedMining miner;
    RobinhoodJobController controller;
    Rounds rounds;
    bytes32 request;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.etch(IMD, vm.parseBytes(vm.readLine("test/fixtures/task16/imd-runtime.hex")));
        vm.etch(INTAKE, vm.parseBytes(vm.readLine("test/fixtures/task16/intake-runtime.hex")));
        vm.etch(0x8366a39CC670B4001A1121B8F6A443A643e40951, vm.parseBytes(vm.readLine("test/fixtures/task23/manager-runtime.hex")));
        vm.etch(0x19Bec7C2E1b2aadAf67b259744751a9960d66000, vm.parseBytes(vm.readLine("test/fixtures/task23/guard-runtime.hex")));
        vm.store(IMD, 0, bytes32(uint256(uint160(address(this)))));
        (bool ok,) = IMD.call(abi.encodeWithSignature("enableTransfers()"));
        require(ok);
        vm.store(INTAKE, 0, bytes32(uint256(uint160(address(this)))));
        ISeatIntake(INTAKE).setPrice("job.open@job-1", IMD, 0.5 ether);
        ISeatIntake(INTAKE).setPayTo(address(800));
        ISeatIntake(INTAKE).setWriter(address(this));
        ISeatIntake(INTAKE).setCallbackGas(200_000);
        token = new FINCR(1e27);
        vm.prank(FOUNDER);
        gateway = new PublisherGateway(ATTESTER);
        vm.prank(FOUNDER);
        controller = new RobinhoodJobController(address(gateway));
        vm.prank(FOUNDER);
        gateway.bindController(controller, address(controller).codehash);
        vm.prank(FOUNDER);
        gateway.setPaused(false);
        FinancierMiningWithMarket.Config memory c = FinancierMiningWithMarket.Config(
            address(token), IMD, 1e27, 10 ether, 0.5 ether, FOUNDER, 0x74421cdb9e6ad159358c4af7C59CFAE472A0541e,
            address(controller), controller.SPECIFICATION(), 1 days, 1 days, 1 hours, 0.1 ether
        );
        vm.prank(FOUNDER);
        miner = new FounderFundedMining(c);
        vm.prank(FOUNDER);
        controller.bindMiner(INativeJobMining(address(miner)));
        rounds = miner.agentRounds();
        deal(IMD, ALICE, 100 ether);
        vm.prank(ALICE);
        IERC20(IMD).approve(address(miner), type(uint256).max);
        token.transfer(address(miner), 4e26);
        vm.prank(FOUNDER);
        miner.arm();
        vm.prank(ALICE);
        miner.bid(0, 10 ether, block.timestamp);
        vm.prank(ALICE);
        request = controller.commission(0, 0);
        bytes32 bodyHash = keccak256(controller.body(0, 0));
        vm.prank(ATTESTER);
        gateway.bindJob(0, Rounds.Admission(request, JOB, bodyHash, block.timestamp, block.timestamp, keccak256("admission")));
        vm.warp(block.timestamp + 10);
    }

    function testOfficialResultWithLongUriMustStillBeRecorded() public {
        bytes memory longUri = new bytes(2049);
        for (uint256 i; i < longUri.length; ++i) longUri[i] = "a";
        bytes32 hash = keccak256("SYNTHETIC nonempty completed result");
        // Official writer completes the request once; the pinned runtime does not revert when the
        // payer callback reverts, and it refuses any second completion of the same request.
        ISeatIntake(INTAKE).complete(request, 0, hash, string(longUri), abi.encode(request, hash, string(longUri)));
        (,,, bool completedAtIntake) = IIMDIntakeViews(INTAKE).requests(request);
        assertTrue(completedAtIntake, "intake marked complete");
        vm.expectRevert();
        ISeatIntake(INTAKE).complete(request, 0, hash, "uri", abi.encode(request, hash, "uri"));
        (bool recorded,,,) = miner.completions(request);
        assertTrue(recorded, "official completion must be recorded so the period can settle");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {FINCR} from "src/FINCR.sol";
import {FounderFundedMining} from "src/FounderFundedMining.sol";
import {FinancierMiningWithMarket} from "src/FinancierMiningWithMarket.sol";
import {RobinhoodJobController, INativeJobMining} from "src/RobinhoodJobController.sol";
import {IIMDIntakeViews} from "src/interfaces/IIMDIntakeViews.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IIntakeControl {
    function setPrice(bytes32, address, uint256) external;
    function setPayTo(address) external;
    function setWriter(address) external;
    function setCallbackGas(uint64) external;
    function complete(bytes32, uint8, bytes32, string calldata, bytes calldata) external;
}

/// Finding: FounderFundedMining.onFailure reverts for any status other than 1 or 2 and onResult reverts for a
/// zero result hash or a URI longer than 2048 bytes. The pinned Intake runtime (test/fixtures/task16) swallows the
/// reverted callback, marks the request `completed`, and rejects any later `complete` for the same id. The miner
/// therefore never records the completion, RobinhoodJobController.finalizeRound requires `recorded` for every
/// purchased request and bound job, and the round's agent allocation can only expire into quarantine.
contract UnrecordableCompletionTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant INTAKE = 0xa43e6F75ee006411F79Ac1C84120606C2330DE82;
    address constant MANAGER = 0x8366a39CC670B4001A1121B8F6A443A643e40951;
    address constant GUARD = 0x19Bec7C2E1b2aadAf67b259744751a9960d66000;
    address constant ALICE = address(101);
    FINCR token;
    FounderFundedMining miner;
    RobinhoodJobController controller;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.etch(IMD, vm.parseBytes(vm.readLine("test/fixtures/task16/imd-runtime.hex")));
        vm.etch(INTAKE, vm.parseBytes(vm.readLine("test/fixtures/task16/intake-runtime.hex")));
        vm.etch(MANAGER, vm.parseBytes(vm.readLine("test/fixtures/task23/manager-runtime.hex")));
        vm.etch(GUARD, vm.parseBytes(vm.readLine("test/fixtures/task23/guard-runtime.hex")));
        vm.store(IMD, 0, bytes32(uint256(uint160(address(this)))));
        (bool ok,) = IMD.call(abi.encodeWithSignature("enableTransfers()"));
        require(ok);
        vm.store(INTAKE, 0, bytes32(uint256(uint160(address(this)))));
        IIntakeControl(INTAKE).setPrice("job.open@job-1", IMD, 0.5 ether);
        IIntakeControl(INTAKE).setPayTo(address(800));
        IIntakeControl(INTAKE).setWriter(address(this));
        IIntakeControl(INTAKE).setCallbackGas(200_000);
        token = new FINCR(1e27);
        controller = new RobinhoodJobController(address(this));
        miner = new FounderFundedMining(
            FinancierMiningWithMarket.Config(
                address(token),
                IMD,
                1e27,
                10 ether,
                0.5 ether,
                address(this),
                address(105),
                address(controller),
                controller.SPECIFICATION(),
                1 days,
                1 days,
                1 hours,
                0.1 ether
            )
        );
        controller.bindMiner(INativeJobMining(address(miner)));
        deal(IMD, ALICE, 100 ether);
        vm.prank(ALICE);
        IERC20(IMD).approve(address(miner), type(uint256).max);
        token.transfer(address(miner), 4e26);
        miner.arm();
        vm.prank(ALICE);
        miner.bid(0, 10 ether, block.timestamp);
    }

    /// The Intake writer closes the request with failure status 3 (e.g. timeout). The miner's onFailure reverts,
    /// the Intake keeps `completed == true`, no retry is possible, and the miner never records the closure.
    function testIntakeFailureStatusOutsideOneOrTwoIsStillRecorded() public {
        vm.prank(ALICE);
        bytes32 id = controller.commission(0, 0);
        IIntakeControl(INTAKE).complete(
            id, 3, bytes32("timeout"), "", abi.encode(id, uint8(3), bytes32("timeout"), uint16(0), uint16(0), bytes(""))
        );
        (,,, bool completed) = IIMDIntakeViews(INTAKE).requests(id);
        assertTrue(completed, "intake closed the request");
        // A second writer call for the same id is rejected by the Intake runtime: there is no retry path.
        (bool retried,) = INTAKE.call(
            abi.encodeCall(
                IIntakeControl.complete,
                (id, 2, 0, "", abi.encode(id, uint8(2), bytes32("failed"), uint16(0), uint16(0), bytes("")))
            )
        );
        assertFalse(retried, "intake refuses a second completion");
        // Expected: the miner recorded the closure so the round can still be finalized or evaluated.
        // Actual on this commit: completions[id].recorded stays false forever.
        (bool recorded,,,) = miner.completions(id);
        assertTrue(recorded, "miner must record every closure the Intake delivers");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PublisherGateway} from "src/PublisherGateway.sol";
import {FINCR} from "src/FINCR.sol";
import {FounderFundedMining} from "src/FounderFundedMining.sol";
import {RobinhoodJobController, INativeJobMining} from "src/RobinhoodJobController.sol";
import {FinancierMiningWithMarket} from "src/FinancierMiningWithMarket.sol";
import {AttestedAgentRounds as Rounds} from "src/AttestedAgentRounds.sol";
import {IAgentWorkVerifier as W} from "src/interfaces/IAgentWorkVerifier.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface ISeatIntake {
    function setPrice(bytes32, address, uint256) external;
    function setPayTo(address) external;
    function setWriter(address) external;
    function setCallbackGas(uint64) external;
    function complete(bytes32, uint8, bytes32, string calldata, bytes calldata) external;
}

/// The current financier can void a whole period's agent allocation, including
/// already-accepted honest work, by commissioning one more job in the period's last second.
contract LateCommissionGriefTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant INTAKE = 0xa43e6F75ee006411F79Ac1C84120606C2330DE82;
    address constant FOUNDER = 0xbcF19c0821A245383c127570615896Abac9e424F;
    address constant ALICE = address(101);
    address constant OWNER = address(301);
    address constant ATTESTER = address(700);
    bytes32 constant JOB = keccak256("SYNTHETIC honest job");
    PublisherGateway gateway;
    FINCR token;
    FounderFundedMining miner;
    RobinhoodJobController controller;
    Rounds rounds;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.etch(IMD, vm.parseBytes(vm.readLine("test/fixtures/task16/imd-runtime.hex")));
        vm.etch(INTAKE, vm.parseBytes(vm.readLine("test/fixtures/task16/intake-runtime.hex")));
        vm.etch(
            0x8366a39CC670B4001A1121B8F6A443A643e40951,
            vm.parseBytes(vm.readLine("test/fixtures/task23/manager-runtime.hex"))
        );
        vm.etch(
            0x19Bec7C2E1b2aadAf67b259744751a9960d66000,
            vm.parseBytes(vm.readLine("test/fixtures/task23/guard-runtime.hex"))
        );
        vm.store(IMD, 0, bytes32(uint256(uint160(address(this)))));
        (bool ok,) = IMD.call(abi.encodeWithSignature("enableTransfers()"));
        require(ok);
        vm.store(INTAKE, 0, bytes32(uint256(uint160(address(this)))));
        ISeatIntake(INTAKE).setPrice("job.open@job-1", IMD, 0.5 ether);
        ISeatIntake(INTAKE).setPayTo(address(800));
        ISeatIntake(INTAKE).setWriter(address(this));
        ISeatIntake(INTAKE).setCallbackGas(200_000);
        token = new FINCR(1e27);
        vm.startPrank(FOUNDER);
        gateway = new PublisherGateway(ATTESTER);
        controller = new RobinhoodJobController(address(gateway));
        gateway.bindController(controller, address(controller).codehash);
        gateway.setPaused(false);
        miner = new FounderFundedMining(
            FinancierMiningWithMarket.Config(
                address(token),
                IMD,
                1e27,
                10 ether,
                0.5 ether,
                FOUNDER,
                0x74421cdb9e6ad159358c4af7C59CFAE472A0541e,
                address(controller),
                controller.SPECIFICATION(),
                1 days,
                1 days,
                1 hours,
                0.1 ether
            )
        );
        controller.bindMiner(INativeJobMining(address(miner)));
        vm.stopPrank();
        rounds = miner.agentRounds();
        deal(IMD, ALICE, 100 ether);
        vm.prank(ALICE);
        IERC20(IMD).approve(address(miner), type(uint256).max);
    }

    function _complete(bytes32 req) internal {
        bytes32 hash = keccak256("SYNTHETIC nonempty completed result");
        ISeatIntake(INTAKE).complete(req, 0, hash, "uri", abi.encode(req, hash, "uri"));
    }

    function testLastSecondCommissionVoidsHonestRound() public {
        token.transfer(address(miner), 4e26);
        vm.prank(FOUNDER);
        miner.arm();
        vm.prank(ALICE);
        miner.bid(0, 10 ether, block.timestamp); // genesis; 8.5 IMD work budget
        // Honest, fully bound and successfully completed FINANCIER job.
        vm.prank(ALICE);
        bytes32 request = controller.commission(0, 0);
        bytes32 body0 = keccak256(controller.body(0, 0));
        vm.prank(ATTESTER);
        gateway.bindJob(0, Rounds.Admission(request, JOB, body0, block.timestamp, block.timestamp, keccak256("adm")));
        vm.warp(block.timestamp + 10);
        _complete(request);

        W.Context memory c = rounds.context(0);
        // Financier (anyone who bid; here the same ALICE) commissions in the last second of the period.
        vm.warp(c.end - 1);
        vm.prank(ALICE);
        try controller.commission(0, 1) returns (bytes32 late) {
            _complete(late); // even a successful callback does not help
            vm.warp(c.end); // admission window closed: the honest publisher can no longer bind it
            bytes32 body1 = keccak256(controller.body(0, 1));
            vm.prank(ATTESTER);
            try gateway.bindJob(
                0,
                Rounds.Admission(
                    late,
                    keccak256("late job"),
                    body1,
                    c.end - 1,
                    c.end - 1,
                    keccak256("adm")
                )
            ) {} catch {}
        } catch {}
        vm.warp(c.end);

        // Honest settlement of the already-accepted agent.
        Rounds.Snapshot memory s = Rounds.Snapshot(
            26_000_000, keccak256("hdr"), c.end - 15 minutes, keccak256("owners"), keccak256("accepted")
        );
        W.Contribution[] memory a = new W.Contribution[](1);
        Rounds.OwnerEvidence[] memory o = new Rounds.OwnerEvidence[](1);
        a[0] = W.Contribution(
            1,
            rounds.IDENTITY_REGISTRY(),
            51_000,
            OWNER,
            OWNER,
            JOB,
            keccak256("receipt"),
            keccak256("submission"),
            keccak256("artifact"),
            rounds.jobBoundAt(JOB) + 2,
            s.timestamp,
            c.deadline
        );
        o[0] = Rounds.OwnerEvidence(100, false, 0, 0, rounds.jobBoundAt(JOB) + 1);
        vm.prank(ATTESTER);
        gateway.lockSnapshot(0, s);
        bytes32 commitment = rounds.settlementCommitment(0, a, s, o);
        vm.prank(ATTESTER);
        // Current code: reverts InvalidSettlement because the late request is unbound; the round
        // can then only expire, quarantining the entire period-0 agent allocation forever.
        gateway.finalizeRound(0, a, s, o, commitment);

        uint256 budget = miner.agentAllocation(0, 1 days);
        assertEq(rounds.claimable(0, OWNER), budget);
        vm.prank(OWNER);
        assertEq(rounds.claim(0), budget);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PublisherGateway} from "src/PublisherGateway.sol";
import {FINCR} from "src/FINCR.sol";
import {FounderFundedMining} from "src/FounderFundedMining.sol";
import {RobinhoodJobController, INativeJobMining} from "src/RobinhoodJobController.sol";
import {FinancierMiningWithMarket} from "src/FinancierMiningWithMarket.sol";

/// arm() is the last on-chain gate before the irreversible 400M custody, yet it never checks that the
/// controller's immutable publisher is a gateway bound to that controller. A misordered deployment
/// (controller.bindMiner before gateway.bindController) or an EOA publisher arms successfully and the
/// whole 20% agent stream (80M FINCR) can never be settled.
contract UnboundGatewayArmTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant FOUNDER = 0xbcF19c0821A245383c127570615896Abac9e424F;
    address constant OPERATIONS = 0x74421cdb9e6ad159358c4af7C59CFAE472A0541e;
    address constant OPERATOR = 0x174818c4FEcB65472522Ff8C7677F5A567cB3020;
    FINCR token;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.etch(IMD, vm.parseBytes(vm.readLine("test/fixtures/task16/imd-runtime.hex")));
        vm.etch(
            0x8366a39CC670B4001A1121B8F6A443A643e40951,
            vm.parseBytes(vm.readLine("test/fixtures/task23/manager-runtime.hex"))
        );
        vm.etch(
            0x19Bec7C2E1b2aadAf67b259744751a9960d66000,
            vm.parseBytes(vm.readLine("test/fixtures/task23/guard-runtime.hex"))
        );
        token = new FINCR(1e27);
        token.transfer(FOUNDER, 4e26);
    }

    function _config(address controller) internal view returns (FinancierMiningWithMarket.Config memory) {
        return FinancierMiningWithMarket.Config(
            address(token),
            IMD,
            1e27,
            10 ether,
            0.5 ether,
            FOUNDER,
            OPERATIONS,
            controller,
            RobinhoodJobController(controller).SPECIFICATION(),
            1 days,
            1 days,
            1 hours,
            0.1 ether
        );
    }

    /// Tries the remaining launch steps; returns whether the miner ended up funded AND armed.
    function _deployFundArm(RobinhoodJobController controller) internal returns (bool) {
        vm.startPrank(FOUNDER);
        FounderFundedMining miner;
        try new FounderFundedMining(_config(address(controller))) returns (FounderFundedMining m) {
            miner = m;
        } catch {
            vm.stopPrank();
            return false;
        }
        try controller.bindMiner(INativeJobMining(address(miner))) {}
        catch {
            vm.stopPrank();
            return false;
        }
        token.transfer(address(miner), 4e26); // irreversible: no rescue path exists
        try miner.arm() {}
        catch {
            vm.stopPrank();
            return false;
        }
        vm.stopPrank();
        return miner.armed();
    }

    function testMisorderedGatewayBindingStillArms() public {
        vm.startPrank(FOUNDER);
        PublisherGateway gateway = new PublisherGateway(OPERATOR);
        RobinhoodJobController controller = new RobinhoodJobController(address(gateway));
        vm.stopPrank();
        // Gateway binding skipped/misordered: miner is bound first.
        bool armed = _deployFundArm(controller);
        // Gateway can now never bind the controller (requires controller.miner()==0) -> no relay path.
        vm.prank(FOUNDER);
        vm.expectRevert(PublisherGateway.InvalidConfiguration.selector);
        gateway.bindController(controller, address(controller).codehash);
        assertFalse(armed, "400M reserve armed with a controller whose gateway can never relay settlements");
    }

    function testOperatorEoaPublisherStillArms() public {
        vm.prank(FOUNDER);
        RobinhoodJobController controller = new RobinhoodJobController(OPERATOR);
        bool armed = _deployFundArm(controller);
        assertFalse(armed, "400M reserve armed with operator EOA as immutable controller publisher");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;
import {Test} from "forge-std/Test.sol";
import {PublisherGateway} from "src/PublisherGateway.sol";
import {FINCR} from "src/FINCR.sol";
import {FounderFundedMining} from "src/FounderFundedMining.sol";
import {RobinhoodJobController, INativeJobMining} from "src/RobinhoodJobController.sol";
import {FinancierMiningWithMarket} from "src/FinancierMiningWithMarket.sol";
import {AttestedAgentRounds as Rounds} from "src/AttestedAgentRounds.sol";
import {IIMDIntakeViews} from "src/interfaces/IIMDIntakeViews.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface ISeatIntake {
    function setPrice(bytes32, address, uint256) external;
    function setPayTo(address) external;
    function setWriter(address) external;
    function setCallbackGas(uint64) external;
    function complete(bytes32, uint8, bytes32, string calldata, bytes calldata) external;
}

/// The pinned Intake runtime marks a request completed even when the payer callback reverts and
/// refuses a second completion. FounderFundedMining.onResult reverts for any uri longer than 2048
/// bytes (and for a zero resultHash; onFailure reverts for any status other than 1/2), so one such
/// official result leaves `completions[request].recorded == false` forever. finalizeRound then
/// reverts for the whole period and its agent budget is quarantined on expiry. Fails on this code;
/// passes once the callback records every official completion instead of reverting.
contract RevertingCallbackStrandsRoundTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant INTAKE = 0xa43e6F75ee006411F79Ac1C84120606C2330DE82;
    address constant FOUNDER = 0xbcF19c0821A245383c127570615896Abac9e424F;
    address constant ALICE = address(101);
    address constant ATTESTER = address(700);
    bytes32 constant JOB = keccak256("SYNTHETIC FINANCIER job UUID");
    PublisherGateway gateway;
    FINCR token;
    FounderFundedMining miner;
    RobinhoodJobController controller;
    Rounds rounds;
    bytes32 request;

    function setUp() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.etch(IMD, vm.parseBytes(vm.readLine("test/fixtures/task16/imd-runtime.hex")));
        vm.etch(INTAKE, vm.parseBytes(vm.readLine("test/fixtures/task16/intake-runtime.hex")));
        vm.etch(0x8366a39CC670B4001A1121B8F6A443A643e40951, vm.parseBytes(vm.readLine("test/fixtures/task23/manager-runtime.hex")));
        vm.etch(0x19Bec7C2E1b2aadAf67b259744751a9960d66000, vm.parseBytes(vm.readLine("test/fixtures/task23/guard-runtime.hex")));
        vm.store(IMD, 0, bytes32(uint256(uint160(address(this)))));
        (bool ok,) = IMD.call(abi.encodeWithSignature("enableTransfers()"));
        require(ok);
        vm.store(INTAKE, 0, bytes32(uint256(uint160(address(this)))));
        ISeatIntake(INTAKE).setPrice("job.open@job-1", IMD, 0.5 ether);
        ISeatIntake(INTAKE).setPayTo(address(800));
        ISeatIntake(INTAKE).setWriter(address(this));
        ISeatIntake(INTAKE).setCallbackGas(200_000);
        token = new FINCR(1e27);
        vm.prank(FOUNDER);
        gateway = new PublisherGateway(ATTESTER);
        vm.prank(FOUNDER);
        controller = new RobinhoodJobController(address(gateway));
        vm.prank(FOUNDER);
        gateway.bindController(controller, address(controller).codehash);
        vm.prank(FOUNDER);
        gateway.setPaused(false);
        FinancierMiningWithMarket.Config memory c = FinancierMiningWithMarket.Config(
            address(token), IMD, 1e27, 10 ether, 0.5 ether, FOUNDER, 0x74421cdb9e6ad159358c4af7C59CFAE472A0541e,
            address(controller), controller.SPECIFICATION(), 1 days, 1 days, 1 hours, 0.1 ether
        );
        vm.prank(FOUNDER);
        miner = new FounderFundedMining(c);
        vm.prank(FOUNDER);
        controller.bindMiner(INativeJobMining(address(miner)));
        rounds = miner.agentRounds();
        deal(IMD, ALICE, 100 ether);
        vm.prank(ALICE);
        IERC20(IMD).approve(address(miner), type(uint256).max);
        token.transfer(address(miner), 4e26);
        vm.prank(FOUNDER);
        miner.arm();
        vm.prank(ALICE);
        miner.bid(0, 10 ether, block.timestamp);
        vm.prank(ALICE);
        request = controller.commission(0, 0);
        bytes32 bodyHash = keccak256(controller.body(0, 0));
        vm.prank(ATTESTER);
        gateway.bindJob(0, Rounds.Admission(request, JOB, bodyHash, block.timestamp, block.timestamp, keccak256("admission")));
        vm.warp(block.timestamp + 10);
    }

    function testOfficialResultWithLongUriMustStillBeRecorded() public {
        bytes memory longUri = new bytes(2049);
        for (uint256 i; i < longUri.length; ++i) longUri[i] = "a";
        bytes32 hash = keccak256("SYNTHETIC nonempty completed result");
        // Official writer completes the request once; the pinned runtime does not revert when the
        // payer callback reverts, and it refuses any second completion of the same request.
        ISeatIntake(INTAKE).complete(request, 0, hash, string(longUri), abi.encode(request, hash, string(longUri)));
        (,,, bool completedAtIntake) = IIMDIntakeViews(INTAKE).requests(request);
        assertTrue(completedAtIntake, "intake marked complete");
        vm.expectRevert();
        ISeatIntake(INTAKE).complete(request, 0, hash, "uri", abi.encode(request, hash, "uri"));
        (bool recorded,,,) = miner.completions(request);
        assertTrue(recorded, "official completion must be recorded so the period can settle");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;
import {Test} from "forge-std/Test.sol";
import {PublisherGateway} from "src/PublisherGateway.sol";
import {FINCR} from "src/FINCR.sol";
import {FounderFundedMining} from "src/FounderFundedMining.sol";
import {RobinhoodJobController, INativeJobMining} from "src/RobinhoodJobController.sol";
import {FinancierMiningWithMarket} from "src/FinancierMiningWithMarket.sol";
import {AttestedAgentRounds as Rounds} from "src/AttestedAgentRounds.sol";

/// Deployment order is only enforced one way: PublisherGateway.bindController rejects a controller
/// that already has a miner, but RobinhoodJobController.bindMiner and FounderFundedMining.arm never
/// check that the immutable publisher (the gateway) has actually been bound to this controller.
/// If the founder binds the miner first, the gateway can never bind, no publisher call can ever
/// reach the controller, every agent round expires to quarantine, and 80M FINCR (20% of the
/// 400M reserve) is stranded in the miner with no recovery path. Fails on this code; passes once
/// bindMiner (or arm) refuses while the gateway is not bound to this controller.
contract MisorderedBindingStrandsAgentsTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant INTAKE = 0xa43e6F75ee006411F79Ac1C84120606C2330DE82;
    address constant FOUNDER = 0xbcF19c0821A245383c127570615896Abac9e424F;
    address constant OPERATOR = 0x174818c4FEcB65472522Ff8C7677F5A567cB3020;

    function testMinerCannotArmWhileGatewayIsUnboundToController() public {
        vm.chainId(4663);
        vm.warp(1_800_000_000);
        vm.etch(IMD, vm.parseBytes(vm.readLine("test/fixtures/task16/imd-runtime.hex")));
        vm.etch(INTAKE, vm.parseBytes(vm.readLine("test/fixtures/task16/intake-runtime.hex")));
        vm.etch(0x8366a39CC670B4001A1121B8F6A443A643e40951, vm.parseBytes(vm.readLine("test/fixtures/task23/manager-runtime.hex")));
        vm.etch(0x19Bec7C2E1b2aadAf67b259744751a9960d66000, vm.parseBytes(vm.readLine("test/fixtures/task23/guard-runtime.hex")));
        FINCR token = new FINCR(1e27);
        vm.prank(FOUNDER);
        PublisherGateway gateway = new PublisherGateway(OPERATOR);
        vm.prank(FOUNDER);
        RobinhoodJobController controller = new RobinhoodJobController(address(gateway));
        FinancierMiningWithMarket.Config memory c = FinancierMiningWithMarket.Config(
            address(token), IMD, 1e27, 10 ether, 0.5 ether, FOUNDER, 0x74421cdb9e6ad159358c4af7C59CFAE472A0541e,
            address(controller), controller.SPECIFICATION(), 1 days, 1 days, 1 hours, 0.1 ether
        );
        vm.prank(FOUNDER);
        FounderFundedMining miner = new FounderFundedMining(c);

        // Wrong order: miner bound before the gateway binding.
        vm.prank(FOUNDER);
        try controller.bindMiner(INativeJobMining(address(miner))) {} catch {}

        // Gateway binding is now impossible forever (bindController requires candidate.miner() == 0).
        vm.prank(FOUNDER);
        try gateway.bindController(controller, address(controller).codehash) {} catch {}

        token.transfer(address(miner), 4e26);
        vm.prank(FOUNDER);
        try miner.arm() {} catch {}

        // Nobody can ever call the controller as publisher: the gateway holds no controller,
        // and the controller's immutable publisher is the gateway, not an EOA.
        bool publisherReachable = address(gateway.controller()) == address(controller);
        // Defect: the reserve is armed while the agent settlement path is unreachable.
        assertFalse(miner.armed() && !publisherReachable, "armed with permanently unreachable publisher");
    }
}