VeritasChain Cryptographic Proof of Reality

// the problem with reality

Deepfakes exist. Screenshots get edited. News articles are quietly updated after the fact. Documents vanish. Videos are taken out of context and re-uploaded with different metadata.

The problem isn't that people lie. The problem is that there's no infrastructure to prove the truth.

Every platform that claims to "verify" content is centralized. They can be pressured, hacked, acquired, or simply shut down. The verification lives inside their database and databases can be edited.

VeritasChain is my answer to that. Not a platform. Not a service. A protocol.

// what it does

VeritasChain lets you prove that a file a photo, a video, a document, a dataset existed at a specific moment in time, uploaded by a specific wallet, without trusting any centralized authority.

The proof lives on the Ethereum blockchain.

It cannot be altered. It cannot be deleted. It cannot be disputed.

No company controls it. No moderator can remove it. No government can quietly make it disappear.

// how it actually works

The architecture is deliberately simple. Simple is harder to attack.

  You                  VeritasChain              Ethereum
   │                        │                       │
   │── upload file ────────▶│                       │
   │                        │── hash (SHA-256)       │
   │                        │── pin to IPFS          │
   │                        │── send tx ────────────▶│
   │                        │            store hash + wallet + timestamp
   │◀── IPFS hash + tx ─────│                       │
   │                        │                       │
   │── verify(hash) ────────│── query contract ─────▶│
   │◀── AUTHENTIC ──────────│◀── on-chain record ────│

Four steps. That's it.

1. Your file is hashed locally using SHA-256. Nothing leaves your device unencrypted. VeritasChain never sees the raw file.

2. The file is pinned to IPFS. A content-addressed, decentralized storage network. You get a CID (Content Identifier) that is mathematically derived from the file's content. If even one byte changes, the CID changes.

3. That hash is anchored on-chain via a Solidity smart contract. Immutable. Timestamped. Tied to your wallet address.

4. You receive a certificate. An IPFS hash + transaction ID. Share it with anyone. They can verify it independently without asking you, without trusting you, without trusting me.

// the key insight

The file is never stored by VeritasChain.

Only the fingerprint is stored on-chain. This matters for two reasons.

First, sensitive documents can be stamped without exposing their contents to anyone. The hash proves existence without revealing the data.

Second, there is no honeypot. No central database of uploaded files to hack, subpoena, or shut down.

Your wallet is your identity. No sign-ups. No email. No password. MetaMask signs the transaction and that is the chain of custody.

// the tech stack

The smart contract (UserFileStorage.sol) is the only piece that matters for trust. Everything else the frontend, the backend, the API is just interface. You could write your own client and interact with the contract directly.

That's by design.

// running it yourself

You shouldn't have to trust my deployment. Run it locally.

Prerequisites: Node 18+, Python 3.10+, MetaMask, Ganache

Deploy the contract

cd contracts && npm install
npx truffle migrate --network development

Start the backend

cd backend && python -m venv venv && source venv/bin/activate
pip install -r requirements.txt
uvicorn app.main:app --reload

Start the frontend

cd frontend && npm install && npm start

Or just:

./start_all.sh

Full README and env setup at: github.com/AnonymousCoderDev/VeritasChain

// why anonymous

VeritasChain was built without a name attached to it.

No VC funding. No team page. No LinkedIn announcement. No "we're excited to share" Twitter thread.

The reason is embedded in the philosophy of the project itself if you're building a tool for verifying truth independent of authority, it shouldn't matter who built it.

Judge the code. Not the coder.

"In a world where reality is manufactured, the only currency worth having is verifiable truth."

MIT licensed. Fork it. Improve it. Deploy your own instance. Knowledge should be free, and so should the tools to verify it.

// end of transmission //