ProofLedger

• 

• 

Inspiration

Digital documents are increasingly used as proof of identity, ownership, agreements, research, and business activity. But once a file is shared, it becomes difficult to prove that the version being viewed today is exactly the version that existed when it was created.

We were inspired by a simple question:

Can we prove the integrity of a digital file without having to trust the person, company, or server claiming that it is authentic?

That led us to ProofLedger.

Instead of uploading sensitive documents to a centralized system, we wanted to create a system where the file stays with the user while its cryptographic proof can be independently verified.

The idea was to combine cryptographic hashing with blockchain to create a practical, privacy-conscious digital proof system.

What it does

ProofLedger creates and verifies tamper-evident proofs for digital files.

When a user selects a file, ProofLedger generates its unique SHA-256 cryptographic hash. This hash acts like a digital fingerprint of the file.

The proof is then anchored to the blockchain.

Later, the user can verify the file by hashing it again and comparing the result with the previously anchored proof.

• Same hash → the file has not changed.
• Different hash → the file has been modified.

The original document does not need to be stored on the blockchain. This means ProofLedger can provide verifiable integrity while minimizing the amount of sensitive information that needs to leave the user's device.

The result is a simple workflow for creating timestamped, tamper-evident, independently verifiable digital proof.

How we built it

We built ProofLedger around three core layers:

1. Cryptographic layer

The selected file is processed using SHA-256 to generate a deterministic cryptographic fingerprint.

[ Hash = SHA256(File) ]

Because cryptographic hashes are highly sensitive to changes, even a small modification to the file produces a different fingerprint.

2. Blockchain layer

Instead of putting the actual document on-chain, we anchor the cryptographic proof and relevant metadata.

This gives the proof an immutable, publicly verifiable reference without exposing the underlying document.

3. Application layer

We built a web interface that connects these components into a simple user experience:

Upload → Hash → Anchor → Verify

The interface abstracts away most of the underlying blockchain complexity while still making the verification result and proof information accessible to the user.

The application is deployed as a live web application so the complete proof lifecycle can be demonstrated directly.

Challenges we ran into

Designing the right blockchain architecture

One of our biggest challenges was deciding what should actually go on-chain.

Putting complete files on a blockchain would be inefficient, expensive, and could create privacy concerns. We therefore designed the system around proof rather than storage — keeping the original file separate from the blockchain record.

Making cryptography understandable

A SHA-256 hash is meaningful to a developer but not necessarily to a normal user.

We had to turn an abstract cryptographic concept into a simple interaction where users could understand the result without needing to know how hashing works internally.

Building an end-to-end workflow

The challenge wasn't just generating a hash. We needed to connect file processing, proof creation, blockchain interaction, persistence, and verification into one reliable flow.

Getting the complete lifecycle working from file → proof → blockchain → verification was an important part of the implementation.

Balancing decentralization with usability

Blockchain applications can easily become complicated because of wallets, transactions, network details, and technical terminology.

We focused on hiding unnecessary complexity and making the core purpose of the application — proving file integrity — immediately understandable.

Accomplishments that we're proud of

We are proud that we turned a relatively complex combination of cryptography and blockchain into a simple, usable workflow.

The biggest accomplishment is the complete proof lifecycle:

Create a cryptographic fingerprint → anchor the proof → retrieve the proof → verify the original file.

We are also particularly proud of the privacy-oriented architecture. ProofLedger does not need to put the original document itself on-chain just to establish its integrity.

Most importantly, we built something that goes beyond demonstrating a blockchain transaction. The blockchain has a specific purpose in the architecture: providing a verifiable trust anchor for digital integrity.

What we learned

We learned that blockchain is often most useful when it stores the minimum information necessary to establish trust, rather than trying to store everything.

Building ProofLedger also gave us a deeper understanding of how cryptographic hashing and immutable records complement each other.

A hash can tell us whether a file changed, while an immutable record can establish what proof was recorded and when.

We also learned that technical security is only part of the challenge. A good verification system needs to make complex concepts understandable to users without weakening the underlying security model.

What's next for ProofLedger

ProofLedger is currently focused on establishing the core digital-proof infrastructure. The next step is turning that foundation into a broader verification platform.

We envision:

• Public verification links for sharing proofs without sharing the original file
• Verifiable certificates and credentials
• Legal and business document verification
• Academic and research integrity verification
• Digital evidence verification
• API access for applications that need document notarization
• Batch proof generation for organizations handling large numbers of documents
• Enterprise audit trails
• Multi-chain anchoring for additional resilience and verification options
• Proof lifecycle management, including revocation and updated versions

Our ultimate goal is simple:

Make digital integrity as easy to verify as checking a fingerprint — without requiring users to blindly trust the system that created the proof.

Built With

• blockchain
• ether
• javascript
• metamask
• react
• sha-256
• web3