INTEGRITY BEACON

Cryptographic Verification for Institutional-Grade Data

GTIXT publishes immutable snapshots with cryptographic hashes. Every data release is verifiable, deterministic, and auditable. Anyone can independently verify that the published data matches the official pointer—ensuring integrity at every layer.

Latest Snapshot Pointer

Real-time reference to the most recent published snapshot. Verify authenticity by comparing the expected SHA-256 hash with the computed hash of the downloaded file.

Snapshot Object

Loading…

Expected SHA-256

Loading…

Published in latest.json

Timestamp

—

Records

—

📥 Download Snapshot

Verification Result

Click "Verify Latest Snapshot" to begin

How Verification Works

GTIXT employs a cryptographic chain to ensure data integrity from source to publication.

Pointer Published

GTIXT publishes latest.json containing the snapshot object path and expected SHA-256 hash.

Snapshot Downloaded

Users download the snapshot file from the public MinIO bucket using the object path from the pointer.

Hash Computed

Compute the SHA-256 hash of the downloaded file locally using sha256sum or browser crypto.

Verification Complete

Compare the computed hash with the expected hash. A match confirms the snapshot is authentic and unaltered.

Why This Matters

Cryptographic verification is the foundation of institutional trust in financial data infrastructure.

🔒

Integrity

SHA-256 hashes ensure that data has not been altered, corrupted, or tampered with at any point in the distribution chain.

👁️

Transparency

Anyone can independently verify data authenticity. No proprietary tools required—just standard cryptographic utilities.

📊

Auditability

Every snapshot is immutable and traceable. Regulators, auditors, and institutions can verify historical data integrity.

🏛️

Institutional Trust

Cryptographic verification meets institutional standards for data integrity, regulatory compliance, and fiduciary responsibility.

Manual Verification

Verify snapshots independently using standard command-line tools. No custom software required.

Step 1: Download Latest Pointer

curl /snapshots/universe_v0.1_public/_public/latest.json -o latest.json

Step 2: Extract Snapshot Path

cat latest.json | jq -r '.object'

Step 3: Download Snapshot

curl /snapshots/$(cat latest.json | jq -r '.object') -o snapshot.json

Step 4: Compute SHA-256

sha256sum snapshot.json

Step 5: Compare Hashes

cat latest.json | jq -r '.sha256'

The output from Step 4 should match the hash from Step 5 exactly.

API Verification

Automate verification in your applications using standard HTTP requests and crypto libraries.

Endpoint: Latest Pointer

GET

/snapshots/universe_v0.1_public/_public/latest.json

Returns the latest snapshot metadata including object path, SHA-256 hash, timestamp, and record count.

Example: Python

import hashlib, requests

# Download pointer
r = requests.get("/snapshots/universe_v0.1_public/_public/latest.json")
pointer = r.json()

# Download snapshot
snapshot_url = "/snapshots/" + pointer["object"]
snapshot = requests.get(snapshot_url).content

# Compute hash
computed = hashlib.sha256(snapshot).hexdigest()
expected = pointer["sha256"]

# Verify
assert computed == expected, "Hash mismatch!"

Example: JavaScript

async function verify() {
  // Fetch pointer
  const r = await fetch("/snapshots/universe_v0.1_public/_public/latest.json");
  const pointer = await r.json();
  
  // Fetch snapshot
  const url = "/snapshots/" + pointer.object;
  const snapshot = await fetch(url);
  const buf = await snapshot.arrayBuffer();
  
  // Compute SHA-256
  const digest = await crypto.subtle.digest("SHA-256", buf);
  const computed = Array.from(new Uint8Array(digest))
    .map(b => b.toString(16).padStart(2, "0")).join("");
  
  // Verify
  return computed === pointer.sha256;
}

🔐 Institutional Cryptographic Features (v1.1)

Released February 24, 2026 — Advanced verification with ECDSA signatures and multi-level hashing

⛓️

Multi-Level Hashing

SHA-256 cryptographic hashing at 5 levels: evidence snapshots, per-firm aggregates, pillar-level rollups, complete dataset, and ECDSA-secp256k1 signatures. Creates complete provenance chain for institutional audit trails.

✍️

ECDSA-secp256k1 Verification

Non-repudiation guarantee using ECDSA-secp256k1 elliptic curve cryptography. Detects any tampering with published snapshots. Signer identity and timestamp embedded in signature. Institutional-grade cryptographic standard.

🔗

Provenance Endpoints

Four institutional endpoints: /api/provenance/trace (complete hash chain), /api/provenance/graph (firm history), /api/provenance/evidence (with proofs), and /api/provenance/verify (ECDSA validation). Full data lineage transparency.

🏛️

Institutional Compliance

Supports SOC 2, ISO 27001, and regulatory reporting requirements. Non-repudiation for regulatory submissions. Multi-level audit trails for compliance frameworks. Complete transformation chain traceable.

Verify ECDSA Signatures via API

POST to /api/provenance/verify with snapshot details

curl -X POST http://localhost:3000/api/provenance/verify \
  -H "Content-Type: application/json" \
  -d '{
  "type": "dataset",
  "snapshot_uuid": "2ec9923b-0cc5-48a4-bb68-a25c4d0be361"
}'

Evidence Verification

Each snapshot entry includes evidence excerpts and URIs for source-level traceability.

Evidence Excerpts

Every entity in the snapshot includes a machine-readable excerpt from its official source document—enabling programmatic verification without manual lookup.

Evidence URIs

Each entry links to its authoritative source (OFAC PDF, EU regulation, UN document). Auditors can verify that extracted data matches the official publication.

Cryptographic Chain

Source → Excerpt → Snapshot → SHA-256 → Pointer. This chain ensures that every data point can be traced back to its regulatory origin.