proofchain-cli 0.1.0__tar.gz

proofchain_cli-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: proofchain-cli
+Version: 0.1.0
+Summary: Hash-chained, signed, independently-verifiable audit proofs for any Postgres table of real events.
+Requires-Python: >=3.9
+Requires-Dist: psycopg2-binary
+Requires-Dist: cryptography

proofchain_cli-0.1.0/README.md

@@ -0,0 +1,44 @@
+# proofchain
+
+Point it at any Postgres table of real events. Get a hash-chained,
+Ed25519-signed, append-only proof log. Anyone can independently verify
+the chain — no trust in the operator required.
+
+## Why
+
+Most "proof of X" claims in finance and crypto are just numbers an
+operator generated internally, with no way for an outside party to
+check them. proofchain fixes that generically: point it at any table,
+any columns, and get a cryptographic chain that's tamper-evident and
+independently re-verifiable by anyone, using only the public key.
+
+## Install
+
+    pip install proofchain
+
+## Example: a small business proving payout history to a lender
+
+    export PROOFCHAIN_DSN="postgresql://user@host:port/business_db"
+    export PROOFCHAIN_KEYFILE="/path/to/signing_key.json"
+
+    proofchain build \
+        --table vendor_payouts \
+        --id-col id \
+        --columns vendor_name,amount_usd,paid_at \
+        --where "status = 'completed'" \
+        --order-by paid_at \
+        --log ./payout_proof.jsonl
+
+    proofchain verify --log ./payout_proof.jsonl
+
+The lender (or anyone) can independently re-run `verify` against the
+same log file and confirm nothing was altered — without ever needing
+API access to the business's database or having to trust the business
+at all.
+
+## How it works
+
+Each `build` run snapshots the specified rows, signs them with your
+Ed25519 key, and chains the entry to the previous one via SHA-256.
+Any edit to historical data breaks the hash chain on the next verify.
+No table or column names are hardcoded — this works on any schema.

