verify.py

#!/usr/bin/env python3
"""
Independently verify a Kerne Honesty Index snapshot.

The whole point of this dataset is that you do not have to take its word for
anything, so this script takes nothing on trust either. It checks, in order:

  1. The attestation hash is really sha256 of the published canonical payload.
  2. The EIP-191 signature really recovers to the published signer address.
  3. The CSV in this repo really agrees with the snapshot JSON beside it.
  4. Optionally, the live endpoint still verifies too.

Usage
-----
    python verify.py                  # check the files in this repo
    python verify.py --live           # also fetch and check the live endpoint

Step 2 needs `eth_account` (`pip install eth-account`). Without it the script
still runs and reports step 2 as SKIPPED rather than silently passing, because
an unchecked signature reported as a tick is worse than no check at all.

Exit code is 0 only if every check that ran passed.
"""

from __future__ import annotations

import argparse
import csv
import hashlib
import json
import os
import sys
import urllib.request

HERE = os.path.dirname(os.path.abspath(__file__))
SNAPSHOT = os.path.join(HERE, "snapshot", "honesty-index-api-response.json")
CURRENT_CSV = os.path.join(HERE, "data", "current.csv")
LIVE_URL = "https://kerne.fi/api/honesty-index"

OK, FAIL, SKIP = "PASS", "FAIL", "SKIP"
results: list[tuple[str, str, str]] = []


def report(name: str, status: str, detail: str = "") -> None:
    results.append((name, status, detail))
    print("  [%s] %s%s" % (status, name, ("  " + detail) if detail else ""))


def fetch_live() -> dict | None:
    """Fetch the live snapshot, or explain why not and return None.

    A verification script that dies with a traceback on a network hiccup has
    told the reader nothing, so this reports and keeps going. The explicit
    User-Agent matters: the default urllib one is refused by the edge in front
    of the API, which looks exactly like the endpoint being down.
    """
    req = urllib.request.Request(
        LIVE_URL,
        headers={"User-Agent": "kerne-honesty-index-verify/1.0 (+https://kerne.fi/honesty-index)",
                 "Accept": "application/json"},
    )
    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            return json.loads(resp.read().decode("utf-8"))
    except Exception as exc:  # noqa: BLE001 - any failure here is reportable, not fatal
        print("  could not fetch the live endpoint: %s" % exc)
        print("  the checks against the files in this repo above are unaffected.")
        return None


def check_hash(snap: dict) -> bool:
    """attestation_hash == "0x" + sha256(utf8(signed_payload_canonical))."""
    canonical = snap.get("signed_payload_canonical")
    claimed = snap.get("attestation_hash")
    if not canonical or not claimed:
        report("attestation hash", FAIL, "snapshot carries no canonical payload or no hash")
        return False
    # Hash the PUBLISHED BYTES. Re-serializing the JSON would change key order
    # or spacing and the hash would not match; that is not a bug, it is the
    # check working.
    computed = "0x" + hashlib.sha256(canonical.encode("utf-8")).hexdigest()
    if computed == claimed:
        report("attestation hash", OK, claimed)
        return True
    report("attestation hash", FAIL, "computed %s, published %s" % (computed, claimed))
    return False


def check_signature(snap: dict) -> bool:
    """EIP-191 personal_sign over the RAW 32 BYTES of the attestation hash."""
    try:
        from eth_account import Account
        from eth_account.messages import encode_defunct
    except ImportError:
        report("signature -> signer", SKIP, "pip install eth-account to run this check")
        return True

    signature = snap.get("signature")
    signer = snap.get("signer")
    digest = snap.get("attestation_hash")
    if not (signature and signer and digest):
        report("signature -> signer", FAIL, "snapshot is missing signature, signer or hash")
        return False

    # Note the shape: the signed message is the 32 raw bytes of the hash, NOT
    # the hex string of it. Signing the string instead is the usual mistake.
    message = encode_defunct(primitive=bytes.fromhex(digest[2:]))
    recovered = Account.recover_message(message, signature=signature)
    if recovered.lower() == signer.lower():
        report("signature -> signer", OK, recovered)
        return True
    report("signature -> signer", FAIL, "recovered %s, published %s" % (recovered, signer))
    return False


