#!/usr/bin/env python3
"""Clean-room verifier for a CAIN Governance State proof. ZERO CAIN imports.

    python3 state_verifier.py <STATE_PROOF.json> <PINNED_MEMBERS.json>

Independently recomputes each state root, verifies chain continuity, monotone sequence and epoch,
that each transition's resulting root equals the next state's root, and that every transition carries
Ed25519 signatures over its commit digest from >= ceil((n+f+1)/2) distinct members of the PINNED
membership file (obtained out of band). Any membership inside the proof is ignored: a proof cannot
vouch for its own signers. Exit 0 = verified.

Fixed 2026-10-05 (F-E03-1): v1 of this verifier accepted {"valid": true, "signers": [...]} dicts.

    commit digest = SHA-256("CAIN-ACP-H/govstate.commit.v1\0" || canonical(transition))
    signed bytes  = "CAIN-ACP-SIG/govstate.commit.v1\0" || commit digest (32 bytes)
"""
from __future__ import annotations

import base64
import hashlib
import json
import sys

from cryptography.exceptions import InvalidSignature
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

DIMENSIONS = ("identity", "authority", "capability", "delegation", "policy", "trust", "risk",
              "intent", "plan", "action", "resource", "tool", "model", "execution", "evidence",
              "revocation", "budget", "tenant", "governance", "incident", "recovery")


def canon(d) -> bytes:
    return json.dumps(d, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")


def sha(d) -> str:
    return hashlib.sha256(canon(d)).hexdigest()


def state_root(state: dict) -> str:
    return sha({"sequence": state.get("sequence"), "governance_epoch": state.get("governance_epoch"),
                "previous_state_root": state.get("previous_state_root", ""),
                "schema_version": state.get("schema_version", "cain.govstate.v1"),
                "dimensions": {k: (state.get("dimensions") or {}).get(k) for k in DIMENSIONS}})


def commit_digest(tr: dict) -> bytes:
    return hashlib.sha256(b"CAIN-ACP-H/govstate.commit.v1\0" + canon(tr)).digest()


def sig_ok(pub_b64: str, digest: bytes, sig_b64: str) -> bool:
    try:
        sig = base64.b64decode(sig_b64, validate=True)
        if base64.b64encode(sig).decode() != sig_b64 or len(sig) != 64:
            return False
        Ed25519PublicKey.from_public_bytes(base64.b64decode(pub_b64, validate=True)).verify(
            sig, b"CAIN-ACP-SIG/govstate.commit.v1\0" + digest)
        return True
    except (InvalidSignature, ValueError, TypeError):
        return False


def verify(proof: dict, pinned: dict) -> list:
    problems = []
    members, f = pinned.get("members") or {}, pinned.get("f")
    if not isinstance(f, int) or f < 0 or len(members) < 3 * f + 1:
        return ["pinned membership invalid (need n >= 3f+1)"]
    quorum = -(-(len(members) + f + 1) // 2)
    certs = proof.get("certificates", [])
    states = proof.get("states", [])
    transitions = proof.get("transitions", [])
    if not states:
        return ["no states"]
    prev_root = ""
    prev_seq = -1
    prev_epoch = -1
    for i, st in enumerate(states):
        if state_root(st) != st.get("state_root"):
            problems.append(f"state {i}: state_root mismatch")
        if i > 0 and st.get("previous_state_root") != prev_root:
            problems.append(f"state {i}: chain break")
        if st.get("sequence", 0) <= prev_seq:
            problems.append(f"state {i}: sequence not monotone")
        if st.get("governance_epoch", 0) < prev_epoch:
            problems.append(f"state {i}: epoch rollback")
        prev_root, prev_seq, prev_epoch = st.get("state_root"), st.get("sequence", 0), st.get("governance_epoch", 0)
    if len(certs) != len(transitions) or len(transitions) != len(states) - 1:
        problems.append("states/transitions/certificates shape mismatch")
    for i, tr in enumerate(transitions):
        cert = certs[i] if i < len(certs) else {}
        sigs = cert.get("signatures") if isinstance(cert, dict) else None
        d = commit_digest(tr)
        good = {m for m, sg in (sigs or {}).items() if m in members and sig_ok(members[m], d, sg)}
        if len(good) < quorum:
            problems.append(f"transition {i}: {len(good)} valid pinned signatures < quorum {quorum}")
        if i + 1 < len(states) and tr.get("resulting_state_root") != states[i + 1].get("state_root"):
            problems.append(f"transition {i}: resulting root != next state root")
    return problems


def main(argv: list) -> int:
    if len(argv) < 3:
        print("usage: state_verifier.py <STATE_PROOF.json> <PINNED_MEMBERS.json>", file=sys.stderr); return 2
    proof = json.load(open(argv[1], encoding="utf-8"))
    pinned = json.load(open(argv[2], encoding="utf-8"))
    problems = verify(proof, pinned)
    if problems:
        print("STATE PROOF FAILED:")
        for p in problems:
            print("  -", p)
        return 1
    print("GOVERNANCE STATE PROOF VERIFIED (independent recomputation)")
    return 0


if __name__ == "__main__":
    raise SystemExit(main(sys.argv))
