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

import {Test} from "forge-std/Test.sol";
import {AskSwarmRegistry} from "src/AskSwarmRegistry.sol";
import {IIntake, OracleAttestation} from "src/IIntake.sol";

contract ProofERC20 {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function approve(address spender, uint256 amount) external returns (bool) { allowance[msg.sender][spender] = amount; return true; }
    function mint(address to, uint256 a) external { balanceOf[to] += a; }
    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        uint256 a = allowance[from][msg.sender];
        if (a != type(uint256).max) allowance[from][msg.sender] = a - amount;
        balanceOf[from] -= amount; balanceOf[to] += amount; return true;
    }
}

/// Mirrors the verified Intake v2 on mainnet (0xa43e6f75ee006411f79ac1c84120606c2330de82, `_request` and
/// `complete`): writer-only, once per Intake request id, and the args' first word is bound to the request
/// id only when status != 0. For status 0 the writer's args are passed to the callback as given.
contract ProofIntake {
    struct Req { address payer; address target; bytes4 selector; bool completed; }
    bytes32 public constant ACTION = bytes32("oracle.request@oracle-1");
    uint256 public constant PRICE = 0.5 ether;
    address public writer; address public imd; address public owner;
    mapping(bytes32 => Req) public requests; mapping(bytes32 => bytes4) public failureSelectorOf; uint256 nonce;
    constructor(address w, address i) { writer = w; imd = i; owner = msg.sender; }
    function priceOf(bytes32 action, address asset) public view returns (uint256) { return action == ACTION && asset == imd ? PRICE : 0; }
    function requestWithFailure(bytes32 action, bytes calldata body, IIntake.Callback calldata cb, bytes4 onFailure, address asset, uint256 amount) external payable returns (bytes32 id) {
        uint256 p = priceOf(action, asset);
        require(p != 0 && amount >= p && body.length != 0, "PriceNotMet");
        id = keccak256(abi.encode(block.chainid, address(this), ++nonce));
        requests[id] = Req(msg.sender, cb.target, cb.selector, false);
        failureSelectorOf[id] = onFailure;
        require(ProofERC20(asset).transferFrom(msg.sender, owner, amount), "pull");
    }
    function complete(bytes32 id, uint8 status, bytes32, string calldata, bytes calldata args) external returns (bool delivered) {
        require(msg.sender == writer, "NotWriter");
        Req storage r = requests[id];
        require(r.payer != address(0), "UnknownRequest");
        require(!r.completed, "AlreadyCompleted");
        r.completed = true;
        bytes4 sel = r.selector;
        if (status != 0) {
            sel = failureSelectorOf[id];
            if (sel != bytes4(0) && args.length != 0) {
                require(args.length >= 64 && bytes32(args[0:32]) == id && uint256(bytes32(args[32:64])) == status, "FailureArgsMismatch");
            } else sel = bytes4(0);
        }
        if ((status == 0 || sel != bytes4(0)) && r.target != address(0)) {
            (delivered,) = r.target.call{gas: 200_000}(abi.encodePacked(sel, args));
        }
    }
}

