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

import {Test} from "forge-std/Test.sol";
import {VerdictOracle} from "src/VerdictOracle.sol";
import {VerdictMarkets} from "src/VerdictMarkets.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

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

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

contract ProofIntake is IIntake {
    struct Ask {
        Callback callback;
        bool delivered;
    }

    mapping(bytes32 => Ask) public asks;
    uint256 public nonce;

    function request(bytes32, bytes calldata, Callback calldata callback, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = bytes32(++nonce);
        asks[id] = Ask(callback, false);
    }

    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata signature)
        external
        returns (bool success)
    {
        Ask storage ask = asks[id];
        require(ask.callback.target != address(0) && !ask.delivered, "unknown or delivered");
        ask.delivered = true;
        (success,) = ask.callback.target.call{gas: 200_000}(abi.encodeWithSelector(ask.callback.selector, id, a, signature));
    }
}

/// @dev A losing bettor presents a qualifying escalation answer (which even confirms the outcome) one second
/// before voidAfter. The restarted dispute window ends after voidAfter, finalize is blocked for good, and the
/// market voids: the loser is refunded instead of losing. Expected: a market whose provisional outcome was
/// never overturned settles and pays its winner.
contract LateEscalationVoidsSettledMarketTest is Test {
    uint256 constant SIGNER_KEY = 0xA11CE;
    uint256 constant PRICE = 0.5 ether;
    bytes constant BODY = '{"v":1,"question":"Test?","panelSize":5}';
    bytes constant ESCALATION = '{"v":1,"question":"Test?","panelSize":10}';
    address constant CREATOR = address(0xC0FFEE);
    address constant ALICE = address(0xA11CE);
    address constant BOB = address(0xB0B);

    ProofToken token;
    ProofIntake intake;
    VerdictOracle oracle;
    VerdictMarkets markets;
    uint256 serial;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        token = new ProofToken();
        intake = new ProofIntake();
        oracle = new VerdictOracle(address(intake), address(token), vm.addr(SIGNER_KEY), bytes32("a"), PRICE, address(this), 0);
        markets = new VerdictMarkets(address(oracle), address(token), address(0x1234), address(0xdead), address(this), 100, 50, 50, 500 ether);
        markets.setCreatorAllowed(CREATOR, true);
        _fund(CREATOR);
        _fund(ALICE);
        _fund(BOB);
    }

    function _fund(address account) internal {
        token.mint(account, 1_000 ether);
        vm.startPrank(account);
        token.approve(address(markets), type(uint256).max);
        token.approve(address(oracle), type(uint256).max);
        vm.stopPrank();
    }

    function _answer(VerdictMarkets.Market memory m, bool result, uint16 panel)
        internal
        returns (OracleAttestation.Attestation memory a)
    {
        a.requestId = keccak256(abi.encode("uuid", ++serial));
        a.chainId = m.params.dataChainId;
        a.questionHash = m.params.questionHash;
        a.answerType = 0;
        a.answer = abi.encode(result);
        a.fromBlock = m.params.fromBlock;
        a.toBlock = m.params.toBlock;
        a.blockHash = keccak256("block");
        a.panelJobId = keccak256(abi.encode("panel", serial));
        a.panelSize = panel;
        a.quorum = panel;
        a.agreed = panel;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 1 days);
    }

    function _sign(OracleAttestation.Attestation memory a) internal view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, oracle.attestationDigest(a));
        return abi.encodePacked(r, s, v);
    }

    function test_lateQualifyingEscalationMustNotTurnASettledMarketIntoRefunds() public {
        VerdictMarkets.Params memory p;
        p.bodyHash = keccak256(BODY);
        p.escalationBodyHash = keccak256(ESCALATION);
        p.questionHash = keccak256("question");
        p.answerType = 0;
        p.dataChainId = 1;
        p.fromBlock = 100;
        p.toBlock = 200;
        p.minPanelSize = 5;
        p.minAgreed = 4;
        p.closeAt = uint64(vm.getBlockTimestamp() + 1 hours);
        p.answerFrom = p.closeAt;
        p.answerUntil = uint64(vm.getBlockTimestamp() + 5 days);
        p.disputeWindow = 2 days;
        p.voidAfter = uint64(vm.getBlockTimestamp() + 10 days);
        p.bounty = 2 * PRICE;
        vm.prank(CREATOR);
        uint256 id = markets.createMarket(p, "uri", 0);

        vm.prank(ALICE);
        markets.bet(id, 1, 10 ether, 0);
        vm.prank(BOB);
        markets.bet(id, 0, 10 ether, 0);

        // Resolve: the panel says true. ALICE is the winner, BOB the loser.
        vm.warp(p.answerFrom);
        bytes32 req = markets.resolve(id, BODY);
        OracleAttestation.Attestation memory first = _answer(markets.markets(id), true, 5);
        assertTrue(intake.deliver(req, first, _sign(first)));
        markets.propose(id, first);
        uint256 firstWindowEnd = markets.markets(id).disputeEndsAt;

        // BOB buys the pinned escalation body himself; the bigger panel confirms "true".
        vm.warp(firstWindowEnd - 1 hours);
        vm.prank(BOB);
        bytes32 bobReq = oracle.request(ESCALATION);
        OracleAttestation.Attestation memory confirm = _answer(markets.markets(id), true, 10);
        assertTrue(intake.deliver(bobReq, confirm, _sign(confirm)));

        // Nobody finalizes. One second before voidAfter BOB presents the confirming answer.
        vm.warp(p.voidAfter - 1);
        vm.prank(BOB);
        try markets.propose(id, confirm) {} catch {}

        VerdictMarkets.Market memory m = markets.markets(id);
        assertEq(m.outcome, 1, "outcome was never overturned");
        uint256 settleAt = m.disputeEndsAt > vm.getBlockTimestamp() ? m.disputeEndsAt : vm.getBlockTimestamp();
        vm.warp(settleAt);

        // Expected: a market with an undisputed outcome and a completed window finalizes and pays its winner.
        // Actual: finalize reverts WrongTime for ever (disputeEndsAt >= voidAfter), voidMarket refunds BOB.
        markets.finalize(id);
        assertEq(uint8(markets.markets(id).state), uint8(VerdictMarkets.State.Finalized));
        vm.prank(ALICE);
        assertGt(markets.claim(id), 10 ether, "winner must be paid more than her stake");
        vm.expectRevert();
        vm.prank(BOB);
        markets.claim(id);
    }
}

