Zero-Knowledge Proofs: Part 1

In this article, we’re starting a journey into the world of zero-knowledge proofs (ZKPs)—one of the most exciting and powerful cryptographic tools in shaping the Sound Internet. As this is the bockbone of Soundness labs, our goal is to make these concepts approachable for all Soundies, especially those who are interested in building cool, efficient, and privacy-preserving dApps, even if they have no deep background in cryptography.

So let’s kick things off with a gentle introduction using something we all know and love: Where’s Waldo?

What Is a Zero-Knowledge Proof?

A zero-knowledge proof is a method by which one party (called the prover) can prove to another party (the verifier) that a statement is true—without revealing any information beyond the truth of the statement itself.

Hint #1: zk in zkLogin, developed by Sui (@SuiNetwork) stands for zero-knowledge.

This seemingly magical property is what makes ZKPs so powerful for privacy, fairness, and security. They underpin anonymous identity systems, confidential transactions, private voting, and even advanced scalability systems on blockchains like zkRollups.

The Three Pillars of ZKPs

Every zero-knowledge proof is built on three foundational properties:

1. Completeness: If the statement is true, an honest verifier will be convinced by an honest prover.

   Soundness: If the statement is false, no cheating prover can convince the verifier otherwise. (This is where our company name, Soundness Labs, comes from! 🐬)

   Zero-Knowledge: The verifier learns nothing beyond the truth of the statement—no secret leaks, no extra hints.

These principles create a strong framework for trust without exposure.

Let’s Talk About Waldo

To bring these ideas to life, let’s walk through a simple and relatable scenario.

Imagine you’re staring at a huge “Where’s Waldo?” picture. It’s busy, chaotic, and you've been hunting for Waldo for hours. Frustrated, you offer a reward to anyone who can show you where Waldo is. 😩

But now there’s a problem.

You don’t want to pay someone unless you’re sure they found Waldo. 🤦🏻‍♂️

They don’t want to show you where he is without getting paid first. 🤦‍♀️

It’s a classic fairness issue—one that happens all the time in real life and on the internet.

The ZK Way to Solve It

Here’s how a zero-knowledge proof helps.

The person who found Waldo (the prover) creates a cropped image showing just Waldo from the original scene. This cropped version doesn’t reveal anything about where Waldo was in the overall image—just that the prover found him.

But now another problem arises: how do you know that this cropped Waldo actually came from the original image and not some different one? 🤔

Cryptographic Commitments to the Rescue

To fix this, we introduce a concept called a commitment. Think of it like a sealed envelope that contains the original image. The prover seals the image inside and shares the sealed envelope (i.e., the cryptographic commitment) with the verifier.

This commitment has two magical properties:

• Binding: Once the prover commits to an image, they can’t change it later.

  Hiding: The verifier can’t see what’s inside until the prover reveals it.

Now, when the prover sends over the cropped Waldo snippet, the verifier can check that it really matches the image they originally committed to.

Avoiding Extra Clues

Even with a cropped image, there’s still a risk: maybe the small portion of the image still gives some clues about where Waldo is.

To solve this, the prover overlays the original Waldo image onto a much larger blank canvas and positions it randomly. Then they crop out the Waldo section. This randomness ensures that the cropped area doesn’t reveal anything about the actual position of Waldo in the original image.

This extra step is what gives the proof its zero-knowledge nature.

What Happens Next?

Once the proof is generated, the prover can request the reward. But in Web2, this still requires trust: the verifier might not pay up.

That’s where Web3 changes the game.

In blockchain systems, the prover can submit their ZK proof to a smart contract. If the proof is valid, the contract automatically sends the payment—no trust required. It’s a completely fair system, thanks to ZKPs and decentralized execution.

The best part? Many blockchains today are capable of verifying ZK proofs on-chain, meaning the process can be efficient, secure, and automatic, but those are pretty expensive. But the format of the proof is totally different from a canvas!

This Waldo example is fun and intuitive, but the implications of zero-knowledge proofs go far beyond puzzles. This is what we wanna go deeper in this series.

What’s Next?

This was the first article in our Zero-Knowledge Proofs series. In the next part, we’ll move beyond examples and start showing how you can actually build your own zkApp and then settle them on-chain using tools like our Soundness Layer—an infrastructure product designed to make zk development cheaper and easier.

Whether you’re a Web3 builder, a curious dev, or just someone who loves fair systems, you won’t want to miss what’s coming next.

Thanks for reading. Follow along for more articles where we go deeper into building real-world zk systems, explain how our tooling works, and share our vision for a Sound Internet. 🐬

If you’ve got questions or want to explore more, feel free to reach out on our Discord channel.

Useful resources:

https://soundness.xyz/blog/sp1sui

https://soundness.xyz/blog/soundness-layer

The source for Waldo example: https://www.youtube.com/watch?v=fOGdb1CTu5c