/// Fails on the current code: a second status-0 delivery for an ask that is already Answered is accepted
/// and overwrites the stored answer, so a 2-of-2 answer replaces the canonical 100-of-100 answer under the
/// same request id without the displacement rule applying. Passes once onOracleResult refuses a request
/// that is no longer Pending (or otherwise refuses a second write to the same request id).
contract OncePerAskProofTest is Test {
    uint256 constant PK = 0xA11CE;
    ProofERC20 imd; ProofIntake intake; AskSwarmRegistry reg;
    address user = makeAddr("user"); address writer = makeAddr("writer");

    function setUp() public {
        vm.chainId(1); vm.roll(26_300_000); vm.warp(1_792_300_000);
        imd = new ProofERC20(); intake = new ProofIntake(writer, address(imd));
        reg = new AskSwarmRegistry(address(intake), address(imd), vm.addr(PK));
        imd.mint(user, 100 ether);
    }
    function _ask() internal returns (bytes32 id) {
        vm.startPrank(user); imd.approve(address(reg), type(uint256).max); id = reg.ask('{"v":1,"question":"q"}'); vm.stopPrank();
    }
    function _att(bytes32 id, bytes32 qh, bytes memory ans, uint16 panel, uint16 quorum, uint16 agreed) internal view returns (OracleAttestation memory a) {
        a = OracleAttestation(id, 1, qh, 2, ans, 0, uint64(block.number - 10), uint64(block.number), blockhash(block.number - 1), bytes32(uint256(7)), panel, quorum, agreed, uint64(block.timestamp), uint64(block.timestamp + 1 days));
    }
    function _sign(OracleAttestation memory a) internal view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(PK, reg.digest(a)); return abi.encodePacked(r, s, v);
    }

    function test_secondDeliveryForAnsweredAskMustNotOverwrite() public {
        bytes32 r1 = _ask();
        bytes32 r2 = _ask();
        bytes32 q = keccak256("question");

        // Intake request r1 is completed with result args naming r2 (Intake binds args to the id only for failures).
        OracleAttestation memory strong = _att(r2, q, "CHF", 100, 51, 100);
        bytes memory sigS = _sign(strong);
        vm.prank(writer);
        intake.complete(r1, 0, 0, "", abi.encode(r2, strong, sigS));
        (AskSwarmRegistry.Ask memory k2, AskSwarmRegistry.Answer memory a2) = reg.get(r2);
        assertEq(uint8(k2.status), uint8(AskSwarmRegistry.Status.Answered));
        assertEq(a2.panelSize, 100);
        assertEq(reg.latestFor(q), r2);

        // Intake request r2 is completed with a weaker signed answer for the same question, again under r2.
        OracleAttestation memory weak = _att(r2, q, "EUR", 2, 2, 2);
        bytes memory sigW = _sign(weak);
        vm.prank(writer);
        intake.complete(r2, 0, 0, "", abi.encode(r2, weak, sigW));

        // Expected: r2 is already Answered, so the second delivery is refused and the 100-of-100 answer stays.
        (, AskSwarmRegistry.Answer memory held) = reg.answerOf(q);
        assertEq(reg.latestFor(q), r2);
        assertEq(held.panelSize, 100, "canonical 100-of-100 answer was overwritten by a 2-of-2 one under the same id");
        assertEq(held.answer, bytes("CHF"));
        assertEq(held.agreed, 100);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {AskSwarmRegistry} from "src/AskSwarmRegistry.sol";
import {OracleAttestation} from "src/IIntake.sol";

/// Fails on the current AskSwarmRegistry: a verified, majority answer of equal-or-larger panel strength
/// but a far shorter validity displaces a long-lived one from `latestFor`, and minutes later the question
/// has no current answer although the long-lived one is still valid. Passes once displacement also
/// requires the newcomer to be at least as fresh (a.expiresAt >= cur.expiresAt) or an equivalent rule.
contract MiniIntake {
    uint256 public constant PRICE = 0.5 ether;
    uint256 nonce;
    struct Callback { address target; bytes4 selector; }
    function priceOf(bytes32, address) external pure returns (uint256) { return PRICE; }
    function requestWithFailure(bytes32, bytes calldata, Callback calldata, bytes4, address asset, uint256 amount)
        external payable returns (bytes32 id)
    {
        require(amount == PRICE, "PriceNotMet");
        (bool ok,) = asset.call(abi.encodeWithSelector(0x23b872dd, msg.sender, address(this), amount));
        require(ok, "pull");
        id = keccak256(abi.encode(block.chainid, address(this), ++nonce));
    }
}

contract MiniToken {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 a) external { balanceOf[to] += a; }
    function approve(address s, uint256 a) external returns (bool) { allowance[msg.sender][s] = a; return true; }
    function transferFrom(address f, address t, uint256 a) external returns (bool) {
        uint256 al = allowance[f][msg.sender];
        if (al != type(uint256).max) allowance[f][msg.sender] = al - a;
        balanceOf[f] -= a; balanceOf[t] += a; return true;
    }
}