// 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 {VerdictOracle} from "src/VerdictOracle.sol";
import {VerdictMarkets} from "src/VerdictMarkets.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

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

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

contract ProofIntake is IIntake {
    struct Ask {
        Callback callback;
        bool delivered;
    }

    mapping(bytes32 => Ask) public asks;
    uint256 public nonce;

    function request(bytes32, bytes calldata, Callback calldata callback, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = bytes32(++nonce);
        asks[id] = Ask(callback, false);
    }

    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata signature)
        external
        returns (bool success)
    {
        Ask storage ask = asks[id];
        require(ask.callback.target != address(0) && !ask.delivered, "unknown or delivered");
        ask.delivered = true;
        (success,) = ask.callback.target.call{gas: 200_000}(
            abi.encodeWithSelector(ask.callback.selector, id, a, signature)
        );
    }
}

/// @dev A losing bettor restarts the dispute window with a confirming escalation so that it ends at or after
/// `voidAfter`; `finalize` can then never run and the decided market is voided with full refunds.
contract LateEscalationVoidsDecidedMarketTest is Test {
    uint256 constant SIGNER_KEY = 0xA11CE;
    uint256 constant PRICE = 0.5 ether;
    address constant CREATOR = address(0xC0FFEE);
    address constant ALICE = address(0xA11CE);
    address constant BOB = address(0xB0B);
    bytes constant BODY = '{"v":1,"question":"Test?","panelSize":5}';
    bytes constant ESCALATION = '{"v":1,"question":"Test?","panelSize":10}';
    bytes32 constant QUESTION = keccak256("unambiguous absolute question");

    ProofToken token;
    ProofIntake intake;
    VerdictOracle oracle;
    VerdictMarkets markets;
    uint256 serial;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        token = new ProofToken();
        intake = new ProofIntake();
        oracle = new VerdictOracle(
            address(intake), address(token), vm.addr(SIGNER_KEY), bytes32("oracle.request@oracle-1"), PRICE, address(this), 0
        );
        markets = new VerdictMarkets(
            address(oracle), address(token), address(0x1234), address(0xdead), address(this), 100, 50, 50, 500 ether
        );
        markets.setCreatorAllowed(CREATOR, true);
        _fund(CREATOR);
        _fund(ALICE);
        _fund(BOB);
    }

    function test_losingBettorVoidsDecidedMarketWithConfirmingEscalation() public {
        uint256 start = vm.getBlockTimestamp();
        VerdictMarkets.Params memory p;
        p.bodyHash = keccak256(BODY);
        p.escalationBodyHash = keccak256(ESCALATION);
        p.questionHash = QUESTION;
        p.answerType = 0;
        p.dataChainId = 1;
        p.fromBlock = 100;
        p.toBlock = 200;
        p.minPanelSize = 5;
        p.minAgreed = 4;
        p.closeAt = uint64(start + 1 hours);
        p.answerFrom = p.closeAt;
        p.answerUntil = uint64(start + 3 days);
        p.disputeWindow = 2 days;
        // "one full dispute window plus an hour after the last answer": accepted by _validateParams.
        p.voidAfter = uint64(start + 3 days + 2 days + 1 hours);
        p.bounty = 2 * PRICE;
        vm.prank(CREATOR);
        uint256 id = markets.createMarket(p, "uri", 0);

        vm.prank(ALICE);
        markets.bet(id, 1, 100 ether, 0);
        vm.prank(BOB);
        markets.bet(id, 0, 100 ether, 0);

        // The base answer (YES: Alice wins) is bought and proposed inside the answer window, two days in.
        vm.warp(start + 2 days);
        bytes32 ask = markets.resolve(id, BODY);
        OracleAttestation.Attestation memory base = _answer(id, true, 5);
        assertTrue(intake.deliver(ask, base, _sign(base)));
        markets.propose(id, base);
        uint256 baseEnd = markets.markets(id).disputeEndsAt;
        assertEq(baseEnd, start + 4 days);

        // Bob (the loser) escalates at the creator's bounty expense one second before the window closes.
        vm.warp(baseEnd - 1);
        vm.prank(BOB);
        bytes32 escalation = markets.escalate(id, ESCALATION);
        OracleAttestation.Attestation memory confirm = _answer(id, true, 10); // same outcome, 2x panel
        confirm.issuedAt = uint64(start + 3 days); // inside [answerFrom, answerUntil]
        assertTrue(intake.deliver(escalation, confirm, _sign(confirm)));
        vm.prank(BOB);
        markets.propose(id, confirm);
        uint256 newEnd = markets.markets(id).disputeEndsAt;
        assertGt(newEnd, p.voidAfter, "window restarted past voidAfter");
        assertEq(markets.markets(id).outcome, 1, "outcome still YES");

        // Expected: once the restarted window has ended the decided outcome can be finalized and Alice paid.
        vm.warp(newEnd);
        markets.finalize(id); // fails on the current code: WrongTime (block.timestamp >= voidAfter)
        vm.prank(ALICE);
        assertEq(markets.claim(id), 196 ether);
        vm.prank(BOB);
        vm.expectRevert(VerdictMarkets.NoStake.selector);
        markets.claim(id);
    }

    function _fund(address account) private {
        token.mint(account, 1_000_000 ether);
        vm.prank(account);
        token.approve(address(markets), type(uint256).max);
    }

    function _answer(uint256 id, bool result, uint16 panel) private returns (OracleAttestation.Attestation memory a) {
        VerdictMarkets.Market memory m = markets.markets(id);
        a.requestId = keccak256(abi.encode("oracle UUID", ++serial));
        a.chainId = m.params.dataChainId;
        a.questionHash = m.params.questionHash;
        a.answerType = m.params.answerType;
        a.answer = abi.encode(result);
        a.figure = 0;
        a.fromBlock = m.params.fromBlock;
        a.toBlock = m.params.toBlock;
        a.blockHash = keccak256("block");
        a.panelJobId = keccak256(abi.encode("panel", serial));
        a.panelSize = panel;
        a.quorum = panel;
        a.agreed = panel;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 1 days);
    }

    function _sign(OracleAttestation.Attestation memory a) private view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, oracle.attestationDigest(a));
        return abi.encodePacked(r, s, v);
    }
}

