Implementing ZKPs on Ethereum: A Practical Tutorial

Zero Knowledge Proofs (ZKPs) have emerged as a cornerstone technology in the blockchain space, enabling privacy-preserving transactions, scalable rollups, and secure identity protocols. This article walks you through the theory, tooling and hands-on steps required to create, verify and deploy a zk-SNARK on Ethereum using industry-leading frameworks like Circom and snarkjs. By the end, you’ll have a complete circuit, verifier contract, and web integration ready for production.

1. Theory of Zero Knowledge Proofs

1.1 Properties

Completeness: Honest prover convinces honest verifier.
Soundness: Dishonest prover cannot cheat, except with negligible probability.
Zero-Knowledge: Verifier learns nothing beyond validity of statement.

1.2 Main ZKP Types

Protocol	Trusted Setup	Proof Size	Ver. Cost (gas)
Groth16 (zk-SNARK)	Yes	~192 bytes	~200 k gas
PLONK (zk-SNARK)	Universal	~800 bytes	~300 k gas
STARK	No	>10 k bytes	>1 M gas

2. Tooling Frameworks

Circom: DSL for arithmetic circuits. (docs)
snarkjs: Keygen, witness, proof and verifier generation. (repo)
Hardhat-Plugin-Circom: Seamless integration in Hardhat projects. (link)
ethers.js / web3.js: On-chain interaction.
OpenZeppelin: Secure Solidity patterns. (site)

3. Hands-On Tutorial

3.1 Environment Setup

Install Node.js npm (v14 ).
npm install -g circom snarkjs
mkdir zk-eth cd zk-eth
npm init -y npm install –save-dev hardhat @nomiclabs/hardhat-ethers ethers hardhat-circom
npx hardhat # select empty project

3.2 Write a Simple Circuit

Create circuits/square.circom:



        pragma circom 2.0.0

        template Square() {

        nbspnbspsignal input x

        nbspnbspsignal output y

        nbspnbspy amplt== x  x

        }

        component main = Square()

3.3 Compile Trusted Setup

circom circuits/square.circom --r1cs --wasm --sym -o build/

Run powers-of-tau ceremony and key generation (Groth16):

snarkjs powersoftau new bn128 12 pot12_0000.ptau -v
snarkjs powersoftau contribute pot12_0000.ptau pot12_0001.ptau --name=First contribution -v
snarkjs powersoftau prepare phase2 pot12_0001.ptau pot12_final.ptau -v
snarkjs groth16 setup build/square.r1cs pot12_final.ptau build/square_0000.zkey
snarkjs zkey contribute build/square_0000.zkey build/square_final.zkey --name=key contributor -v
snarkjs zkey export verificationkey build/square_final.zkey build/verification_key.json

3.4 Generate Proof Verifier

Create input JSON build/input.json with {x: 5}.

Generate witness:

node build/square_js/generate_witness.js build/square_js/square.wasm build/input.json build/witness.wtns

Generate proof public signals:

snarkjs groth16 prove build/square_final.zkey build/witness.wtns build/proof.json build/public.json

Generate Solidity verifier:

snarkjs zkey export solidityverifier build/square_final.zkey ../contracts/Verifier.sol

3.5 Deploy on Ethereum

In contracts/Verifier.sol, wrap the generated verifier in an OpenZeppelin contract and deploy via Hardhat:

Configure hardhat.config.js with your network and private key.
Write scripts/deploy.js:



const hre = require(hardhat)

async function main() {

nbspnbspconst Verifier = await hre.ethers.getContractFactory(Verifier)

nbspnbspconst verifier = await Verifier.deploy()

nbspnbspawait verifier.deployed()

nbspnbspconsole.log(Verifier deployed to:, verifier.address)

}

main().catch(err =gt { console.error(err) process.exit(1) })

3.6 Frontend Integration

Use ethers.js to call verifyProof(a, b, c, input):



import { ethers } from ethers

import proof from ../build/proof.json

import publicSignals from ../build/public.json

import VerifierABI from ../artifacts/contracts/Verifier.sol/Verifier.json

async function verify() { nbspnbspconst provider = new ethers.providers.Web3Provider(window.ethereum) nbspnbspawait provider.send(eth_requestAccounts, []) nbspnbspconst signer = provider.getSigner() nbspnbspconst verifier = new ethers.Contract(VERIFIER_ADDRESS, VerifierABI.abi, signer) nbspnbspconst res = await verifier.verifyProof(proof.pi_a, proof.pi_b, proof.pi_c, publicSignals) nbspnbspconsole.log(Valid proof, res) }

4. Advanced Topics

ZK-EVM initiatives (e.g., Polygon zkEVM).
Recursive Proofs: Nesting circuits for rollups.
Gas Optimization: Minimizing public inputs proof sizes.
STARKs on Layer-2: Check out StarkNet.

5. Security Considerations

Protect your trusted setup consider multi-party ceremonies.
Audit your circuits for unintended leaks.
Verify on-chain gas costs and handle revert scenarios.

6. Conclusion

By following this tutorial, you’ve:

Understood ZKP fundamentals and types.
Built and compiled a Circom circuit.
Generated proofs, keys, and verifier contracts.
Deployed to Ethereum and integrated with a dApp.

Zero Knowledge Proofs unlock privacy and scalability on-chain. Continue exploring advanced protocols to stay at the forefront of zk-development.

Implementing ZKPs on Ethereum: A Practical Tutorial