contract IndexEvictionTest is Test {
    uint256 constant PK = 0xA11CE;
    address user = makeAddr("user");
    address griefer = makeAddr("griefer");
    MiniToken imd;
    MiniIntake intake;
    AskSwarmRegistry reg;

    function setUp() public {
        vm.chainId(1);
        vm.roll(26_300_000);
        vm.warp(1_792_300_000);
        imd = new MiniToken();
        intake = new MiniIntake();
        reg = new AskSwarmRegistry(address(intake), address(imd), vm.addr(PK));
        imd.mint(user, 10 ether);
        imd.mint(griefer, 10 ether);
    }

    function _att(bytes32 id, uint16 panel, uint16 quorum, uint16 agreed, uint64 expiresAt)
        internal view returns (OracleAttestation memory a)
    {
        a = OracleAttestation({
            requestId: id, chainId: 1, questionHash: bytes32(uint256(0xeeee)), answerType: 2, answer: "CHF",
            figure: 0, fromBlock: uint64(block.number - 10), toBlock: uint64(block.number),
            blockHash: bytes32(uint256(1)), panelJobId: bytes32(uint256(7)), panelSize: panel, quorum: quorum,
            agreed: agreed, issuedAt: uint64(block.timestamp), expiresAt: expiresAt
        });
    }

    function _ask(address who) internal returns (bytes32 id) {
        vm.startPrank(who);
        imd.approve(address(reg), type(uint256).max);
        id = reg.ask("{}");
        vm.stopPrank();
    }

    function _deliver(bytes32 id, OracleAttestation memory a) internal {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(PK, reg.digest(a));
        vm.prank(address(intake));
        reg.onOracleResult(id, a, abi.encodePacked(r, s, v));
    }

    function test_longLivedAnswerStaysCurrentAgainstShortLivedStrongerOne() public {
        bytes32 qh = bytes32(uint256(0xeeee));
        uint256 t0 = block.timestamp;

        // honest asker: 15 seats, 11 agreed, valid 24 hours
        bytes32 honest = _ask(user);
        _deliver(honest, _att(honest, 15, 11, 11, uint64(t0 + 24 hours)));
        assertEq(reg.latestFor(qh), honest);

        // griefer, same question hash, flat price: 100 seats, 60 agreed, valid 10 minutes
        bytes32 g = _ask(griefer);
        _deliver(g, _att(g, 100, 51, 60, uint64(t0 + 10 minutes)));

        vm.warp(t0 + 11 minutes);
        // the honest answer is still valid for ~23h49m ...
        (, AskSwarmRegistry.Answer memory h) = reg.get(honest);
        assertTrue(h.verified && block.timestamp <= h.expiresAt, "precondition: honest answer still valid");
        // ... so the question must still have a current answer and a 15/11 filtered read must find one.
        assertTrue(reg.isCurrent(qh), "question lost its current answer to a 10-minute attestation");
        (bytes32 rid,) = reg.answerOf(qh, 15, 11);
        assertTrue(rid != bytes32(0), "filtered read returns nothing although a valid 15/11 answer exists");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {AskSwarmRegistry} from "src/AskSwarmRegistry.sol";
import {OracleAttestation} from "src/IIntake.sol";

/// Minimal ERC-20 for the IMD stand-in.
contract Token {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

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

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

/// Intake v2 as deployed at 0xa43e...de82: `complete` runs once per Intake request id and, on status 0,
/// forwards the writer's `args` to the callback without checking which request id they name.
contract Intake {
    struct Callback {
        address target;
        bytes4 selector;
    }

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

    bytes32 constant ACTION = bytes32("oracle.request@oracle-1");
    address public immutable writer;
    address public immutable imd;
    mapping(bytes32 => Req) public reqs;
    uint256 nonce;

    constructor(address w, address i) {
        writer = w;
        imd = i;
    }

    function priceOf(bytes32 a, address asset) public view returns (uint256) {
        return a == ACTION && asset == imd ? 0.5 ether : 0;
    }

    function requestWithFailure(bytes32 a, bytes calldata, Callback calldata cb, bytes4, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(amount >= priceOf(a, asset), "price");
        require(Token(asset).transferFrom(msg.sender, address(this), amount), "pull");
        id = keccak256(abi.encode(block.chainid, address(this), ++nonce));
        reqs[id] = Req(msg.sender, cb.target, cb.selector, false);
    }

    function complete(bytes32 id, uint8 status, bytes calldata args) external {
        require(msg.sender == writer, "NotWriter");
        Req storage r = reqs[id];
        require(r.payer != address(0) && !r.completed, "bad");
        r.completed = true;
        if (status == 0) {
            bytes memory data = bytes.concat(r.sel, args);
            address t = r.target;
            assembly {
                pop(call(200000, t, 0, add(data, 0x20), mload(data), 0, 0))
            }
        }
    }
}

contract OnceOnlyProof is Test {
    uint256 constant PK = 0xA11CE;
    address user = makeAddr("user");
    address writer = makeAddr("writer");
    Token imd;
    Intake intake;
    AskSwarmRegistry reg;

    function setUp() public {
        vm.chainId(1);
        vm.roll(26_300_000);
        vm.warp(1_792_300_000);
        imd = new Token();
        intake = new Intake(writer, address(imd));
        reg = new AskSwarmRegistry(address(intake), address(imd), vm.addr(PK));
        imd.mint(user, 10 ether);
    }

    function _ask() internal returns (bytes32 id) {
        vm.startPrank(user);
        imd.approve(address(reg), type(uint256).max);
        id = reg.ask("{}");
        vm.stopPrank();
    }

    function _att(bytes32 id, bytes memory ans, uint16 panel, uint16 quorum, uint16 agreed)
        internal
        view
        returns (OracleAttestation memory a)
    {
        a = OracleAttestation({
            requestId: id,
            chainId: 1,
            questionHash: bytes32(uint256(0xabcd)),
            answerType: 0,
            answer: ans,
            figure: 0,
            fromBlock: uint64(block.number - 10),
            toBlock: uint64(block.number),
            blockHash: blockhash(block.number - 1),
            panelJobId: bytes32(uint256(7)),
            panelSize: panel,
            quorum: quorum,
            agreed: agreed,
            issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 1 days)
        });
    }

    function _sign(OracleAttestation memory a) internal view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(PK, reg.digest(a));
        return abi.encodePacked(r, s, v);
    }

    /// Two registry asks (two Intake request ids). The first is answered and indexed. The second Intake
    /// request is completed with args that name the first registry id again. Expected: the settled id1
    /// record is untouched (a settled ask takes no second delivery). Actual: id1's stored answer is
    /// overwritten by an unsigned 1-of-2 attestation, status flips to Unverified, and latestFor still
    /// points at id1, so answerOf hands out an unverified record as the canonical answer.
    function test_settledAskTakesNoSecondDelivery() public {
        bytes32 id1 = _ask();
        bytes32 id2 = _ask();
        OracleAttestation memory good = _att(id1, hex"01", 15, 11, 15);
        bytes memory sigGood = _sign(good);
        vm.prank(writer);
        intake.complete(id1, 0, abi.encode(id1, good, sigGood));
        assertEq(reg.latestFor(bytes32(uint256(0xabcd))), id1, "indexed");

        OracleAttestation memory bad = _att(id1, hex"00", 2, 1, 1);
        vm.prank(writer);
        intake.complete(id2, 0, abi.encode(id1, bad, ""));

        (AskSwarmRegistry.Ask memory k1, AskSwarmRegistry.Answer memory after1) = reg.get(id1);
        assertEq(uint8(k1.status), uint8(AskSwarmRegistry.Status.Answered), "settled status must not change");
        assertTrue(after1.verified, "settled answer must not be overwritten");
        assertEq(after1.agreed, 15);
        assertEq(reg.latestFor(bytes32(uint256(0xabcd))), id1);
        assertTrue(reg.isCurrent(bytes32(uint256(0xabcd))), "canonical answer must stay verified");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;
import {Test} from "forge-std/Test.sol";
import {AskSwarmRegistry} from "src/AskSwarmRegistry.sol";
import {IIntake, OracleAttestation} from "src/IIntake.sol";

contract ProofToken {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 amount) external { balanceOf[to] += amount; }
    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount; return true;
    }
    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

// The relevant Intake v2 transport behavior: complete is writer-only, marks each OUTER
// id completed once, and forwards opaque success args without validating their first word.
contract ProofIntake {
    struct Request { address target; bytes4 selector; bool completed; }
    ProofToken public immutable token;
    address public immutable writer;
    uint256 private nonce;
    mapping(bytes32 => Request) public requests;
    constructor(ProofToken t, address w) { token = t; writer = w; }
    function priceOf(bytes32, address) external pure returns (uint256) { return 0.5 ether; }
    function requestWithFailure(bytes32, bytes calldata, IIntake.Callback calldata cb,
        bytes4, address, uint256 amount) external returns (bytes32 id) {
        require(token.transferFrom(msg.sender, writer, amount));
        id = keccak256(abi.encode(block.chainid, address(this), ++nonce));
        requests[id] = Request(cb.target, cb.selector, false);
    }
    function complete(bytes32 outerId, bytes calldata args) external returns (bool called) {
        require(msg.sender == writer, "only writer");
        Request storage r = requests[outerId];
        require(r.target != address(0) && !r.completed, "not pending");
        r.completed = true;
        (called,) = r.target.call{gas: 200_000}(abi.encodePacked(r.selector, args));
    }
}

contract RepeatedCallbackProof is Test {
    uint256 constant KEY = 0xA11CE;
    AskSwarmRegistry registry;
    ProofToken token;
    ProofIntake intake;
    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        token = new ProofToken();
        intake = new ProofIntake(token, address(this));
        registry = new AskSwarmRegistry(address(intake), address(token), vm.addr(KEY));
        token.mint(address(this), 10 ether);
        token.approve(address(registry), 10 ether);
    }
    function attestation(bytes32 id) internal view returns (OracleAttestation memory a) {
        a = OracleAttestation({requestId: keccak256(abi.encode("oracle UUID", id)), chainId: 1,
            questionHash: keccak256("question"), answerType: 0, answer: abi.encode(true), figure: 1,
            fromBlock: 100, toBlock: 200, blockHash: keccak256("block"), panelJobId: keccak256("job"),
            panelSize: 15, quorum: 11, agreed: 11, issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 1 days)});
    }
    function sign(OracleAttestation memory a) internal view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, registry.digest(a));
        return abi.encodePacked(r, s, v);
    }
    function test_anotherCompletionCannotRewriteAnAlreadySettledRequest() public {
        bytes32 first = registry.ask("{}");
        OracleAttestation memory a = attestation(first);
        require(intake.complete(first, abi.encode(first, a, sign(a))), "first delivery");
        (AskSwarmRegistry.Ask memory beforeAsk, AskSwarmRegistry.Answer memory beforeAnswer) = registry.get(first);
        require(beforeAnswer.verified, "fixture must begin with a verified answer");
        bytes32 saved = keccak256(abi.encode(beforeAsk, beforeAnswer));
        bytes32 second = registry.ask("{}");
        // A writer mistake or malicious writer can put first in the opaque success arguments
        // of a different, still-pending outer request. Neither outer request is completed twice.
        intake.complete(second, abi.encode(first, a, bytes("invalid signature")));
        (AskSwarmRegistry.Ask memory afterAsk, AskSwarmRegistry.Answer memory afterAnswer) = registry.get(first);
        assertEq(keccak256(abi.encode(afterAsk, afterAnswer)), saved,
            "a settled record must be immutable even when a later callback repeats its id");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;
import {Test} from "forge-std/Test.sol";
import {AskSwarmRegistry} from "src/AskSwarmRegistry.sol";
import {IIntake, OracleAttestation} from "src/IIntake.sol";

contract ProofToken {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 amount) external { balanceOf[to] += amount; }
    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount; return true;
    }
    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