// 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 {VerdictOracle} from "src/VerdictOracle.sol";
import {VerdictMarkets} from "src/VerdictMarkets.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

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

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

contract ProofIntake is IIntake {
    struct Ask {
        Callback callback;
        bool delivered;
    }

    mapping(bytes32 => Ask) public asks;
    uint256 public nonce;

    function request(bytes32, bytes calldata, Callback calldata callback, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = bytes32(++nonce);
        asks[id] = Ask(callback, false);
    }

    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata signature)
        external
        returns (bool success)
    {
        Ask storage ask = asks[id];
        require(ask.callback.target != address(0) && !ask.delivered, "unknown or delivered");
        ask.delivered = true;
        (success,) = ask.callback.target.call{gas: 200_000}(
            abi.encodeWithSelector(ask.callback.selector, id, a, signature)
        );
    }
}

/// @dev A bettor buys an answer to the escalation body at their own expense while the market is still Open and
/// proposes it first. Nothing can ever replace it (the escalation body fixes its panel size, and 2x is required),
/// so the dispute window is dead, and every later `escalate` burns the creator's bounty on an unusable answer.
contract EscalationFirstLocksOutcomeTest is Test {
    uint256 constant SIGNER_KEY = 0xA11CE;
    uint256 constant PRICE = 0.5 ether;
    address constant CREATOR = address(0xC0FFEE);
    address constant ALICE = address(0xA11CE);
    address constant BOB = address(0xB0B);
    bytes constant BODY = '{"v":1,"question":"Test?","panelSize":5}';
    bytes constant ESCALATION = '{"v":1,"question":"Test?","panelSize":10}';
    bytes32 constant QUESTION = keccak256("unambiguous absolute question");

    ProofToken token;
    ProofIntake intake;
    VerdictOracle oracle;
    VerdictMarkets markets;
    uint256 serial;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        token = new ProofToken();
        intake = new ProofIntake();
        oracle = new VerdictOracle(
            address(intake), address(token), vm.addr(SIGNER_KEY), bytes32("oracle.request@oracle-1"), PRICE, address(this), 0
        );
        markets = new VerdictMarkets(
            address(oracle), address(token), address(0x1234), address(0xdead), address(this), 100, 50, 50, 500 ether
        );
        markets.setCreatorAllowed(CREATOR, true);
        _fund(CREATOR);
        _fund(ALICE);
        _fund(BOB);
    }

    function test_escalationAnswerCannotBeTheFirstProposalOnAnOpenMarket() public {
        uint256 start = vm.getBlockTimestamp();
        VerdictMarkets.Params memory p;
        p.bodyHash = keccak256(BODY);
        p.escalationBodyHash = keccak256(ESCALATION);
        p.questionHash = QUESTION;
        p.answerType = 0;
        p.dataChainId = 1;
        p.fromBlock = 100;
        p.toBlock = 200;
        p.minPanelSize = 5;
        p.minAgreed = 4;
        p.closeAt = uint64(start + 1 hours);
        p.answerFrom = p.closeAt;
        p.answerUntil = uint64(start + 5 days);
        p.disputeWindow = 2 days;
        p.voidAfter = uint64(start + 10 days);
        p.bounty = 2 * PRICE;
        vm.prank(CREATOR);
        uint256 id = markets.createMarket(p, "uri", 0);

        vm.prank(ALICE);
        markets.bet(id, 1, 100 ether, 0);
        vm.prank(BOB);
        markets.bet(id, 0, 100 ether, 0);

        // Bob buys the escalation body himself (0.5 IMD) while the market is Open and nothing is proposed.
        vm.warp(p.answerFrom);
        vm.prank(BOB);
        bytes32 own = oracle.request(ESCALATION);
        OracleAttestation.Attestation memory shopped = _answer(id, false, 10);
        assertTrue(intake.deliver(own, shopped, _sign(shopped)));

        // Expected: an escalation answer only challenges an existing base proposal; it is not a first answer.
        vm.prank(BOB);
        vm.expectRevert(VerdictMarkets.WrongBody.selector);
        markets.propose(id, shopped); // succeeds on the current code and locks outcome 0 for good
    }

    function _fund(address account) private {
        token.mint(account, 1_000_000 ether);
        vm.startPrank(account);
        token.approve(address(markets), type(uint256).max);
        token.approve(address(oracle), type(uint256).max);
        vm.stopPrank();
    }

    function _answer(uint256 id, bool result, uint16 panel) private returns (OracleAttestation.Attestation memory a) {
        VerdictMarkets.Market memory m = markets.markets(id);
        a.requestId = keccak256(abi.encode("oracle UUID", ++serial));
        a.chainId = m.params.dataChainId;
        a.questionHash = m.params.questionHash;
        a.answerType = m.params.answerType;
        a.answer = abi.encode(result);
        a.figure = 0;
        a.fromBlock = m.params.fromBlock;
        a.toBlock = m.params.toBlock;
        a.blockHash = keccak256("block");
        a.panelJobId = keccak256(abi.encode("panel", serial));
        a.panelSize = panel;
        a.quorum = panel;
        a.agreed = panel;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 1 days);
    }

    function _sign(OracleAttestation.Attestation memory a) private view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, oracle.attestationDigest(a));
        return abi.encodePacked(r, s, v);
    }
}

