Midnight Private Certificate Verifier

A privacy-preserving academic certificate verifier built on Midnight, using zero-knowledge proofs to verify degree eligibility without revealing the degree itself.

Comment

Inspiration

The idea came from hearing and seeing people around me deal with academic certificate verification. In Bangladesh, getting certificates issued and then proving they are authentic can take time. There can also be a lot of unnecessary authentication, document sharing, and back-and-forth between institutions and organizations.

I started thinking about whether blockchain and zero-knowledge proofs could make this process simpler. Instead of sending your academic information to every platform that needs to verify it, you could prove that you meet a requirement without actually revealing the information itself.

This is a small prototype for now, but I see it as something that could become much bigger. I hope that, as these technologies mature, academic institutions could eventually use on-chain systems for certificate issuance and verification in a way that is simpler, more private, and easier to trust.

I built this project during the Midnight Hackathon using Midnight's privacy-focused smart contract platform.

What it does

Midnight Private Certificate Verifier is a small privacy-focused academic credential verification system.

The flow is:

Issue → Verify → Result → Issue

An issuer sets an accepted degree on the contract. A verifier then provides a degree as a private witness, and the Compact circuit checks whether it matches the issuer-approved degree:

$$ \texttt{verified = disclose(degree == acceptedDegree)} $$

The important part is that the verification result is revealed, not the degree itself.

There is also a limitation in this prototype: the certificate ID and holder name are not currently cryptographically bound to the private degree witness. I have documented this clearly rather than making the system sound more complete than it actually is.

How I built it

I built the project using:

  • Midnight Network for the privacy-focused smart contract layer
  • Compact for the smart contract and zero-knowledge circuit
  • Midnight.js for interacting with the contract
  • Node.js / TypeScript for the API server and deployment tooling
  • HTML/JavaScript for the frontend
  • Docker for the local development environment
  • Midnight Preview network for the public demonstration

The issuer configuration and verification state are handled through the contract, while the degree used for verification is supplied as private witness data.

I also kept the local and public-network setups separate so I could develop locally and still have a path toward demonstrating it on Midnight's Preview network.

Challenges I ran into

The hardest part was understanding how private witness data, public ledger state, and the Compact circuit actually fit together.

It is easy to say that something is "private" when talking about zero-knowledge proofs, but the actual circuit determines what is really being proven and what is disclosed. I had to pay close attention to that distinction while building the verification flow.

I also ran into quite a few issues with the Midnight tooling, especially around the Compact compiler, versions, wallet setup, network configuration, proof server, deployment, and synchronization.

Getting all these pieces working together took a lot of debugging. Some of the frontend and backend integration issues were also pretty painful near the end of the hackathon.

Another challenge was keeping the frontend simple enough for someone seeing the project for the first time while still being honest about what the prototype actually proves.

Accomplishments that I'm proud of

I'm proud that I managed to turn the idea into a working end-to-end prototype during the hackathon.

The project has a complete Issue → Verify → Result workflow, a working Compact circuit, Midnight integration, a TypeScript API layer, Docker-based infrastructure, and a frontend that ties everything together.

I'm also particularly happy that I documented the current limitations instead of hiding them. The certificate ID and holder name are not cryptographically bound to the degree in this version, and I think being clear about that is important when talking about privacy and zero-knowledge systems.

Most importantly, I built the whole thing myself and got it working on the Midnight network under the hackathon deadline.

What I learned

This project gave me a much better understanding of how zero-knowledge applications actually work beyond the simple idea of "hiding data."

I learned how private witnesses, public ledger state, circuit logic, transactions, wallets, proof infrastructure, and application APIs all connect together.

The biggest lesson for me was that privacy claims have to follow the circuit. Just because an application uses zero-knowledge proofs does not automatically mean everything about the data is private or cryptographically bound. Understanding that difference was probably the most valuable thing I took away from the project.

What's next for Midnight Private Certificate Verifier

This is only a starting point for me.

The next step would be to build a stronger credential model where the certificate ID and holder information are also cryptographically tied to the credential. I would also like to add stronger issuance and ownership mechanisms and support richer claims without exposing unnecessary personal information.

I'd like to eventually deploy the application more fully on Midnight's public environment and make the verification experience more practical.

Beyond academic degrees, I think the same idea could work for professional certificates, licenses, memberships, and other situations where someone needs to prove something about themselves without handing over all of their personal information.

For now, the project is a small demonstration of an idea I find really interesting: prove what needs to be verified, and reveal as little as possible.

Built With

Share this project:

Updates

Submission history