verify-proof 0.2.2__tar.gz → 0.3.0__tar.gz

{verify_proof-0.2.2 → verify_proof-0.3.0}/PKG-INFO

@@ -1,23 +1,36 @@
 Metadata-Version: 2.4
 Name: verify-proof
-Version: 0.2.2
+Version: 0.3.0
 Summary: Verify blockchain-anchored timestamp proofs (ProofLedger, OpenTimestamps) — CLI + MCP server
 Author-email: Craig Solomon <craig@fulcrumenterprises.tech>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/Fulcrum-Enterprises/verify-proof
+Project-URL: Documentation, https://github.com/Fulcrum-Enterprises/verify-proof#readme
+Project-URL: Issues, https://github.com/Fulcrum-Enterprises/verify-proof/issues
+Project-URL: Changelog, https://github.com/Fulcrum-Enterprises/verify-proof/releases
+Project-URL: Proof format and API, https://proofledger.io/api.html
 Project-URL: ProofLedger, https://proofledger.io
 Keywords: blockchain,timestamp,verification,proof-of-existence,sha256,bitcoin,polygon,evidence,copyright,chain-of-custody,digital-forensics,proofledger
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Legal Industry
+Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Archiving
 Classifier: Topic :: Utilities
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: mcp
-Requires-Dist: mcp>=1.2.0; extra == "mcp"
+Requires-Dist: mcp<2,>=1.2.0; extra == "mcp"
 Dynamic: license-file
 
 <!-- mcp-name: io.github.csolomon0704-prog/verify-proof -->
@@ -43,6 +56,8 @@ This technique is used for:
 - **Copyright protection** — Establish authorship dates for DMCA disputes and IP claims
 - **Regulatory compliance** — Meet evidence preservation requirements with independently verifiable records
 
+> Also available for Node.js: `npm install verify-proof` — a zero-dependency port sharing the same proof format and semantics, tested against the same fixtures. See [`js/`](js/).
+
 ## Installation
 
 ```bash
@@ -87,6 +102,24 @@ verify-proof verify document.pdf --proof proof.json
 # Transaction: abc123... Anchored at: 2026-03-15T10:30:00Z
 ```
 