// The relevant Intake v2 transport behavior: complete is writer-only, marks each OUTER
// id completed once, and forwards opaque success args without validating their first word.
contract ProofIntake {
    struct Request { address target; bytes4 selector; bool completed; }
    ProofToken public immutable token;
    address public immutable writer;
    uint256 private nonce;
    mapping(bytes32 => Request) public requests;
    constructor(ProofToken t, address w) { token = t; writer = w; }
    function priceOf(bytes32, address) external pure returns (uint256) { return 0.5 ether; }
    function requestWithFailure(bytes32, bytes calldata, IIntake.Callback calldata cb,
        bytes4, address, uint256 amount) external returns (bytes32 id) {
        require(token.transferFrom(msg.sender, writer, amount));
        id = keccak256(abi.encode(block.chainid, address(this), ++nonce));
        requests[id] = Request(cb.target, cb.selector, false);
    }
    function complete(bytes32 outerId, bytes calldata args) external returns (bool called) {
        require(msg.sender == writer, "only writer");
        Request storage r = requests[outerId];
        require(r.target != address(0) && !r.completed, "not pending");
        r.completed = true;
        (called,) = r.target.call{gas: 200_000}(abi.encodePacked(r.selector, args));
    }
}

contract FutureIssuedProof is Test {
    uint256 constant KEY = 0xA11CE;
    AskSwarmRegistry registry;
    ProofToken token;
    ProofIntake intake;
    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        token = new ProofToken();
        intake = new ProofIntake(token, address(this));
        registry = new AskSwarmRegistry(address(intake), address(token), vm.addr(KEY));
        token.mint(address(this), 10 ether);
        token.approve(address(registry), 10 ether);
    }
    function attestation(bytes32 id) internal view returns (OracleAttestation memory a) {
        a = OracleAttestation({requestId: keccak256(abi.encode("oracle UUID", id)), chainId: 1,
            questionHash: keccak256("question"), answerType: 0, answer: abi.encode(true), figure: 1,
            fromBlock: 100, toBlock: 200, blockHash: keccak256("block"), panelJobId: keccak256("job"),
            panelSize: 15, quorum: 11, agreed: 11, issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 1 days)});
    }
    function sign(OracleAttestation memory a) internal view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, registry.digest(a));
        return abi.encodePacked(r, s, v);
    }
    function test_futureIssuedAttestationIsNotCurrent() public {
        bytes32 id = registry.ask("{}");
        OracleAttestation memory a = attestation(id);
        a.issuedAt = uint64(block.timestamp + 301); // beyond canonical 5-minute tolerance
        bytes memory signature = sign(a);
        intake.complete(id, abi.encode(id, a, signature));
        (, AskSwarmRegistry.Answer memory result) = registry.get(id);
        assertFalse(result.verified, "attestation issued beyond clock tolerance must not verify");
        assertFalse(registry.isCurrent(a.questionHash));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;
import {Test} from "forge-std/Test.sol";
import {AskSwarmRegistry} from "src/AskSwarmRegistry.sol";
import {IIntake, OracleAttestation} from "src/IIntake.sol";

contract ProofToken {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 amount) external { balanceOf[to] += amount; }
    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount; return true;
    }
    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

