VeritasChain Standards Organization (VSO)

Posted on Jan 2

Introducing VCC Demo: A Browser-Based Cryptographic Audit Trail You Can Try Right Now

#javascript #react #blockchain #fintech

TL;DR: We built a complete cryptographic verification system that runs entirely in your browser. Try it now at veritaschain.org/vcc/demo—no signup required.

Why We Built This

In 2024-2025, the proprietary trading industry witnessed an unprecedented collapse. Over 80 prop firms shut down, many amid accusations of manipulated evaluations and unverifiable trade execution. Traders had no way to independently verify that their trades were handled fairly.

The core problem? Trust-based audit systems controlled by the entity being audited.

The VeritasChain Protocol (VCP) offers a different approach: cryptographic proof over trust. Instead of asking "Do I trust this platform?", VCP enables anyone to ask "Can I mathematically verify this hasn't been tampered with?"

Today, we're releasing VCC Demo—a fully functional, browser-based implementation that lets you experience this firsthand.

Try It Now

🔗 veritaschain.org/vcc/demo

No installation. No signup. No server. Everything runs in your browser.

What You Can Do

1. Create Trading Events

Simulate a complete trade lifecycle:

SIG → ORD → ACK → EXE → CLS
(Signal → Order → Acknowledged → Executed → Closed)

Each event gets a cryptographic hash computed using SHA-256:

2. Build Merkle Trees

Click "Create Merkle Anchor" to batch your events into an RFC 6962-compliant Merkle tree:

                    [Root]
                      │
           ┌──────────┴──────────┐
           │                     │
        [Node]                [Node]
           │                     │
      ┌────┴────┐          ┌─────┴─────┐
      │         │          │           │
   [Leaf]    [Leaf]     [Leaf]      [Leaf]

The Merkle root is a single hash that commits to ALL events in the batch. Change any single bit of any event, and the root changes completely.

3. Verify Independently

This is the "Verify, Don't Trust" moment. Select any anchored event and verify its inclusion:

{
  "valid": true,
  "certificate": {
    "event_hash": "91648f1e8ea266a9...",
    "merkle_root": "38a3d9ce3372bd5f...",
    "merkle_proof": [
      {"hash": "abc123...", "position": "right"},
      {"hash": "def456...", "position": "left"}
    ],
    "verification_method": "RFC6962_MERKLE"
  }
}

The verification runs entirely in your browser. You don't need to trust our server—because there is no server.

Under the Hood

Technology Stack

Component	Technology
Cryptography	Web Crypto API (native)
Merkle Tree	RFC 6962 with domain separation
Identifiers	UUID v7 (time-ordered)
Storage	IndexedDB (browser-local)
UI	React 18 + Tailwind CSS
Hosting	GitHub Pages (static)

VCP v1.1 Compliance

VCC Demo implements the three-layer integrity architecture defined in VCP v1.1:

Layer	Component	Implementation
Layer 1	Event Hash	SHA-256 via Web Crypto
Layer 2	Merkle Tree	RFC 6962 compliant
Layer 3	External Anchor	Simulated (demo)

The Code

Everything fits in a single 42KB HTML file. Here's the core Merkle verification:

const verifyMerkleProof = async (eventHash, merkleRoot, auditPath, leafIndex) => {
    // Start with leaf hash (0x00 prefix per RFC 6962)
    let currentHash = await merkleHashLeaf(eventHash);

    // Walk up the tree
    for (const step of auditPath) {
        if (step.position === 'left') {
            currentHash = await merkleHashNode(step.hash, currentHash);
        } else {
            currentHash = await merkleHashNode(currentHash, step.hash);
        }
    }

    // If we arrive at the same root, proof is valid
    return currentHash === merkleRoot;
};

The domain separation (0x00 for leaves, 0x01 for internal nodes) prevents second-preimage attacks—a subtle but critical security detail.

What This Demo Proves (And Doesn't)

✅ What It Proves

Merkle integrity works: Any modification is instantly detectable
Proofs are efficient: O(log n) data to verify any event
Client-side verification is possible: No server trust required
RFC 6962 is implementable: Certificate Transparency techniques apply to trading

❌ What It Doesn't Prove (Yet)

Timestamp authority: Browser clock isn't authoritative
External anchoring: The "anchor" is local, not on a blockchain
Digital signatures: No private keys in this demo

For production systems, you'd add OpenTimestamps or blockchain anchoring, HSM-backed Ed25519 signatures, and proper key management.

Use Cases

For Traders

Understand how cryptographic audit trails work before demanding them from your broker.

For Prop Firms

Evaluate VCP integration without any commitment. See exactly what data structures look like.

For Developers

Fork the code, study the implementation, build your own verification tools.

For Auditors

Understand the mathematical guarantees that Merkle proofs provide.

The Bigger Picture

VCC Demo is part of the VeritasChain ecosystem:

Component	Purpose
VCP	The protocol specification
VCC	Cloud logging service (production)
VCC Demo	Browser-based reference implementation
VCP Explorer	Third-party verification UI

The demo runs entirely client-side, but production VCC provides:

Real external anchoring (OpenTimestamps, blockchain)
Ed25519 digital signatures with HSM
Multi-tenant API with authentication
PostgreSQL storage with replication

Try It Yourself