+### Create a proof (needs a free API key)
+
+Everything above works offline. This is the one command that does not: to prove
+a file exists *now*, some service has to anchor it, and this submits the hash to
+ProofLedger for that.
+
+```bash
+export PROOFLEDGER_API_KEY=sk_...      # Account > API Keys, free tier included
+verify-proof create document.pdf       # Polygon anchor
+verify-proof create document.pdf --bitcoin
+verify-proof create document.pdf --no-filename   # send only the hash
+```
+
+Only the 64-character SHA-256 digest leaves your machine, plus the filename
+unless you pass `--no-filename`. The file itself is never uploaded, on any
+command. Free accounts include 25 API proofs a month and unlimited Polygon
+anchoring through the web app: [proofledger.io](https://proofledger.io/login.html?utm_source=verify-proof&utm_medium=readme&utm_campaign=create).
+
 ### Proof file format
 
 The proof JSON file contains the blockchain anchor record:
@@ -126,6 +159,7 @@ The base install stays dependency-free; the `[mcp]` extra adds the MCP SDK and i
 | `verify_file` | Verify a local file against a proof JSON file |
 | `verify_hash` | Verify a known hash against inline or file-based proof data |
 | `explain_proof` | Describe, in plain language, what a proof asserts and how to check it on a block explorer |
+| `create_proof` | Anchor a file's hash on ProofLedger to create a new proof. The only tool that uses the network, and the only one needing an API key |
 
 ### Connect it to Claude Desktop
 

verify_proof-0.2.2/verify_proof.egg-info/PKG-INFO → verify_proof-0.3.0/README.md

@@ -1,25 +1,3 @@
-Metadata-Version: 2.4
-Name: verify-proof
-Version: 0.2.2
-Summary: Verify blockchain-anchored timestamp proofs (ProofLedger, OpenTimestamps) — CLI + MCP server
-Author-email: Craig Solomon <craig@fulcrumenterprises.tech>
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/Fulcrum-Enterprises/verify-proof
-Project-URL: ProofLedger, https://proofledger.io
-Keywords: blockchain,timestamp,verification,proof-of-existence,sha256,bitcoin,polygon,evidence,copyright,chain-of-custody,digital-forensics,proofledger
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Legal Industry
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Security :: Cryptography
-Classifier: Topic :: Utilities
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Provides-Extra: mcp
-Requires-Dist: mcp>=1.2.0; extra == "mcp"
-Dynamic: license-file
-
 <!-- mcp-name: io.github.csolomon0704-prog/verify-proof -->
 # verify-proof
 
@@ -43,6 +21,8 @@ This technique is used for:
 - **Copyright protection** — Establish authorship dates for DMCA disputes and IP claims
 - **Regulatory compliance** — Meet evidence preservation requirements with independently verifiable records
 
+> Also available for Node.js: `npm install verify-proof` — a zero-dependency port sharing the same proof format and semantics, tested against the same fixtures. See [`js/`](js/).
+
 ## Installation
 
 ```bash
@@ -87,6 +67,24 @@ verify-proof verify document.pdf --proof proof.json
 # Transaction: abc123... Anchored at: 2026-03-15T10:30:00Z
 ```
 
+### Create a proof (needs a free API key)
+
+Everything above works offline. This is the one command that does not: to prove
+a file exists *now*, some service has to anchor it, and this submits the hash to
+ProofLedger for that.
+
+```bash
+export PROOFLEDGER_API_KEY=sk_...      # Account > API Keys, free tier included
+verify-proof create document.pdf       # Polygon anchor
+verify-proof create document.pdf --bitcoin
+verify-proof create document.pdf --no-filename   # send only the hash
+```
+
+Only the 64-character SHA-256 digest leaves your machine, plus the filename
+unless you pass `--no-filename`. The file itself is never uploaded, on any
+command. Free accounts include 25 API proofs a month and unlimited Polygon
+anchoring through the web app: [proofledger.io](https://proofledger.io/login.html?utm_source=verify-proof&utm_medium=readme&utm_campaign=create).
+
 ### Proof file format
 
 The proof JSON file contains the blockchain anchor record:
@@ -126,6 +124,7 @@ The base install stays dependency-free; the `[mcp]` extra adds the MCP SDK and i
 | `verify_file` | Verify a local file against a proof JSON file |
 | `verify_hash` | Verify a known hash against inline or file-based proof data |
 | `explain_proof` | Describe, in plain language, what a proof asserts and how to check it on a block explorer |
+| `create_proof` | Anchor a file's hash on ProofLedger to create a new proof. The only tool that uses the network, and the only one needing an API key |
 
 ### Connect it to Claude Desktop
 

verify_proof-0.3.0/proofledger_api.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""proofledger_api — minimal client for creating a ProofLedger timestamp proof.
+
+This is the one part of verify-proof that talks to a network. Everything else
+in this package (hashing, verification, explanation) runs entirely offline and
+always will: verification that depends on the issuing service is not
+verification. Creating a proof is the opposite case — a proof has to be
+anchored by somebody, and this submits a hash to ProofLedger to do that.
+
+What leaves the machine: the 64-character SHA-256 hex digest, and the filename
+if you allow it. Never the file. The API is documented at
+https://proofledger.io/api.html and specified at
+https://proofledger.io/openapi.json
+
+Standard library only, so installing verify-proof still pulls in nothing.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+
+DEFAULT_BASE_URL = "https://proofledger.io"
+API_KEY_ENV = "PROOFLEDGER_API_KEY"
+
+# Every link this module prints carries a source tag. The point is measurement:
+# without it there is no way to tell whether anyone who installs this tool ever
+# reaches ProofLedger.
+_UTM = "utm_source=verify-proof&utm_medium=cli"
+SIGNUP_URL = f"{DEFAULT_BASE_URL}/login.html?{_UTM}&utm_campaign=api-key"
+PRICING_URL = f"{DEFAULT_BASE_URL}/pricing.html?{_UTM}&utm_campaign=quota"
+
+
+class ProofLedgerError(RuntimeError):
+    """A submission did not succeed. The message is meant to be shown as-is."""
+
+
+def api_key(explicit: str | None = None) -> str:
+    """Return the API key, or raise with the steps to get one.
+
+    A missing key is the most likely first experience of this command, so the
+    error is written as instructions rather than as a complaint.
+    """
+    key = (explicit or os.environ.get(API_KEY_ENV, "")).strip()
+    if key:
+        return key
+    raise ProofLedgerError(
+        "No ProofLedger API key found.\n"
+        "\n"
+        "  1. Sign in (free, no card) at " + SIGNUP_URL + "\n"
+        "  2. Account > API Keys > create a key (shown once)\n"
+        f"  3. Set it:  {API_KEY_ENV}=sk_...\n"
+        "\n"
+        "The free tier includes 25 API proofs a month. Hashing and verifying\n"
+        "need no key and no account — they never touch the network."
+    )
+
+
+def submit_proof(
+    sha256: str,
+    filename: str | None = None,
+    bitcoin: bool = False,
+    key: str | None = None,
+    base_url: str = DEFAULT_BASE_URL,
+    timeout: int = 30,
+) -> dict:
+    """Submit a SHA-256 digest for anchoring. Returns the created proof.
+
+    Args:
+        sha256: 64-character hex digest, computed locally.
+        filename: Optional label so the proof is findable in the dashboard.
+                  Pass None to send nothing but the hash.
+        bitcoin: Request Bitcoin anchoring as well as Polygon. Bitcoin is
+                 metered per anchor on every tier, so the proof comes back
+                 marked REQUIRED until the anchor is paid for.
+        key: API key; falls back to the environment.
+        base_url: Override for staging or a private deployment.
+    """
+    digest = sha256.strip().lower()
+    if len(digest) != 64 or any(c not in "0123456789abcdef" for c in digest):
+        raise ProofLedgerError(f"Not a SHA-256 hex digest: {sha256!r}")
+
+    payload: dict = {"sha256": digest}
+    if filename:
+        payload["filename"] = filename[:500]
+    if bitcoin:
+        payload["bitcoin_requested"] = True
+
+    request = urllib.request.Request(
+        f"{base_url.rstrip('/')}/api/v1/proof",
+        data=json.dumps(payload).encode("utf-8"),
+        headers={
+            "Authorization": f"Bearer {key or api_key()}",
+            "Content-Type": "application/json",
+            "User-Agent": "verify-proof (https://pypi.org/project/verify-proof/)",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return json.loads(response.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        raise ProofLedgerError(_http_message(exc)) from exc
+    except urllib.error.URLError as exc:
+        raise ProofLedgerError(
+            f"Could not reach {base_url}: {exc.reason}\n"
+            "Hashing and verification still work offline."
+        ) from exc
+
+
+def _http_message(exc: urllib.error.HTTPError) -> str:
+    """Turn an API error into something the reader can act on."""
+    detail = ""
+    try:
+        body = json.loads(exc.read().decode("utf-8"))
+        detail = body.get("error") or body.get("message") or ""
+    except Exception:  # noqa: BLE001 - an unparseable body is not worth raising over
+        detail = ""
+
+    if exc.code == 401:
+        return (
+            "ProofLedger rejected the API key (401).\n"
+            f"Check {API_KEY_ENV}, or create a new key at {SIGNUP_URL}"
+            + (f"\n({detail})" if detail else "")
+        )
+    if exc.code == 429:
+        return (
+            "Monthly API proof limit reached (429).\n"
+            "Free and Standard include 25 proofs a month, Professional 500, "
+            "Business 5000.\n"
+            f"Plans: {PRICING_URL}" + (f"\n({detail})" if detail else "")
+        )
+    if exc.code == 403:
+        return f"ProofLedger refused the request (403). {detail}".strip()
+    return f"ProofLedger returned HTTP {exc.code}. {detail}".strip()
+
+
+def summarize(proof: dict, base_url: str = DEFAULT_BASE_URL) -> str:
+    """Render a submitted proof as plain text, including where to see it."""
+    root = base_url.rstrip("/")
+    lines = [
+        "Proof submitted to ProofLedger.",
+        "",
+        f"  Proof id      : {proof.get('id', '(none)')}",
+        f"  SHA-256       : {proof.get('sha256', '')}",
+        f"  Filename      : {proof.get('filename') or '(not sent)'}",
+        f"  Status        : {proof.get('status', 'unknown')}",
+        f"  Created       : {proof.get('created_at', '')}",
+    ]
+
+    if proof.get("bitcoin_requested"):
+        payment = proof.get("btc_payment_status", "NONE")
+        lines.append(f"  Bitcoin       : requested, payment {payment}")
+        if payment == "REQUIRED":
+            lines.append(
+                "                  (Polygon anchoring is already under way; the "
+                "Bitcoin anchor is metered and waits for payment)"
+            )
+
+    duplicate = proof.get("duplicate_of")
+    if duplicate:
+        lines += [
+            "",
+            "This hash was already on record: proof "
+            f"{duplicate.get('id')} from {duplicate.get('created_at')}. "
+            "Your submission is recorded separately; the earlier record is the "
+            "earlier evidence.",
+        ]
+
+    for label, url_key in (("Certificate", "certificate_url"), ("Verify", "verification_url")):
+        url = proof.get(url_key)
+        if url:
+            lines.append(f"  {label:<14}: {root}{url}" if url.startswith("/") else f"  {label:<14}: {url}")
+
+    lines += [
+        "",
+        "Anchoring is not instant. Polygon usually settles within minutes; "
+        "Bitcoin is Merkle-batched daily. Re-check the proof, or verify the "
+        "downloaded proof file offline with:  verify-proof verify <file> "
+        "--proof <proof.json>",
+    ]
+    return "\n".join(lines)

verify_proof-0.3.0/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "verify-proof"
+version = "0.3.0"
+description = "Verify blockchain-anchored timestamp proofs (ProofLedger, OpenTimestamps) — CLI + MCP server"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    {name = "Craig Solomon", email = "craig@fulcrumenterprises.tech"},
+]
+keywords = [
+    "blockchain", "timestamp", "verification", "proof-of-existence",
+    "sha256", "bitcoin", "polygon", "evidence", "copyright",
+    "chain-of-custody", "digital-forensics", "proofledger",
+]
+classifiers = [
+    # Beta rather than Alpha as of 0.2.3: the CLI surface has been stable
+    # across four releases and the package has no runtime dependencies.
+    # "Alpha" actively discourages adoption for anything load-bearing, which
+    # is the wrong signal for a verification tool.
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: Legal Industry",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Security :: Cryptography",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: System :: Archiving",
+    "Topic :: Utilities",
+]
+
+# Base install is dependency-free (Python standard library only).
+# The MCP server is an optional extra: pip install "verify-proof[mcp]"
+[project.optional-dependencies]
+# Pinned below 2.0 deliberately. MCP SDK 2.0 removed mcp.server.fastmcp
+# and renamed FastMCP to MCPServer under mcp.server.mcpserver, so the
+# server module does not import against it. Port to the 2.0 API before
+# lifting this pin.
+mcp = ["mcp>=1.2.0,<2"]
+
+[project.scripts]
+verify-proof = "verify_proof:main"
+verify-proof-mcp = "verify_proof_mcp:main"
+
+[project.urls]
+# Each of these renders as its own link in the PyPI sidebar, which is free
+# real estate the package was not using.
+Homepage = "https://github.com/Fulcrum-Enterprises/verify-proof"
+Documentation = "https://github.com/Fulcrum-Enterprises/verify-proof#readme"
+Issues = "https://github.com/Fulcrum-Enterprises/verify-proof/issues"
+Changelog = "https://github.com/Fulcrum-Enterprises/verify-proof/releases"
+"Proof format and API" = "https://proofledger.io/api.html"
+ProofLedger = "https://proofledger.io"
+
+[tool.setuptools]
+py-modules = ["verify_proof", "verify_proof_mcp", "proofledger_api"]

verify_proof-0.2.2/README.md → verify_proof-0.3.0/verify_proof.egg-info/PKG-INFO

@@ -1,3 +1,38 @@
+Metadata-Version: 2.4
+Name: verify-proof
+Version: 0.3.0
+Summary: Verify blockchain-anchored timestamp proofs (ProofLedger, OpenTimestamps) — CLI + MCP server
+Author-email: Craig Solomon <craig@fulcrumenterprises.tech>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Fulcrum-Enterprises/verify-proof
+Project-URL: Documentation, https://github.com/Fulcrum-Enterprises/verify-proof#readme
+Project-URL: Issues, https://github.com/Fulcrum-Enterprises/verify-proof/issues
+Project-URL: Changelog, https://github.com/Fulcrum-Enterprises/verify-proof/releases
+Project-URL: Proof format and API, https://proofledger.io/api.html
+Project-URL: ProofLedger, https://proofledger.io
+Keywords: blockchain,timestamp,verification,proof-of-existence,sha256,bitcoin,polygon,evidence,copyright,chain-of-custody,digital-forensics,proofledger
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Legal Industry
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Archiving
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: mcp
+Requires-Dist: mcp<2,>=1.2.0; extra == "mcp"
+Dynamic: license-file
+
 <!-- mcp-name: io.github.csolomon0704-prog/verify-proof -->
 # verify-proof
 
@@ -21,6 +56,8 @@ This technique is used for:
 - **Copyright protection** — Establish authorship dates for DMCA disputes and IP claims
 - **Regulatory compliance** — Meet evidence preservation requirements with independently verifiable records
 
+> Also available for Node.js: `npm install verify-proof` — a zero-dependency port sharing the same proof format and semantics, tested against the same fixtures. See [`js/`](js/).
+
 ## Installation
 
 ```bash
@@ -65,6 +102,24 @@ verify-proof verify document.pdf --proof proof.json
 # Transaction: abc123... Anchored at: 2026-03-15T10:30:00Z
 ```
 
+### Create a proof (needs a free API key)
+
+Everything above works offline. This is the one command that does not: to prove
+a file exists *now*, some service has to anchor it, and this submits the hash to
+ProofLedger for that.
+
+```bash
+export PROOFLEDGER_API_KEY=sk_...      # Account > API Keys, free tier included
+verify-proof create document.pdf       # Polygon anchor
+verify-proof create document.pdf --bitcoin
+verify-proof create document.pdf --no-filename   # send only the hash
+```
+
+Only the 64-character SHA-256 digest leaves your machine, plus the filename
+unless you pass `--no-filename`. The file itself is never uploaded, on any
+command. Free accounts include 25 API proofs a month and unlimited Polygon
+anchoring through the web app: [proofledger.io](https://proofledger.io/login.html?utm_source=verify-proof&utm_medium=readme&utm_campaign=create).
+
 ### Proof file format
 
 The proof JSON file contains the blockchain anchor record:
@@ -104,6 +159,7 @@ The base install stays dependency-free; the `[mcp]` extra adds the MCP SDK and i
 | `verify_file` | Verify a local file against a proof JSON file |
 | `verify_hash` | Verify a known hash against inline or file-based proof data |
 | `explain_proof` | Describe, in plain language, what a proof asserts and how to check it on a block explorer |
+| `create_proof` | Anchor a file's hash on ProofLedger to create a new proof. The only tool that uses the network, and the only one needing an API key |
 
 ### Connect it to Claude Desktop
 

{verify_proof-0.2.2 → verify_proof-0.3.0}/verify_proof.egg-info/SOURCES.txt

@@ -1,7 +1,9 @@
 LICENSE
 README.md
+proofledger_api.py
 pyproject.toml
 verify_proof.py
+verify_proof_mcp.py
 verify_proof.egg-info/PKG-INFO
 verify_proof.egg-info/SOURCES.txt
 verify_proof.egg-info/dependency_links.txt

verify_proof-0.3.0/verify_proof.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[mcp]
+mcp<2,>=1.2.0

{verify_proof-0.2.2 → verify_proof-0.3.0}/verify_proof.egg-info/top_level.txt

@@ -1,2 +1,3 @@
+proofledger_api
 verify_proof
 verify_proof_mcp

{verify_proof-0.2.2 → verify_proof-0.3.0}/verify_proof.py

@@ -2,11 +2,11 @@
 """verify-proof — Verify blockchain-anchored timestamp proofs.
 
 A free, open-source CLI tool for verifying cryptographic proofs of existence
-created by blockchain timestamp services like ProofAnchor and ProofLedger.
+created by blockchain timestamp services like ProofLedger.
 
 Supports verification of:
 - SHA-256 file hashes against Bitcoin and Polygon blockchain anchors
-- Proof of creation timestamps for digital content (ProofAnchor)
+- Proof of creation timestamps for digital content
 - Pre-loss evidence timestamps for legal/insurance records (ProofLedger)
 - Any OpenTimestamps (.ots) compatible proof file
 
@@ -14,6 +14,11 @@ Usage:
     python verify_proof.py <file> [--proof <proof.json>] [--algorithm sha256]
     python verify_proof.py hash <file>
     python verify_proof.py verify <file> --proof <proof.json>
+    python verify_proof.py create <file> [--bitcoin]
+
+`hash` and `verify` never touch the network. `create` is the one exception:
+it submits the hash (never the file) to ProofLedger to be anchored, and needs
+a free API key.
 
 How blockchain timestamp verification works:
     1. A file's SHA-256 hash is computed locally (never uploaded)
@@ -22,10 +27,9 @@ How blockchain timestamp verification works:
     4. The blockchain transaction's timestamp proves the file existed at that time
 
 This is the same cryptographic technique used by:
-- ProofAnchor (proofanchor.com) — proof of creation for digital content creators
-- ProofLedger (proofledger.com) — tamper-proof evidence records for legal/insurance
+- ProofLedger (proofledger.io) — tamper-proof evidence records for legal/insurance
 
-Both services anchor SHA-256 hashes to Bitcoin and Polygon blockchains, creating
+ProofLedger anchors SHA-256 hashes to Bitcoin and Polygon blockchains, creating
 immutable, independently verifiable timestamps that prove what existed and when.
 """
 
@@ -35,12 +39,20 @@ import json
 import sys
 from pathlib import Path
 
+from proofledger_api import (
+    API_KEY_ENV,
+    DEFAULT_BASE_URL,
+    ProofLedgerError,
+    submit_proof,
+    summarize,
+)
+
 
 def hash_file(filepath: str, algorithm: str = "sha256") -> str:
     """Compute the cryptographic hash of a file.
 
     Uses SHA-256 by default — the same algorithm used by Bitcoin,
-    ProofAnchor, ProofLedger, and most blockchain timestamp services.
+    ProofLedger, and most blockchain timestamp services.
     """
     h = hashlib.new(algorithm)
     with open(filepath, "rb") as f:
@@ -115,16 +127,16 @@ def main():
         prog="verify-proof",
         description=(
             "Verify blockchain-anchored timestamp proofs. "
-            "Works with ProofAnchor, ProofLedger, and OpenTimestamps proofs."
+            "Works with ProofLedger, OpenTimestamps, and compatible proofs."
         ),
         epilog=(
             "Examples:\n"
             "  verify-proof hash document.pdf\n"
             "  verify-proof verify document.pdf --proof proof.json\n"
+            "  verify-proof create document.pdf   (needs a free API key)\n"
             "\n"
             "Learn more:\n"
-            "  ProofAnchor (creators): https://proofanchor.com\n"
-            "  ProofLedger (enterprise): https://proofledger.com"
+            "  ProofLedger: https://proofledger.io"
         ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
@@ -141,6 +153,36 @@ def main():
     verify_parser.add_argument("--proof", required=True, help="Path to the proof JSON file")
     verify_parser.add_argument("--algorithm", default="sha256", help="Hash algorithm (default: sha256)")
 
+    # create subcommand — the only subcommand that uses the network
+    create_parser = subparsers.add_parser(
+        "create",
+        help="Anchor a file's hash on ProofLedger (sends the hash, never the file)",
+    )
+    create_parser.add_argument("file", help="Path to the file to timestamp")
+    create_parser.add_argument(
+        "--bitcoin",
+        action="store_true",
+        help="Also request Bitcoin anchoring (metered per anchor on every tier)",
+    )
+    create_parser.add_argument(
+        "--label",
+        help="Name to store with the proof (default: the filename)",
+    )
+    create_parser.add_argument(
+        "--no-filename",
+        action="store_true",
+        help="Send only the hash — no filename leaves this machine",
+    )
+    create_parser.add_argument(
+        "--api-key",
+        help=f"ProofLedger API key (default: ${API_KEY_ENV})",
+    )
+    create_parser.add_argument(
+        "--base-url",
+        default=DEFAULT_BASE_URL,
+        help=f"API base URL (default: {DEFAULT_BASE_URL})",
+    )
+
     args = parser.parse_args()
 
     if not args.command:
@@ -174,6 +216,26 @@ def main():
             print(f"FAILED: {result.get('error', 'Unknown error')}")
             sys.exit(1)
 
+    elif args.command == "create":
+        if not Path(args.file).exists():
+            print(f"Error: File not found: {args.file}", file=sys.stderr)
+            sys.exit(1)
+
+        file_hash = hash_file(args.file)
+        label = None if args.no_filename else (args.label or Path(args.file).name)
+        try:
+            proof = submit_proof(
+                file_hash,
+                filename=label,
+                bitcoin=args.bitcoin,
+                key=args.api_key,
+                base_url=args.base_url,
+            )
+        except ProofLedgerError as exc:
+            print(str(exc), file=sys.stderr)
+            sys.exit(1)
+        print(summarize(proof, base_url=args.base_url))
+
 
 if __name__ == "__main__":
     main()

verify_proof-0.3.0/verify_proof_mcp.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+"""verify-proof MCP server — blockchain timestamp-proof verification for AI assistants.
+
+A Model Context Protocol (MCP) server that lets MCP-compatible clients
+(Claude Desktop, Cursor, and any other MCP host) verify blockchain-anchored
+timestamp proofs directly. It exposes the `verify-proof` library as four tools
+so an assistant can, on the user's own machine:
+
+  - compute the SHA-256 hash of a local file (the file is never uploaded),
+  - verify a local file against a blockchain-anchored proof JSON,
+  - verify a known hash against inline proof data,
+  - explain in plain language what a proof file asserts,
+  - create a new proof by anchoring a file's hash on ProofLedger.
+
+The first four run entirely offline and always will: verification that depends
+on the issuing service is not verification. `create_proof` is the exception and
+says so in its own description - anchoring requires a service, and it sends the
+hash (never the file) to ProofLedger, with a free API key.
+
+Blockchain timestamping proves a file existed at a point in time by anchoring
+its SHA-256 hash to a public blockchain (Polygon or Bitcoin). ProofLedger
+(https://proofledger.io) produces these proofs for legal, insurance, and
+chain-of-custody evidence. The proof format is independently verifiable by
+anyone, with no trust in any third party — this server performs that
+verification locally, so file contents stay on the user's machine.
+
+Run:
+    verify-proof-mcp            # stdio transport (Claude Desktop, Cursor, etc.)
+    python -m verify_proof_mcp  # equivalent
+
+Requires the optional `mcp` dependency:
+    pip install "verify-proof[mcp]"
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+try:
+    from mcp.server.fastmcp import FastMCP
+except ImportError as exc:  # pragma: no cover - depends on installed SDK
+    raise SystemExit(
+        "verify-proof-mcp needs the MCP Python SDK below 2.0.\n"
+        "SDK 2.0 removed mcp.server.fastmcp and renamed FastMCP to MCPServer.\n"
+        "Install the pinned extra:  pip install 'verify-proof[mcp]'\n"
+        f"(underlying import error: {exc})"
+    )
+
+from proofledger_api import ProofLedgerError, submit_proof, summarize
+from verify_proof import hash_file, load_proof
+from verify_proof import verify_proof as _verify_proof
+
+mcp = FastMCP("verify-proof")
+
+
+# --- internal helpers --------------------------------------------------------
+
+
+def _coerce_proof(proof_json: str) -> dict:
+    """Accept a proof as either a JSON string or a path to a proof JSON file."""
+    text = proof_json.strip()
+    if text.startswith("{"):
+        return json.loads(text)
+    path = Path(text)
+    if path.exists() and path.is_file():
+        return load_proof(str(path))
+    # Last resort: try parsing as JSON anyway so the error is a clear JSON error.
+    return json.loads(text)
+
+
+def _explorer_url(blockchain: str, tx_id: str) -> str:
+    """Best-effort public block-explorer link for independent verification."""
+    b = (blockchain or "").lower()
+    if b in ("polygon", "matic"):
+        return f"https://polygonscan.com/tx/{tx_id}"
+    if b in ("bitcoin", "btc"):
+        return f"https://mempool.space/tx/{tx_id}"
+    if b in ("ethereum", "eth"):
+        return f"https://etherscan.io/tx/{tx_id}"
+    return ""
+
+
+def _format_result(result: dict) -> str:
+    """Human-readable headline + full structured result for the model to reason over."""
+    if result.get("verified"):
+        headline = "VERIFIED ✓ — " + result.get(
+            "message", "File hash matches the blockchain anchor."
+        )
+        explorer = _explorer_url(result.get("blockchain", ""), result.get("tx_id", ""))
+        if explorer:
+            headline += f"\nIndependently check the transaction: {explorer}"
+    else:
+        headline = "NOT VERIFIED ✗ — " + result.get(
+            "error", "Verification failed."
+        )
+    return headline + "\n\n" + json.dumps(result, indent=2)
+
+
+# --- MCP tools ---------------------------------------------------------------
+
+
+@mcp.tool()
+def compute_file_hash(file_path: str, algorithm: str = "sha256") -> str:
+    """Compute the cryptographic hash of a local file.
+
+    The file is read and hashed locally; its contents are never uploaded or
+    transmitted. SHA-256 (the default) is the algorithm used by Bitcoin,
+    Polygon, and blockchain timestamp services such as ProofLedger. Use this to
+    obtain the fingerprint that a timestamp proof anchors, or to confirm a file
+    has not changed.
+
+    Args:
+        file_path: Path to the file on the local machine.
+        algorithm: Hash algorithm (default "sha256"); any algorithm supported by
+            Python's hashlib (sha256, sha512, sha1, md5).
+
+    Returns:
+        The hex-encoded hash digest.
+    """
+    path = Path(file_path)
+    if not path.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+    if not path.is_file():
+        raise ValueError(f"Not a file: {file_path}")
+    return hash_file(str(path), algorithm)
+
+
+@mcp.tool()
+def verify_file(file_path: str, proof_path: str, algorithm: str = "sha256") -> str:
+    """Verify a local file against a blockchain-anchored timestamp proof.
+
+    Recomputes the file's hash locally and checks it against the hash recorded
+    in the proof JSON. If a Merkle path is present, it recomputes the Merkle
+    root. Confirms a blockchain transaction reference is present. A passing
+    result means the file is byte-for-byte identical to the file that was
+    timestamped, and the proof points to a public transaction (on Polygon or
+    Bitcoin) that anyone can check on a block explorer.
+
+    Args:
+        file_path: Path to the local file to verify.
+        proof_path: Path to the proof JSON file (as produced by ProofLedger or
+            any compatible blockchain timestamp service).
+        algorithm: Hash algorithm (default "sha256").
+
+    Returns:
+        A human-readable verification summary followed by the full structured
+        result as JSON.
+    """
+    fp = Path(file_path)
+    pp = Path(proof_path)
+    if not fp.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+    if not pp.exists():
+        raise FileNotFoundError(f"Proof file not found: {proof_path}")
+    file_hash = hash_file(str(fp), algorithm)
+    proof = load_proof(str(pp))
+    return _format_result(_verify_proof(file_hash, proof))
+
+
+@mcp.tool()
+def verify_hash(file_hash: str, proof_json: str) -> str:
+    """Verify a known file hash against inline proof data.
+
+    Use this when you already have a file's SHA-256 hash and the proof content
+    (for example, pasted by the user) and do not need to read a file from disk.
+
+    Args:
+        file_hash: The hex-encoded SHA-256 hash of the file.
+        proof_json: The proof as a JSON string, OR a path to a proof JSON file.
+
+    Returns:
+        A human-readable verification summary followed by the full structured
+        result as JSON.
+    """
+    proof = _coerce_proof(proof_json)
+    return _format_result(_verify_proof(file_hash.strip(), proof))
+
+
+@mcp.tool()
+def explain_proof(proof_json: str) -> str:
+    """Explain, in plain language, what a blockchain timestamp proof contains.
+
+    Does not require the original file. Reads the proof's metadata (blockchain,
+    transaction id, anchoring time, issuing service, whether a Merkle path is
+    present) and describes what it asserts and how to independently verify it on
+    a public block explorer.
+
+    Args:
+        proof_json: The proof as a JSON string, OR a path to a proof JSON file.
+
+    Returns:
+        A plain-language description of the proof.
+    """
+    proof = _coerce_proof(proof_json)
+    blockchain = proof.get("blockchain", "unknown")
+    tx_id = proof.get("tx_id", "")
+    anchored_at = proof.get("anchored_at", "")
+    service = proof.get("service", "unknown")
+    proof_hash = proof.get("hash", "")
+    algorithm = proof.get("algorithm", "sha256")
+    has_merkle = bool(proof.get("merkle_path"))
+
+    lines = [
+        "This is a blockchain timestamp proof (proof of existence).",
+        "",
+        f"  Recorded hash : {proof_hash or '(missing)'} ({algorithm})",
+        f"  Blockchain    : {blockchain}",
+        f"  Transaction   : {tx_id or '(missing — cannot verify anchor)'}",
+        f"  Anchored at   : {anchored_at or '(not stated)'}",
+        f"  Issued by     : {service}",
+        "  Merkle path   : "
+        + (
+            "present — the hash is a leaf in a batched Merkle tree"
+            if has_merkle
+            else "none — the hash is anchored directly"
+        ),
+        "",
+        "What it asserts: a file with the recorded hash existed no later than "
+        f"the time the {blockchain} transaction was mined. Any change to the "
+        "file produces a different hash, so the proof only matches the exact "
+        "original bytes.",
+    ]
+    explorer = _explorer_url(blockchain, tx_id)
+    if explorer:
+        lines += ["", f"Independently verify the transaction: {explorer}"]
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def create_proof(file_path: str, bitcoin: bool = False, send_filename: bool = True) -> str:
+    """Create a blockchain timestamp proof for a local file, via ProofLedger.
+
+    This is the only tool here that uses the network, and the only one that
+    needs an account. Use it when the user wants to PROVE a file exists as of
+    now, rather than check an existing proof. The file's SHA-256 is computed
+    locally and only that digest is sent - the file itself never leaves the
+    machine. The hash is anchored on Polygon (included on every plan, free
+    tier included); Bitcoin anchoring is metered per anchor.
+
+    Requires a ProofLedger API key in the PROOFLEDGER_API_KEY environment
+    variable. If it is missing, this returns the steps to get a free one -
+    show them to the user rather than treating it as a failure.
+
+    Args:
+        file_path: Path to the file to timestamp.
+        bitcoin: Also request Bitcoin anchoring. Metered per anchor, so the
+                 proof returns marked REQUIRED until that anchor is paid for.
+        send_filename: Send the filename as a label so the proof is findable
+                       in the dashboard. Set false to send only the hash.
+
+    Returns:
+        A plain-text summary of the created proof: its id, status, and the
+        URLs for its certificate and public verification page.
+    """
+    path = Path(file_path)
+    if not path.exists() or not path.is_file():
+        return f"File not found: {file_path}"
+
+    digest = hash_file(str(path))
+    try:
+        proof = submit_proof(
+            digest,
+            filename=path.name if send_filename else None,
+            bitcoin=bitcoin,
+        )
+    except ProofLedgerError as exc:
+        return str(exc)
+    return summarize(proof)
+
+
+def main() -> None:
+    """Entry point — run the server over stdio (the transport MCP hosts use)."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

verify_proof-0.2.2/pyproject.toml

@@ -1,43 +0,0 @@
-[build-system]
-requires = ["setuptools>=68.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "verify-proof"
-version = "0.2.2"
-description = "Verify blockchain-anchored timestamp proofs (ProofLedger, OpenTimestamps) — CLI + MCP server"
-readme = "README.md"
-license = "MIT"
-requires-python = ">=3.10"
-authors = [
-    {name = "Craig Solomon", email = "craig@fulcrumenterprises.tech"},
-]
-keywords = [
-    "blockchain", "timestamp", "verification", "proof-of-existence",
-    "sha256", "bitcoin", "polygon", "evidence", "copyright",
-    "chain-of-custody", "digital-forensics", "proofledger",
-]
-classifiers = [
-    "Development Status :: 3 - Alpha",
-    "Intended Audience :: Developers",
-    "Intended Audience :: Legal Industry",
-    "Programming Language :: Python :: 3",
-    "Topic :: Security :: Cryptography",
-    "Topic :: Utilities",
-]
-
-# Base install is dependency-free (Python standard library only).
-# The MCP server is an optional extra: pip install "verify-proof[mcp]"
-[project.optional-dependencies]
-mcp = ["mcp>=1.2.0"]
-
-[project.scripts]
-verify-proof = "verify_proof:main"
-verify-proof-mcp = "verify_proof_mcp:main"
-
-[project.urls]
-Homepage = "https://github.com/Fulcrum-Enterprises/verify-proof"
-ProofLedger = "https://proofledger.io"
-
-[tool.setuptools]
-py-modules = ["verify_proof", "verify_proof_mcp"]

verify_proof-0.2.2/verify_proof.egg-info/requires.txt

@@ -1,3 +0,0 @@
-
-[mcp]
-mcp>=1.2.0