Panel composition can be ground after the VRF word is public

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.20;

import "forge-std/Test.sol";
// Named imports: Escrow.sol and ArbitrationPool.sol both declare file-level errors with
// identical names (ZeroAmount, NotActive, NotDisputed), so wildcard imports collide.
import {ArbitrationPool} from "../../contracts/ArbitrationPool.sol";
import {EscrowFactory} from "../../contracts/EscrowFactory.sol";
import {Escrow} from "../../contracts/Escrow.sol";
import {MockVRFCoordinator} from "../../contracts/MockVRFCoordinator.sol";
import {ArbitrationPoolLib} from "../../contracts/lib/ArbitrationPoolLib.sol";
import {ArbitrationPoolTypes} from "../../contracts/lib/ArbitrationPoolTypes.sol";
import {ProtocolTimings} from "../../contracts/lib/ProtocolTimings.sol";

/// @dev Configurable-decimals ERC-20 stand-in for cNGN. MockUSDT is hardcoded to 18.
contract TokenNDecimals {
    string public name = "cNGN stand-in";
    string public symbol = "cNGN";
    uint8 public decimals;
    uint256 public totalSupply;
    bool public paused;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    constructor(uint8 _decimals) { decimals = _decimals; }

    function setPaused(bool p) external { paused = p; }

    function mint(address to, uint256 amount) external {
        totalSupply += amount;
        balanceOf[to] += amount;
        emit Transfer(address(0), to, amount);
    }

    function transfer(address to, uint256 value) external returns (bool) {
        require(!paused, "token paused");
        require(balanceOf[msg.sender] >= value, "insufficient balance");
        balanceOf[msg.sender] -= value;
        balanceOf[to] += value;
        emit Transfer(msg.sender, to, value);
        return true;
    }

    function approve(address spender, uint256 value) external returns (bool) {
        allowance[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    function transferFrom(address from, address to, uint256 value) external returns (bool) {
        require(!paused, "token paused");
        require(balanceOf[from] >= value, "insufficient balance");
        require(allowance[from][msg.sender] >= value, "insufficient allowance");
        balanceOf[from] -= value;
        balanceOf[to] += value;
        allowance[from][msg.sender] -= value;
        emit Transfer(from, to, value);
        return true;
    }
}

/// @notice Shared local harness. Mirrors test/helpers.js deployPoolAndFactory wiring.
///         Libraries (TallyLib / SelectLib) are auto-linked by forge for tests.
abstract contract PocBase is Test {
    TokenNDecimals   internal token;
    MockVRFCoordinator internal vrf;
    ArbitrationPool  internal pool;
    EscrowFactory    internal factory;

    address internal owner    = address(0xA11CE);
    // H-03: the pool now requires a signed identity attestation to onboard a juror.
    address internal attestor;
    uint256 internal attestorPk;
    address internal buyer    = address(0xB0B);
    address internal seller   = address(0x5E11E4);
    address internal treasury = address(0x7);
    address internal reserve  = address(0x8);
    address internal outsider = address(0x9);

    uint256 internal constant WAD = 1e6;

    function _deployStack(uint8 tokenDecimals) internal {
        token = new TokenNDecimals(tokenDecimals);
        vrf   = new MockVRFCoordinator();

        (attestor, attestorPk) = makeAddrAndKey("attestor");

        vm.startPrank(owner);
        pool = new ArbitrationPool(address(token), address(vrf), bytes32(0), 1, treasury);
        pool.setAttestor(attestor);
        factory = new EscrowFactory(address(token), address(pool));
        pool.configureCommission(address(factory), address(0));
        pool.setRelayer(owner);
        vm.stopPrank();

        vm.label(address(token), "cNGN");
        vm.label(address(pool), "ArbitrationPool");
        vm.label(address(factory), "EscrowFactory");
        vm.label(buyer, "buyer");
        vm.label(seller, "seller");
        vm.label(reserve, "reserve");
    }

    /// @dev Fund the pool's fee reserve so juror fees are payable.
    function _fundFeePool(uint256 amount) internal {
        token.mint(address(this), amount);
        token.approve(address(pool), amount);
        pool.fundPool(amount);
    }

    /// @dev H-03: onboarding now needs an attestor-signed identity, and the juror is not
    ///      draftable until STAKE_MATURATION has elapsed. `_matureJurors()` advances past it.
    uint256 internal _lastStakeAt;

    function _stakeJuror(address juror, uint8 tier, uint256 amount) internal {
        _lastStakeAt = block.timestamp;
        token.mint(juror, amount);
        bytes32 identity = keccak256(abi.encodePacked("identity", juror));
        uint256 expiresAt = block.timestamp + 365 days;
        bytes memory sig = _attest(juror, identity, expiresAt);

        vm.startPrank(juror);
        token.approve(address(pool), amount);
        pool.stakeAttested(tier, amount, identity, expiresAt, sig);
        vm.stopPrank();
    }

    function _attest(address juror, bytes32 identity, uint256 expiresAt)
        internal view returns (bytes memory)
    {
        bytes32 digest = keccak256(abi.encodePacked(
            "JUROR_ATTESTATION", address(pool), juror, identity, expiresAt, block.chainid
        ));
        bytes32 eth = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", digest));
        (uint8 v, bytes32 r, bytes32 sBytes) = vm.sign(attestorPk, eth);
        return abi.encodePacked(r, sBytes, v);
    }

    /// @dev Advance past the H-03 maturation window so staked jurors become draftable.
    /// @dev H-03: a stake is only drawable once STAKE_MATURATION has elapsed. Idempotent —
    ///      warps only as far as the newest stake requires, so repeated calls are free.
    function _matureJurors() internal {
        uint256 eligibleAt = _lastStakeAt + ProtocolTimings.STAKE_MATURATION + 1;
        if (block.timestamp < eligibleAt) vm.warp(eligibleAt);
    }

    /// @dev getCaseJurors was removed at HEAD; the panel now comes from getCaseView.
    function _panel(bytes32 caseId) internal view returns (address[] memory panel) {
        (,,,,,, panel) = pool.getCaseView(caseId);
    }

    /// @dev Simple (non-milestone) escrow, created and funded by the buyer.
    function _createFundedEscrow(uint256 amount, uint256 deliverDays) internal returns (Escrow e) {
        return _createFundedEscrowFor(buyer, amount, deliverDays);
    }

    /// @dev H-05 caps concurrent open cases per disputant, so repeated draws need
    ///      a distinct buyer each time.
    function _createFundedEscrowFor(address b, uint256 amount, uint256 deliverDays)
        internal returns (Escrow e)
    {
        _matureJurors();
        string[] memory titles;
        uint256[] memory amts;
        uint256[] memory days_;
        vm.prank(b);
        address addr = factory.createEscrow(seller, amount, deliverDays, titles, amts, days_, "NGN", false);
        e = Escrow(addr);
        token.mint(b, amount);
        vm.startPrank(b);
        token.approve(addr, amount);
        e.deposit();
        vm.stopPrank();
    }

    /// @dev H-01: an appeal must now self-fund its full 5-seat panel at the case-tier fee.
    function _minAppealDeposit(uint256 dealValue, bool commercial) internal view returns (uint256) {
        return ArbitrationPoolLib.caseTierFee(
            dealValue, commercial,
            pool.tierFeeExpertCommercial(), pool.tierFeeCommunity(),
            pool.tierFeeVerified(), pool.tierFeeExpert(), pool.tierFeeCapExpert()
        ) * pool.PANEL_SIZE_APPEAL();
    }

    function _bal(address who) internal view returns (uint256) {
        return token.balanceOf(who);
    }

    /// @dev Resolution enum: 0 None, 1 RefundBuyer, 2 ReleaseSeller, 3 Split.
    /// @dev HEAD binds the commit preimage to caseId + ballot epoch, so a commit
    ///      captured for a superseded seating cannot be revealed into a new one.
    function _commitHash(bytes32 caseId, uint8 vote, bytes32 salt, address juror)
        internal view returns (bytes32)
    {
        (uint256 epoch,) = pool.ballotContext(caseId, juror);
        return keccak256(abi.encodePacked(caseId, epoch, vote, salt, juror));
    }

    /// @dev Drive a seated case through commit -> reveal -> tally with a unanimous vote.
    ///      Windows come from the compiled ProtocolTimings profile, whatever it is.
    function _commitRevealTally(bytes32 caseId, address[] memory panel, uint8 vote) internal {
        (,,,,,,,,,, uint256 evidenceDeadline, uint256 commitDeadline, uint256 revealDeadline,,,,,) =
            _caseTimings(caseId);

        vm.warp(evidenceDeadline + 1);
        for (uint256 i = 0; i < panel.length; i++) {
            bytes32 h1_ = _commitHash(caseId, vote, bytes32(uint256(i + 1)), panel[i]);
            vm.prank(panel[i]);
            pool.commitVote(caseId, h1_);
        }

        vm.warp(commitDeadline + 1);
        for (uint256 i = 0; i < panel.length; i++) {
            vm.prank(panel[i]);
            pool.revealVote(caseId, ArbitrationPoolTypes.Resolution(vote), 0, bytes32(uint256(i + 1)));
        }

        vm.warp(revealDeadline + 1);
        pool.tally(caseId);
    }

    /// @dev cases() getter returns the Case struct fields positionally; pull the deadlines.
    function _caseTimings(bytes32 caseId)
        internal
        view
        returns (
            address escrowContract,
            uint256 disputedMilestoneIndex,
            uint256 dealValue,
            bool commercial,
            uint256 appealDeposit,
            ArbitrationPoolTypes.Phase phase,
            ArbitrationPoolTypes.Resolution ruling,
            uint16 buyerShareBps,
            ArbitrationPoolTypes.Resolution priorRuling,
            uint16 priorBuyerShareBps,
            uint256 evidenceDeadline,
            uint256 commitDeadline,
            uint256 revealDeadline,
            uint256 appealDeadline,
            uint256 executeAfter,
            uint8 appealRound,
            address appellant,
            uint256 appealActivationDeadline
        )
    {
        return pool.cases(caseId);
    }

    // ---- EIP-712 meta-auth (HEAD): domain-bound per clone, validUntil-capped ----
    function _escrowDomain(Escrow e) internal view returns (bytes32) {
        return keccak256(abi.encode(
            keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
            keccak256(bytes("Escrow")), keccak256(bytes("1")), block.chainid, address(e)
        ));
    }

    function _sign712(Escrow e, bytes32 structHash, uint256 pk) internal view returns (bytes memory) {
        bytes32 digest = keccak256(abi.encodePacked("\x19\x01", _escrowDomain(e), structHash));
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(pk, digest);
        return abi.encodePacked(r, s, v);
    }

    function _soon() internal view returns (uint64) { return uint64(block.timestamp + 1 hours); }

    // ---- Relayed-ballot EIP-712 (HEAD): binds caseId, epoch, juror, payload, nonce, expiry ----
    function _ballotSig(
        bytes32 caseId, uint256 epoch, address juror, bytes32 payloadHash,
        uint256 nonce, uint64 expiry, bool isReveal, uint256 pk
    ) internal view returns (bytes memory) {
        bytes32 typeHash = isReveal
            ? keccak256("RevealBallot(bytes32 caseId,uint256 epoch,address juror,bytes32 payloadHash,uint256 nonce,uint64 expiry)")
            : keccak256("CommitBallot(bytes32 caseId,uint256 epoch,address juror,bytes32 payloadHash,uint256 nonce,uint64 expiry)");
        bytes32 structHash =
            keccak256(abi.encode(typeHash, caseId, epoch, juror, payloadHash, nonce, expiry));
        bytes32 digest =
            keccak256(abi.encodePacked("\x19\x01", pool.BALLOT_DOMAIN_SEPARATOR(), structHash));
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(pk, digest);
        return abi.encodePacked(r, s, v);
    }

    uint256 internal constant NONCE_MASK = (1 << 128) - 1;
}