proofchain_cli-0.1.0/proofchain/cli.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+proofchain.py — generic hash-chained, signed audit-proof CLI.
+
+Point it at ANY Postgres table of real events (trades, sales, burns,
+whatever) and get a tamper-evident, independently-verifiable proof log.
+Generalized from omega_revenue_proof.py — same mechanism, config-driven
+instead of hardcoded to one schema.
+
+Usage:
+  export PROOFCHAIN_DSN="postgresql://user@host:port/db"
+  export PROOFCHAIN_KEYFILE="/path/to/key.json"   # {"secret":[...]} or [...]
+
+  python3 proofchain.py build \
+      --table my_trades \
+      --id-col id \
+      --columns symbol,pnl_usdt,closed_at \
+      --where "status IN ('closed_profit','closed_stop') AND closed_at IS NOT NULL" \
+      --order-by closed_at \
+      --log ./my_proof.jsonl
+
+  python3 proofchain.py verify --log ./my_proof.jsonl
+
+No table/column names are hardcoded. Nothing here reads or writes
+omega_bank, omega_ledger, or any Omega-specific table unless you pass
+those names explicitly via --table.
+"""
+import os, sys, json, base64, argparse, hashlib
+from pathlib import Path
+from datetime import datetime, timezone
+
+import psycopg2
+from cryptography.hazmat.primitives.asymmetric.ed25519 import (
+    Ed25519PrivateKey, Ed25519PublicKey
+)
+from cryptography.exceptions import InvalidSignature
+
+
+def load_signer():
+    keyfile = os.environ.get("PROOFCHAIN_KEYFILE")
+    if not keyfile:
+        sys.exit("PROOFCHAIN_KEYFILE env var not set — no placeholder key will be used.")
+    data = json.loads(Path(keyfile).read_text())
+    raw = bytes(data["secret"][:32]) if isinstance(data, dict) else bytes(data[:32])
+    priv = Ed25519PrivateKey.from_private_bytes(raw)
+    pub = priv.public_key()
+    return priv, pub
+
+
+def build(args):
+    dsn = os.environ.get("PROOFCHAIN_DSN")
+    if not dsn:
+        sys.exit("PROOFCHAIN_DSN env var not set.")
+
+    priv, pub = load_signer()
+    cols = [c.strip() for c in args.columns.split(",")]
+    select_cols = ", ".join([args.id_col] + cols)
+
+    query = f"SELECT {select_cols} FROM {args.table}"
+    if args.where:
+        query += f" WHERE {args.where}"
+    if args.order_by:
+        query += f" ORDER BY {args.order_by} ASC"
+
+    conn = psycopg2.connect(dsn)
+    with conn.cursor() as cur:
+        cur.execute(query)
+        rows = cur.fetchall()
+    conn.close()
+
+    records = []
+    for row in rows:
+        rec = {"id": str(row[0])}
+        for i, col in enumerate(cols):
+            rec[col] = str(row[i + 1]) if row[i + 1] is not None else None
+        records.append(rec)
+
+    log_path = Path(args.log)
+    prev_hash = "genesis"
+    if log_path.exists() and log_path.stat().st_size > 0:
+        last_line = log_path.read_text().strip().splitlines()[-1]
+        prev_hash = json.loads(last_line)["entry_hash"]
+
+    snapshot = {
+        "type": "proofchain_snapshot",
+        "table": args.table,
+        "record_count": len(records),
+        "records": records,
+        "prev_hash": prev_hash,
+        "built_at": datetime.now(timezone.utc).isoformat(),
+    }
+    msg = json.dumps(snapshot, sort_keys=True, default=str).encode()
+    sig = base64.b64encode(priv.sign(msg)).decode()
+    entry_hash = hashlib.sha256(msg + sig.encode()).hexdigest()
+    snapshot["signature"] = sig
+    snapshot["entry_hash"] = entry_hash
+
+    with open(log_path, "a") as f:
+        f.write(json.dumps(snapshot, default=str) + "\n")
+
+    print(f"Snapshot written. {len(records)} record(s) from '{args.table}'. "
+          f"entry_hash={entry_hash[:16]}...")
+    print(f"Log: {log_path}")
+
+
+def verify(args):
+    priv, pub = load_signer()
+    log_path = Path(args.log)
+    if not log_path.exists():
+        print("No log yet.")
+        return
+
+    lines = log_path.read_text().strip().splitlines()
+    prev_hash = "genesis"
+    ok = True
+    for i, line in enumerate(lines):
+        record = json.loads(line)
+        sig = record.pop("signature")
+        claimed_hash = record.pop("entry_hash")
+        if record.get("prev_hash") != prev_hash:
+            print(f"  [BROKEN CHAIN] entry {i}: expected prev_hash={prev_hash}, "
+                  f"got {record.get('prev_hash')}")
+            ok = False
+        msg = json.dumps(record, sort_keys=True, default=str).encode()
+        try:
+            pub.verify(base64.b64decode(sig), msg)
+        except InvalidSignature:
+            print(f"  [BAD SIGNATURE] entry {i}")
+            ok = False
+        recomputed = hashlib.sha256(msg + sig.encode()).hexdigest()
+        if recomputed != claimed_hash:
+            print(f"  [HASH MISMATCH] entry {i}")
+            ok = False
+        prev_hash = claimed_hash
+
+    print("VERIFIED: chain intact, all signatures valid" if ok
+          else "FAILED: tampering or corruption detected")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    b = sub.add_parser("build")
+    b.add_argument("--table", required=True)
+    b.add_argument("--id-col", default="id")
+    b.add_argument("--columns", required=True, help="comma-separated column list")
+    b.add_argument("--where", default="")
+    b.add_argument("--order-by", default="")
+    b.add_argument("--log", required=True)
+
+    v = sub.add_parser("verify")
+    v.add_argument("--log", required=True)
+
+    args = parser.parse_args()
+    if args.cmd == "build":
+        build(args)
+    elif args.cmd == "verify":
+        verify(args)
+
+
+if __name__ == "__main__":
+    main()

proofchain_cli-0.1.0/proofchain_cli.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: proofchain-cli
+Version: 0.1.0
+Summary: Hash-chained, signed, independently-verifiable audit proofs for any Postgres table of real events.
+Requires-Python: >=3.9
+Requires-Dist: psycopg2-binary
+Requires-Dist: cryptography

proofchain_cli-0.1.0/proofchain_cli.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+proofchain/__init__.py
+proofchain/cli.py
+proofchain_cli.egg-info/PKG-INFO
+proofchain_cli.egg-info/SOURCES.txt
+proofchain_cli.egg-info/dependency_links.txt
+proofchain_cli.egg-info/entry_points.txt
+proofchain_cli.egg-info/requires.txt
+proofchain_cli.egg-info/top_level.txt

proofchain_cli-0.1.0/proofchain_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

proofchain_cli-0.1.0/proofchain_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+proofchain = proofchain.cli:main

proofchain_cli-0.1.0/proofchain_cli.egg-info/requires.txt

@@ -0,0 +1,2 @@
+psycopg2-binary
+cryptography

proofchain_cli-0.1.0/proofchain_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+proofchain

proofchain_cli-0.1.0/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "proofchain-cli"
+version = "0.1.0"
+description = "Hash-chained, signed, independently-verifiable audit proofs for any Postgres table of real events."
+requires-python = ">=3.9"
+dependencies = ["psycopg2-binary", "cryptography"]
+
+[project.scripts]
+proofchain = "proofchain.cli:main"

proofchain_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+