BR Academy

Zero-Knowledge Proofs for Builders: Circuits, Rollups and Privacy

Master zero-knowledge proofs: build circuits, deploy rollups, and architect privacy systems. From SNARKs to production.

Intermediate33 lessons9.1 hoursCertificate

About this course

Zero-knowledge proofs are reshaping blockchain. They power Ethereum’s rollups, enable privacy-preserving identity, and unlock scalability. But they’re hard to learn—most resources are academic or scattered.

This course teaches ZK from first principles to production code. You will understand what a proof actually attests, why the witness stays hidden, and how a verifier can be a contract on a public chain. You will compare SNARKs and STARKs on proof size, setup, assumptions, and verifier cost, then choose a stack with a table instead of a slogan.

You will write circuits in Circom and Noir. The labs take you through a Merkle membership proof, a range proof, and a thin integration of a Circom proof into a Solidity wrapper, with tests for a valid proof and a rejected one. You will learn how proofs are generated from a witness and a proving key, what a trusted setup and a ceremony actually risk, and how to pin verifying keys honestly, including when parameters are only for development.

The rollup modules explain the difference between optimistic and validity designs, the roles of sequencer, prover, and settlement contract, and the data-availability choice that a proof does not automatically solve. You will read official case studies of Starknet, Polygon zkEVM, and Scroll as dated documentation, then design a small transfer-only validity rollup on paper with a public-input table and a liveness story.

The privacy and identity modules name anonymity, unlinkability, and a careful disclosure story. You will study shielded-transfer and membership-vote mechanisms as teaching tools, with play funds and lawful use only, and you will prove attributes without revealing a whole credential. The final module covers proving time, verification gas, common circuit bugs such as unconstrained values, and a checklist you will apply to your own capstone.

Every lesson includes a worked example and an exercise. The capstone is to design, build, and audit one narrow ZK application—such as an anonymous vote, a toy shielded transfer, or an attribute proof—with circuit code, a verifier or test harness, measurements, and a short audit. Pass the module quizzes and meet the capstone rubric on correctness, security, and clarity to earn the certificate.

Who this is for: blockchain engineers and protocol developers with 1–2 years of Solidity or Rust experience who know hashing and signatures and want to build and review ZK systems.

What you will leave with: 7 modules, 33 lessons, labs in Circom and Noir, quizzes, and a portfolio capstone. Questions? Contact us at https://blockrelations.com/contact/

What you will be able to do

Can explain what a zero-knowledge proof proves and verify, and why ZK is not encryption or obfuscation
Can compare SNARKs and STARKs on proof size, verification cost, trusted setup, and scalability tradeoffs
Can write and test a simple arithmetic circuit in Circom or Noir
Can integrate a proving system (Circom + snarkjs, or Noir + Aztec) into a Solidity contract
Can design a ZK rollup architecture and explain how validity proofs replace fraud proofs
Can implement a privacy application (anonymous voting, shielded transfer, or identity proof) using ZK
Can audit ZK code for common circuit bugs (unconstrained inputs, under-constrained outputs, witness leakage)
Can estimate proving time, proof size, and gas cost for a ZK application and optimize for production

Curriculum 7 modules · 33 lessons

1What Zero-Knowledge Proofs Are4 lessons

What is a Zero-Knowledge Proof? Preview8 min
ZK vs. Encryption, Hashing, and Digital Signatures 10 min
The Anatomy of a ZK Proof: Prover, Verifier, and the Statement 12 min
Interactive vs. Non-Interactive Proofs 9 min

2SNARKs and STARKs in Plain Terms4 lessons

What is a SNARK? Proof Size, Verification, and Trusted Setup 11 min
What is a STARK? Transparency, Scalability, and Quantum Resistance 11 min
SNARK vs. STARK: When to Use Each 10 min
Groth16, Plonk, Halo2, and Cairo—A Landscape 12 min

3Writing Circuits5 lessons

Setting Up Circom and Writing Your First Circuit 13 min
Constraints, Signals, and Templates in Circom 14 min
Lab: Write a Merkle Tree Membership Proof Circuit 25 min
Introduction to Noir: Circuits in Rust-Like Syntax 12 min
Lab: Write a Range Proof in Noir 25 min

4Proving Systems and Trusted Setups5 lessons

How Proofs Are Generated: Witness, Constraint System, and Proving Key 13 min
Trusted Setups: Why They Matter and How They Work 12 min
Participating in a Trusted Setup Ceremony 10 min
How Proofs Are Verified On-Chain 11 min
Lab: Integrate a Circom Proof into a Solidity Contract 30 min

5ZK Rollups and Validity Proofs5 lessons

Rollup Fundamentals: Optimistic vs. Validity Proofs 12 min
ZK Rollup Architecture: Sequencer, Prover, and Settlement 13 min
The Validity Proof Flow: Batching, Proving, and Verification 11 min
StarkNet, Polygon zkEVM, and Scroll: Case Studies 12 min
Lab: Design a ZK Rollup for a Simple Token Transfer System 30 min

6Privacy Applications and Identity5 lessons

Privacy in Blockchain: Anonymity, Unlinkability, and Deniability 11 min
Shielded Transfers: How Tornado Cash and Zcash Work 12 min
Anonymous Voting: Proof of Membership Without Revealing Identity 11 min
ZK Identity: Proving Attributes Without Revealing Data 12 min
Lab: Build an Anonymous Voting Contract with ZK Proofs 35 min

7Performance, Cost, and Auditing5 lessons

Proving Time, Proof Size, and Optimization Strategies 12 min
On-Chain Verification Gas Costs and Optimization 11 min
Common Circuit Bugs: Unconstrained Inputs, Witness Leakage, and Soundness Holes 13 min
ZK Code Audit Checklist: What to Look For 11 min
Capstone: Design, Build, and Audit a ZK Application 90 min

Taught by Block Relations

Research & Education · Built for blockchain engineers and protocol developers with 1–2 years of Solidity or Rust experience, comfortable with cryptographic concepts such as hashing and signatures, but new to zero-knowledge proofs. You need to understand ZK deeply enough to choose between proving systems, write simple circuits, and integrate ZK rollups or privacy features into production.