// The relevant Intake v2 transport behavior: complete is writer-only, marks each OUTER
// id completed once, and forwards opaque success args without validating their first word.
contract ProofIntake {
    struct Request { address target; bytes4 selector; bool completed; }
    ProofToken public immutable token;
    address public immutable writer;
    uint256 private nonce;
    mapping(bytes32 => Request) public requests;
    constructor(ProofToken t, address w) { token = t; writer = w; }
    function priceOf(bytes32, address) external pure returns (uint256) { return 0.5 ether; }
    function requestWithFailure(bytes32, bytes calldata, IIntake.Callback calldata cb,
        bytes4, address, uint256 amount) external returns (bytes32 id) {
        require(token.transferFrom(msg.sender, writer, amount));
        id = keccak256(abi.encode(block.chainid, address(this), ++nonce));
        requests[id] = Request(cb.target, cb.selector, false);
    }
    function complete(bytes32 outerId, bytes calldata args) external returns (bool called) {
        require(msg.sender == writer, "only writer");
        Request storage r = requests[outerId];
        require(r.target != address(0) && !r.completed, "not pending");
        r.completed = true;
        (called,) = r.target.call{gas: 200_000}(abi.encodePacked(r.selector, args));
    }
}

contract ChainDomainProof is Test {
    uint256 constant KEY = 0xA11CE;
    AskSwarmRegistry registry;
    ProofToken token;
    ProofIntake intake;
    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        token = new ProofToken();
        intake = new ProofIntake(token, address(this));
        registry = new AskSwarmRegistry(address(intake), address(token), vm.addr(KEY));
        token.mint(address(this), 10 ether);
        token.approve(address(registry), 10 ether);
    }
    function attestation(bytes32 id) internal view returns (OracleAttestation memory a) {
        a = OracleAttestation({requestId: keccak256(abi.encode("oracle UUID", id)), chainId: 1,
            questionHash: keccak256("question"), answerType: 0, answer: abi.encode(true), figure: 1,
            fromBlock: 100, toBlock: 200, blockHash: keccak256("block"), panelJobId: keccak256("job"),
            panelSize: 15, quorum: 11, agreed: 11, issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 1 days)});
    }
    function sign(OracleAttestation memory a) internal view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, registry.digest(a));
        return abi.encodePacked(r, s, v);
    }
    function test_oldChainSignatureIsRejectedAfterChainIdChange() public {
        bytes32 id = registry.ask("{}");
        OracleAttestation memory a = attestation(id);
        bytes memory oldChainSignature = sign(a); // EIP-712 domain chainId = 1
        vm.chainId(8453); // simulated chain-id-changing fork, preserving the deployed state
        intake.complete(id, abi.encode(id, a, oldChainSignature));
        (, AskSwarmRegistry.Answer memory result) = registry.get(id);
        assertFalse(result.verified, "signature from old domain chain must not verify on new chain");
        assertFalse(registry.isCurrent(a.questionHash));
    }
}

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

