The Keystone, proven on-chain

#!/usr/bin/env python3
"""Independent offline verifier for the AlgoVoi four-protocol Keystone proof pack.

Depends only on SHA-256 and Ed25519 (stdlib) plus RFC 8785 JSON Canonicalisation
(pip install rfc8785 cryptography). It reads keystone_4proto_pack.json and, using
nothing from AlgoVoi, re-derives every content-addressed reference, verifies every
decision signature, and confirms the four protocol chains converge on one settlement.

  python verify_4proto.py keystone_4proto_pack.json

Exit code 0 iff every check passes. No network call is made; re-scan the transaction
on the public Base Sepolia explorer yourself to confirm the settlement is real.
"""
import sys, json, base64, hashlib

import rfc8785
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

PROTOCOLS = ["x402", "mpp", "ap2", "a2a"]

def ref(obj):
    return "sha256:" + hashlib.sha256(rfc8785.dumps(obj)).hexdigest()

def b64u_dec(s):
    return base64.urlsafe_b64decode(s + "=" * ((-len(s)) % 4))

def verify_decision_signature(sig, decision_obj):
    """Verify the compact EdDSA JWS and confirm it covers the exact decision object."""
    pk = Ed25519PublicKey.from_public_bytes(base64.b64decode(sig["authority_pubkey_b64"]))
    h, p, s = sig["jws"].split(".")
    pk.verify(b64u_dec(s), f"{h}.{p}".encode())          # raises on a bad signature
    payload = json.loads(b64u_dec(p))
    return payload == decision_obj

def main(path):
    pack = json.load(open(path, encoding="utf-8"))
    checks = []
    def ck(name, ok): checks.append((name, bool(ok))); print(f"  [{'PASS' if ok else 'FAIL'}] {name}")

    tx = pack["tx"]
    settlement_ref = pack["settlement"]["settlement_ref"]
    ck("settlement_ref == sha256:JCS(settlement_attestation)",
       ref(pack["settlement"]["attestation"]) == settlement_ref)
    ck("passport_ref recomputes",
       ref(pack["passport_object"]) == pack["protocols"]["x402"]["passport_ref"])
    ck("compose timestamp precedes settlement block",
       pack["compose_ts_ms"] / 1000.0 < pack["settlement_block"]["timestamp_s"])

    seen_settlement, mandate_refs, tq_refs = set(), set(), set()
    for proto in PROTOCOLS:
        c = pack["protocols"][proto]
        ck(f"[{proto}] mandate_ref recomputes", ref(c["mandate_object"]) == c["mandate_ref"])
        ck(f"[{proto}] policy_bound_ref recomputes", ref(c["policy_object"]) == c["policy_bound_ref"])
        ck(f"[{proto}] decision_ref recomputes", ref(c["decision_object"]) == c["decision_ref"])
        ck(f"[{proto}] execution_ref recomputes", ref(c["execution_object"]) == c["execution_ref"])
        ck(f"[{proto}] mandate embeds passport_ref",
           c["mandate_object"].get("passport_ref") == c["passport_ref"])
        ck(f"[{proto}] policy embeds mandate_ref",
           c["policy_object"].get("mandate_ref") == c["mandate_ref"])
        ck(f"[{proto}] decision embeds policy_bound_ref",
           c["decision_object"].get("policy_bound_ref") == c["policy_bound_ref"])
        ck(f"[{proto}] execution embeds decision_ref",
           c["execution_object"].get("decision_ref") == c["decision_ref"])
        ck(f"[{proto}] execution binds shared settlement_ref + this tx",
           c["execution_object"].get("settlement_ref") == settlement_ref
           and c["execution_object"]["settlement"]["tx_id"] == tx)
        ck(f"[{proto}] decision signature valid + covers decision object",
           verify_decision_signature(c["decision_signature"], c["decision_object"]))
        seen_settlement.add(c["settlement_ref"]); mandate_refs.add(c["mandate_ref"]); tq_refs.add(c["trust_query_ref"])

    ck("all four protocols converge on ONE settlement_ref", seen_settlement == {settlement_ref})
    ck("four protocol-distinct mandate_refs", len(mandate_refs) == 4)
    ck("four protocol-distinct trust_query_refs", len(tq_refs) == 4)

    passed = sum(1 for _, ok in checks if ok)
    print(f"\n{passed}/{len(checks)} checks pass  (tx {tx})")
    print(f"settlement_ref {settlement_ref}")
    return 0 if passed == len(checks) else 1

if __name__ == "__main__":
    sys.exit(main(sys.argv[1] if len(sys.argv) > 1 else "keystone_4proto_pack.json"))