def check_csv_matches(snap: dict) -> bool:
    """The CSV in this repo must describe the same snapshot as the JSON."""
    if not os.path.exists(CURRENT_CSV):
        report("csv agrees with snapshot", SKIP, "data/current.csv not found")
        return True

    with open(CURRENT_CSV, newline="", encoding="utf-8") as fh:
        rows = list(csv.DictReader(fh))

    snap_rows = {r["key"]: r for r in snap.get("rows", [])}
    if len(rows) != len(snap_rows):
        report("csv agrees with snapshot", FAIL, "%d csv rows vs %d snapshot rows" % (len(rows), len(snap_rows)))
        return False

    problems = []
    for row in rows:
        key = row["key"]
        if key not in snap_rows:
            problems.append("%s is in the csv but not the snapshot" % key)
            continue
        if row["snapshot_attestation_hash"] != snap.get("attestation_hash"):
            problems.append("%s carries a different attestation hash" % key)
        if row["snapshot_generated_at"] != snap.get("generated_at"):
            problems.append("%s carries a different generated_at" % key)
        realized = snap_rows[key].get("realized") or {}
        if realized.get("ok") and row["realized_apy_pct"]:
            if abs(float(row["realized_apy_pct"]) - float(realized["annualizedPct"])) > 1e-6:
                problems.append("%s realized apy disagrees" % key)
        # A blank must never have been written as a zero. This is the single
        # most damaging thing this file could get wrong about a third party.
        if row["comparability"] != "direct" and row["gap_pp"] != "":
            problems.append("%s states a gap it is not entitled to state" % key)

    if problems:
        report("csv agrees with snapshot", FAIL, "; ".join(problems[:5]))
        return False
    report("csv agrees with snapshot", OK, "%d rows, hashes and gaps consistent" % len(rows))
    return True


def check_blank_not_zero(snap: dict) -> bool:
    """No row may publish a gap of exactly 0 where it meant 'not comparable'."""
    if not os.path.exists(CURRENT_CSV):
        report("blanks are blank, not zero", SKIP, "data/current.csv not found")
        return True
    with open(CURRENT_CSV, newline="", encoding="utf-8") as fh:
        rows = list(csv.DictReader(fh))
    stated = [r for r in rows if r["gap_pp"] != ""]
    blank = [r for r in rows if r["gap_pp"] == ""]
    bad = [r["key"] for r in blank if r["comparability"] == "direct" and r["realized_ok"] == "true"]
    if bad:
        report("blanks are blank, not zero", FAIL, "comparable rows with no gap: %s" % ", ".join(bad))
        return False
    report("blanks are blank, not zero", OK, "%d rows state a gap, %d correctly do not" % (len(stated), len(blank)))
    return True


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("--live", action="store_true", help="also fetch and verify the live endpoint")
    args = parser.parse_args()

    if not os.path.exists(SNAPSHOT):
        print("Cannot find %s" % SNAPSHOT, file=sys.stderr)
        return 2

    with open(SNAPSHOT, encoding="utf-8") as fh:
        snap = json.load(fh)

    print("Snapshot in this repo: %s" % snap.get("generated_at"))
    check_hash(snap)
    check_signature(snap)
    check_csv_matches(snap)
    check_blank_not_zero(snap)

    if args.live:
        print("\nLive endpoint: %s" % LIVE_URL)
        live = fetch_live()
        if live is None:
            report("live endpoint", SKIP, "could not be fetched, see the message above")
        else:
            print("Live snapshot: %s" % live.get("generated_at"))
            check_hash(live)
            check_signature(live)
            if live.get("generated_at") != snap.get("generated_at"):
                print("\n  NOTE: the live snapshot is newer than this repo's copy. That is expected.")
                print("  The live endpoint is always correct; this repo is a lagging mirror.")

    failed = [r for r in results if r[1] == FAIL]
    skipped = [r for r in results if r[1] == SKIP]
    print("\n%d checks, %d failed, %d skipped." % (len(results), len(failed), len(skipped)))
    return 1 if failed else 0


if __name__ == "__main__":
    sys.exit(main())