// 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 {VerdictOracle} from "src/VerdictOracle.sol";
import {VerdictMarkets} from "src/VerdictMarkets.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";
import {IIntake} from "src/interfaces/IIntake.sol";

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

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

contract ProofIntake is IIntake {
    struct Ask {
        Callback callback;
        bool delivered;
    }

    mapping(bytes32 => Ask) public asks;
    uint256 public nonce;

    function request(bytes32, bytes calldata, Callback calldata callback, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = bytes32(++nonce);
        asks[id] = Ask(callback, false);
    }

    function deliver(bytes32 id, OracleAttestation.Attestation calldata a, bytes calldata signature)
        external
        returns (bool success)
    {
        Ask storage ask = asks[id];
        require(ask.callback.target != address(0) && !ask.delivered, "unknown or delivered");
        ask.delivered = true;
        (success,) = ask.callback.target.call{gas: 200_000}(
            abi.encodeWithSelector(ask.callback.selector, id, a, signature)
        );
    }
}

/// @notice A losing bettor buys the funded escalation, holds the delivered answer, and proposes it at
/// voidAfter - disputeWindow (still inside the first dispute window, so nobody could finalize before).
/// The restarted window ends exactly at voidAfter, finalize is impossible, the market voids and the
/// winner is refunded her stake instead of being paid. Expected: a market whose parameters pass
/// validation lets the provisional winner collect once the dispute window has run, or the parameters
/// are refused at creation.
contract EscalationVoidProofTest is Test {
    uint256 constant SIGNER_KEY = 0xA11CE;
    uint256 constant PRICE = 0.5 ether;
    bytes constant BODY = '{"v":1,"question":"Q?","panelSize":5}';
    bytes constant ESCALATION = '{"v":1,"question":"Q?","panelSize":10}';
    address constant CREATOR = address(0xC0FFEE);
    address constant ALICE = address(0xA11CE);
    address constant BOB = address(0xB0B);

    ProofToken token;
    ProofIntake intake;
    VerdictOracle oracle;
    VerdictMarkets markets;
    uint256 serial;

    function setUp() public {
        vm.chainId(11155111);
        vm.warp(1_800_000_000);
        token = new ProofToken();
        intake = new ProofIntake();
        oracle = new VerdictOracle(address(intake), address(token), vm.addr(SIGNER_KEY), bytes32("a"), PRICE, address(this), 0);
        markets = new VerdictMarkets(address(oracle), address(token), address(0x1234), address(0xdead), address(this), 100, 50, 50, 500 ether);
        markets.setCreatorAllowed(CREATOR, true);
        _fund(CREATOR);
        _fund(ALICE);
        _fund(BOB);
    }

    function _fund(address who) internal {
        token.mint(who, 1_000 ether);
        vm.prank(who);
        token.approve(address(markets), type(uint256).max);
    }

    function _answer(VerdictMarkets.Params memory p, bool result, uint16 panel)
        internal
        returns (OracleAttestation.Attestation memory a)
    {
        a.requestId = keccak256(abi.encode("uuid", ++serial));
        a.chainId = p.dataChainId;
        a.questionHash = p.questionHash;
        a.answerType = 0;
        a.answer = abi.encode(result);
        a.fromBlock = p.fromBlock;
        a.toBlock = p.toBlock;
        a.blockHash = keccak256("block");
        a.panelJobId = keccak256(abi.encode("panel", serial));
        a.panelSize = panel;
        a.quorum = panel;
        a.agreed = panel;
        a.issuedAt = uint64(vm.getBlockTimestamp());
        a.expiresAt = uint64(vm.getBlockTimestamp() + 1 days);
    }

    function _sign(OracleAttestation.Attestation memory a) internal view returns (bytes memory) {
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(SIGNER_KEY, oracle.attestationDigest(a));
        return abi.encodePacked(r, s, v);
    }

    function test_provisionalWinnerCanCollectAfterDisputeWindow() public {
        uint256 t0 = vm.getBlockTimestamp();
        VerdictMarkets.Params memory p;
        p.bodyHash = keccak256(BODY);
        p.escalationBodyHash = keccak256(ESCALATION);
        p.questionHash = keccak256("question");
        p.answerType = 0;
        p.dataChainId = 1;
        p.fromBlock = 100;
        p.toBlock = 200;
        p.minPanelSize = 5;
        p.minAgreed = 4;
        p.closeAt = uint64(t0 + 1 hours);
        p.answerFrom = p.closeAt;
        p.answerUntil = uint64(t0 + 3 days);
        p.disputeWindow = 2 days;
        p.voidAfter = uint64(t0 + 4 days); // satisfies closeAt <= answerFrom < answerUntil < voidAfter
        p.bounty = 2 * PRICE;

        vm.prank(CREATOR);
        try markets.createMarket(p, "uri", 0) returns (uint256 id) {
            _run(id, p);
        } catch {
            // A fix that refuses parameters under which finalization can be pushed past voidAfter is acceptable.
        }
    }

    function _run(uint256 id, VerdictMarkets.Params memory p) internal {
        vm.prank(ALICE);
        markets.bet(id, 1, 10 ether, 0);
        vm.prank(BOB);
        markets.bet(id, 0, 10 ether, 0);
        uint256 aliceBefore = token.balanceOf(ALICE);

        // Honest resolution at answerFrom: YES, Alice is the provisional winner.
        vm.warp(p.answerFrom);
        bytes32 req = markets.resolve(id, BODY);
        OracleAttestation.Attestation memory a = _answer(p, true, 5);
        assertTrue(intake.deliver(req, a, _sign(a)));
        markets.propose(id, a);
        uint256 firstEnd = markets.markets(id).disputeEndsAt;

        // Bob, the loser, buys the funded escalation immediately; it is answered YES too, panel 10.
        vm.warp(p.answerFrom + 1);
        vm.prank(BOB);
        bytes32 esc = markets.escalate(id, ESCALATION);
        vm.warp(p.answerFrom + 10 minutes);
        OracleAttestation.Attestation memory e = _answer(p, true, 10);
        assertTrue(intake.deliver(esc, e, _sign(e)));

        // Bob holds the answer and proposes it at voidAfter - disputeWindow, before the first window ends.
        vm.warp(p.voidAfter - p.disputeWindow);
        assertLt(vm.getBlockTimestamp(), firstEnd, "no finalize was possible before Bob's proposal");
        vm.prank(BOB);
        try markets.propose(id, e) {} catch {}

        // Alice does everything she can: finalize as soon as any window ends, then claim.
        uint256 end = markets.markets(id).disputeEndsAt;
        vm.warp(end);
        try markets.finalize(id) {} catch {}
        if (markets.markets(id).state != VerdictMarkets.State.Finalized) {
            vm.warp(p.voidAfter);
            try markets.finalize(id) {} catch {}
        }
        if (markets.markets(id).state != VerdictMarkets.State.Finalized) {
            markets.voidMarket(id);
        }
        vm.prank(ALICE);
        markets.claim(id);
        assertGt(token.balanceOf(ALICE), aliceBefore + 10 ether, "provisional winner only got her stake back");
    }
}