ZK Developer

Quiz 14

Questions: 20

Zero Knowledge (ZK) Developer Noir Programming And ZK Circuits
1. Intro To Noir
A pivotal first step to Your First Zero-Knowledge Project: A Noir Journey - Construct your initial ZK application from the ground up, experiencing the full development lifecycle from circuit creation to final proof verification. This lesson also introduces Noir, its key principles like ACIR, and guides you through installing the Nargo CLI and Barretenberg backend. Duration: 6min
2. Noir Architecture
A clarifying breakdown of Understanding the Noir Architecture: From Circuit to Proof - Trace the path from Noir circuit creation to proof generation, detailing Nargo's compilation to ACIR and witness output. Uncover how Barretenberg produces ZK proofs and enables their verification, both off-chain and through on-chain smart contracts. Duration: 5min
3. ZK Protocol Architecture
A structural breakdown of Understanding Zero-Knowledge Protocol Architecture for On-Chain Applications - Explore the critical division between off-chain components (circuits, front-ends) for efficient ZK proof generation, and on-chain smart contracts (Verifier, App) for trustless proof verification and application logic. This lesson illuminates the complete workflow, showing how user inputs lead to secure, verified actions on the blockchain. Duration: 6min
4. Nargo And Barretenberg Installation
A foundational primer to Your First Steps with Noir: Environment Setup - This lesson details installing Nargo (Noir's CLI), Barretenberg (proving backend), and the `jq` utility. Set up your essential toolkit to begin developing zero-knowledge applications using Noir. Duration: 5min
5. Creating A Noir Project
An essential walkthrough to Getting Started: Creating Your First Noir Project with Nargo - Learn to initiate your first Noir project using `nargo new`, understanding the command-line operations for project creation. This lesson clarifies the difference between `nargo new` and `nargo init`, and explores the default `src` directory and `Nargo.toml` manifest file. Duration: 1min
6. Noir Project Types And Layout
A practical introduction to Noir Project Types and Layout - Master the layout of Noir projects by dissecting the `Nargo.toml` config file and the `src` directory, home to your `main.nr` circuit entry point. Distinguish between key Noir crate types (`bin`, `lib`, `contract`) and grasp how they influence compilation and project functionality. Duration: 5min
7. Quiz 7 Quiz
Questions: 17
8. Noir Data Types
A strategic guide to Understanding Circuit Inputs in Noir - Learn to define circuit interactions in Noir by distinguishing private inputs, known only by the prover, from public inputs shared with the verifier. Master the choice between Noir's efficient `Field` type for general computation and `Integer` types for essential range-specific operations and comparisons. Duration: 4min
9. Assert And Test Functions
A foundational guide to Mastering Constraints and Verification: Assertions and Test Functions in Noir - Discover how to enforce circuit logic using `assert` statements and meticulously verify its behavior with Noir's `#[test]` functions. This lesson lays the groundwork for creating robust and reliable zero-knowledge circuits by ensuring all constraints are satisfied. Duration: 2min
10. Creating And Verifying A Proof Off Chain
An essential deep-dive into The Complete Off-Chain ZK Proof Workflow - Master the command-line journey from Noir circuit to verified ZK proof using `nargo` and Barretenberg's `bb` tools entirely off-chain. This lesson details circuit validation, input handling, witness and proof generation, plus verification key creation and usage. Duration: 10min
11. Using Dependencies In Noir
An essential primer to Understanding the Goal: Off-Chain Signature Verification with Privacy - Learn to initialize your Noir development environment, manage project dependencies using `Nargo.toml`, and integrate the `ecrecover-noir` library. This lesson provides the foundational steps for building circuits for private off-chain signature verification, highlighting critical dependency considerations. Duration: 6min
12. Writing A Signature Verification Circuit
A detailed breakdown to Verifying ECDSA Signatures in Noir: A Practical Guide - Uncover how to construct ECDSA verification circuits in Noir, comparing its library-centric approach to Solidity's `ecrecover`. This lesson offers a step-by-step guide to implementation, essential for ZK applications needing to validate off-chain signatures. Duration: 5min
13. Creating The Noir ECSDA Inputs
A practical breakdown of Understanding Your Noir Circuit and Prover.toml for ECDSA Verification - Uncover the process of creating the `Prover.toml` file, essential for proving ECDSA signature verifications in Noir. You'll learn to generate crypto inputs using `cast` and automate their formatting into the required decimal string arrays with a helper script. Duration: 6min
14. Quiz 14 Quiz
Questions: 20
15. ECDSA Proof And Verifier Contract
A hands-on walkthrough of Generating and Verifying ECDSA Proofs with Nargo and Barretenberg - Master the end-to-end process of creating cryptographic proofs for ECDSA circuits using Nargo and Barretenberg, from witness generation to off-chain validation. This lesson guides you through generating Solidity smart contracts for secure and efficient on-chain proof verification. Duration: 8min
16. Noir ECDSA Summary
A detailed exploration of Verifying ECDSA Signatures On-Chain with Noir and ZKPs - Delve into building Noir ZK circuits for ECDSA signature verification, covering key concepts like input preparation, array types, and the `ecrecover` function. This lesson guides you through generating proofs off-chain and deploying Verifier smart contracts for on-chain validation, bridging private computation with blockchain transparency. Duration: 2min

Course Overview

About the course

What you'll learn

Noir syntax

Create a witness, a proof, and Solidity verifier contracts

Use the Poseidon commitment scheme

Create ZK circuits and build a full ZK protocol

ZK Merkle trees and hashing in Noir

Verify signatures without revealing the signer

Build the backend for a full-stack ZK application with noir.js and bb.js

How to create proofs and verify them in a front-end

Course Description

Who is this course for?

  • Software engineers
  • Solutions Architects
  • ZK Engineers
  • ZK Smart Contract Developers
  • Web3 Developers

Meet your instructors

Ciara Nightingale

Ciara Nightingale

Developer relations at Cyfrin

Last updated on June 12, 2025