import {Test} from "forge-std/Test.sol";
import {AskSwarmRegistry} from "src/AskSwarmRegistry.sol";
import {OracleAttestation} from "src/IIntake.sol";

/// Minimal ERC-20 for the IMD stand-in.
contract Token {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

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

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

/// Intake v2 as deployed at 0xa43e...de82: `complete` runs once per Intake request id and, on status 0,
/// forwards the writer's `args` to the callback without checking which request id they name.
contract Intake {
    struct Callback {
        address target;
        bytes4 selector;
    }

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

    bytes32 constant ACTION = bytes32("oracle.request@oracle-1");
    address public immutable writer;
    address public immutable imd;
    mapping(bytes32 => Req) public reqs;
    uint256 nonce;

    constructor(address w, address i) {
        writer = w;
        imd = i;
    }

    function priceOf(bytes32 a, address asset) public view returns (uint256) {
        return a == ACTION && asset == imd ? 0.5 ether : 0;
    }

    function requestWithFailure(bytes32 a, bytes calldata, Callback calldata cb, bytes4, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(amount >= priceOf(a, asset), "price");
        require(Token(asset).transferFrom(msg.sender, address(this), amount), "pull");
        id = keccak256(abi.encode(block.chainid, address(this), ++nonce));
        reqs[id] = Req(msg.sender, cb.target, cb.selector, false);
    }

    function complete(bytes32 id, uint8 status, bytes calldata args) external {
        require(msg.sender == writer, "NotWriter");
        Req storage r = reqs[id];
        require(r.payer != address(0) && !r.completed, "bad");
        r.completed = true;
        if (status == 0) {
            bytes memory data = bytes.concat(r.sel, args);
            address t = r.target;
            assembly {
                pop(call(200000, t, 0, add(data, 0x20), mload(data), 0, 0))
            }
        }
    }
}

contract OnceOnlyProof is Test {
    uint256 constant PK = 0xA11CE;
    address user = makeAddr("user");
    address writer = makeAddr("writer");
    Token imd;
    Intake intake;
    AskSwarmRegistry reg;

    function setUp() public {
        vm.chainId(1);
        vm.roll(26_300_000);
        vm.warp(1_792_300_000);
        imd = new Token();
        intake = new Intake(writer, address(imd));
        reg = new AskSwarmRegistry(address(intake), address(imd), vm.addr(PK));
        imd.mint(user, 10 ether);
    }

    function _ask() internal returns (bytes32 id) {
        vm.startPrank(user);
        imd.approve(address(reg), type(uint256).max);
        id = reg.ask("{}");
        vm.stopPrank();
    }

    function _att(bytes32 id, bytes memory ans, uint16 panel, uint16 quorum, uint16 agreed)
        internal
        view
        returns (OracleAttestation memory a)
    {
        a = OracleAttestation({
            requestId: id,
            chainId: 1,
            questionHash: bytes32(uint256(0xabcd)),
            answerType: 0,
            answer: ans,
            figure: 0,
            fromBlock: uint64(block.number - 10),
            toBlock: uint64(block.number),
            blockHash: blockhash(block.number - 1),
            panelJobId: bytes32(uint256(7)),
            panelSize: panel,
            quorum: quorum,
            agreed: agreed,
            issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 1 days)
        });
    }

    function _sign(OracleAttestation memory a) internal view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(PK, reg.digest(a));
        return abi.encodePacked(r, s, v);
    }

    /// Two registry asks (two Intake request ids). The first is answered and indexed. The second Intake
    /// request is completed with args that name the first registry id again. Expected: the settled id1
    /// record is untouched (a settled ask takes no second delivery). Actual: id1's stored answer is
    /// overwritten by an unsigned 1-of-2 attestation, status flips to Unverified, and latestFor still
    /// points at id1, so answerOf hands out an unverified record as the canonical answer.
    function test_settledAskTakesNoSecondDelivery() public {
        bytes32 id1 = _ask();
        bytes32 id2 = _ask();
        OracleAttestation memory good = _att(id1, hex"01", 15, 11, 15);
        bytes memory sigGood = _sign(good);
        vm.prank(writer);
        intake.complete(id1, 0, abi.encode(id1, good, sigGood));
        assertEq(reg.latestFor(bytes32(uint256(0xabcd))), id1, "indexed");

        OracleAttestation memory bad = _att(id1, hex"00", 2, 1, 1);
        vm.prank(writer);
        intake.complete(id2, 0, abi.encode(id1, bad, ""));

        (AskSwarmRegistry.Ask memory k1, AskSwarmRegistry.Answer memory after1) = reg.get(id1);
        assertEq(uint8(k1.status), uint8(AskSwarmRegistry.Status.Answered), "settled status must not change");
        assertTrue(after1.verified, "settled answer must not be overwritten");
        assertEq(after1.agreed, 15);
        assertEq(reg.latestFor(bytes32(uint256(0xabcd))), id1);
        assertTrue(reg.isCurrent(bytes32(uint256(0xabcd))), "canonical answer must stay verified");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {AskSwarmRegistry} from "src/AskSwarmRegistry.sol";
import {OracleAttestation} from "src/IIntake.sol";

/// Fails on the current AskSwarmRegistry: a verified, majority answer of equal-or-larger panel strength
/// but a far shorter validity displaces a long-lived one from `latestFor`, and minutes later the question
/// has no current answer although the long-lived one is still valid. Passes once displacement also
/// requires the newcomer to be at least as fresh (a.expiresAt >= cur.expiresAt) or an equivalent rule.
contract MiniIntake {
    uint256 public constant PRICE = 0.5 ether;
    uint256 nonce;
    struct Callback { address target; bytes4 selector; }
    function priceOf(bytes32, address) external pure returns (uint256) { return PRICE; }
    function requestWithFailure(bytes32, bytes calldata, Callback calldata, bytes4, address asset, uint256 amount)
        external payable returns (bytes32 id)
    {
        require(amount == PRICE, "PriceNotMet");
        (bool ok,) = asset.call(abi.encodeWithSelector(0x23b872dd, msg.sender, address(this), amount));
        require(ok, "pull");
        id = keccak256(abi.encode(block.chainid, address(this), ++nonce));
    }
}

contract MiniToken {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 a) external { balanceOf[to] += a; }
    function approve(address s, uint256 a) external returns (bool) { allowance[msg.sender][s] = a; return true; }
    function transferFrom(address f, address t, uint256 a) external returns (bool) {
        uint256 al = allowance[f][msg.sender];
        if (al != type(uint256).max) allowance[f][msg.sender] = al - a;
        balanceOf[f] -= a; balanceOf[t] += a; return true;
    }
}

contract IndexEvictionTest is Test {
    uint256 constant PK = 0xA11CE;
    address user = makeAddr("user");
    address griefer = makeAddr("griefer");
    MiniToken imd;
    MiniIntake intake;
    AskSwarmRegistry reg;

    function setUp() public {
        vm.chainId(1);
        vm.roll(26_300_000);
        vm.warp(1_792_300_000);
        imd = new MiniToken();
        intake = new MiniIntake();
        reg = new AskSwarmRegistry(address(intake), address(imd), vm.addr(PK));
        imd.mint(user, 10 ether);
        imd.mint(griefer, 10 ether);
    }

    function _att(bytes32 id, uint16 panel, uint16 quorum, uint16 agreed, uint64 expiresAt)
        internal view returns (OracleAttestation memory a)
    {
        a = OracleAttestation({
            requestId: id, chainId: 1, questionHash: bytes32(uint256(0xeeee)), answerType: 2, answer: "CHF",
            figure: 0, fromBlock: uint64(block.number - 10), toBlock: uint64(block.number),
            blockHash: bytes32(uint256(1)), panelJobId: bytes32(uint256(7)), panelSize: panel, quorum: quorum,
            agreed: agreed, issuedAt: uint64(block.timestamp), expiresAt: expiresAt
        });
    }

    function _ask(address who) internal returns (bytes32 id) {
        vm.startPrank(who);
        imd.approve(address(reg), type(uint256).max);
        id = reg.ask("{}");
        vm.stopPrank();
    }

    function _deliver(bytes32 id, OracleAttestation memory a) internal {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(PK, reg.digest(a));
        vm.prank(address(intake));
        reg.onOracleResult(id, a, abi.encodePacked(r, s, v));
    }

    function test_longLivedAnswerStaysCurrentAgainstShortLivedStrongerOne() public {
        bytes32 qh = bytes32(uint256(0xeeee));
        uint256 t0 = block.timestamp;

        // honest asker: 15 seats, 11 agreed, valid 24 hours
        bytes32 honest = _ask(user);
        _deliver(honest, _att(honest, 15, 11, 11, uint64(t0 + 24 hours)));
        assertEq(reg.latestFor(qh), honest);

        // griefer, same question hash, flat price: 100 seats, 60 agreed, valid 10 minutes
        bytes32 g = _ask(griefer);
        _deliver(g, _att(g, 100, 51, 60, uint64(t0 + 10 minutes)));

        vm.warp(t0 + 11 minutes);
        // the honest answer is still valid for ~23h49m ...
        (, AskSwarmRegistry.Answer memory h) = reg.get(honest);
        assertTrue(h.verified && block.timestamp <= h.expiresAt, "precondition: honest answer still valid");
        // ... so the question must still have a current answer and a 15/11 filtered read must find one.
        assertTrue(reg.isCurrent(qh), "question lost its current answer to a 10-minute attestation");
        (bytes32 rid,) = reg.answerOf(qh, 15, 11);
        assertTrue(rid != bytes32(0), "filtered read returns nothing although a valid 15/11 answer exists");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;
import {Test} from "forge-std/Test.sol";
import {AskSwarmRegistry} from "src/AskSwarmRegistry.sol";
import {IIntake, OracleAttestation} from "src/IIntake.sol";

contract ProofToken {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 amount) external { balanceOf[to] += amount; }
    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount; return true;
    }
    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

// The relevant Intake v2 transport behavior: complete is writer-only, marks each OUTER
// id completed once, and forwards opaque success args without validating their first word.
contract ProofIntake {
    struct Request { address target; bytes4 selector; bool completed; }
    ProofToken public immutable token;
    address public immutable writer;
    uint256 private nonce;
    mapping(bytes32 => Request) public requests;
    constructor(ProofToken t, address w) { token = t; writer = w; }
    function priceOf(bytes32, address) external pure returns (uint256) { return 0.5 ether; }
    function requestWithFailure(bytes32, bytes calldata, IIntake.Callback calldata cb,
        bytes4, address, uint256 amount) external returns (bytes32 id) {
        require(token.transferFrom(msg.sender, writer, amount));
        id = keccak256(abi.encode(block.chainid, address(this), ++nonce));
        requests[id] = Request(cb.target, cb.selector, false);
    }
    function complete(bytes32 outerId, bytes calldata args) external returns (bool called) {
        require(msg.sender == writer, "only writer");
        Request storage r = requests[outerId];
        require(r.target != address(0) && !r.completed, "not pending");
        r.completed = true;
        (called,) = r.target.call{gas: 200_000}(abi.encodePacked(r.selector, args));
    }
}

contract FutureIssuedProof is Test {
    uint256 constant KEY = 0xA11CE;
    AskSwarmRegistry registry;
    ProofToken token;
    ProofIntake intake;
    function setUp() public {
        vm.chainId(1);
        vm.warp(1_800_000_000);
        token = new ProofToken();
        intake = new ProofIntake(token, address(this));
        registry = new AskSwarmRegistry(address(intake), address(token), vm.addr(KEY));
        token.mint(address(this), 10 ether);
        token.approve(address(registry), 10 ether);
    }
    function attestation(bytes32 id) internal view returns (OracleAttestation memory a) {
        a = OracleAttestation({requestId: keccak256(abi.encode("oracle UUID", id)), chainId: 1,
            questionHash: keccak256("question"), answerType: 0, answer: abi.encode(true), figure: 1,
            fromBlock: 100, toBlock: 200, blockHash: keccak256("block"), panelJobId: keccak256("job"),
            panelSize: 15, quorum: 11, agreed: 11, issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 1 days)});
    }
    function sign(OracleAttestation memory a) internal view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, registry.digest(a));
        return abi.encodePacked(r, s, v);
    }
    function test_futureIssuedAttestationIsNotCurrent() public {
        bytes32 id = registry.ask("{}");
        OracleAttestation memory a = attestation(id);
        a.issuedAt = uint64(block.timestamp + 301); // beyond canonical 5-minute tolerance
        bytes memory signature = sign(a);
        intake.complete(id, abi.encode(id, a, signature));
        (, AskSwarmRegistry.Answer memory result) = registry.get(id);
        assertFalse(result.verified, "attestation issued beyond clock tolerance must not verify");
        assertFalse(registry.isCurrent(a.questionHash));
    }
}