What is a zk-SNARK?

A zk-SNARK is a zero-knowledge proof that is small, quick to verify and needs only one message from the prover, which is why blockchains can check them inside a smart contract.

Also called SNARK or succinct non-interactive argument of knowledge.

Explain it like I’m five

Picture a receipt for a very long sum. The sum took the prover a week, and the receipt fits on a sticky note. A clerk checks the receipt in a blink and never sees the week of working. This works because everyone shares special public numbers, made once by a group of people who each stirred in a secret of their own and then burned it. If one of them really burned theirs, nobody can print a fake receipt. If all of them kept theirs, someone could.

What problem it solves

A blockchain pays for the bytes it stores and the steps it checks, so proofs must stay small and cheap to verify. A SNARK keeps both small. In the 2013 Pinocchio system the proof was 288 bytes, whatever the computation, and checking it took about 10 milliseconds. The ethereum.org documentation puts the cost of verifying one SNARK proof on Ethereum at about 500,000 gas, which a rollup shares among thousands of transactions.

How it works, step by step

  • The program is flattened into a list of additions and multiplications on numbers modulo a large prime (an arithmetic circuit), and then into polynomial equations (a quadratic arithmetic program).
  • A correct run means that one polynomial built from the circuit divides evenly by a fixed polynomial that is zero at the circuit’s gates. The division leaves no remainder only if every gate was computed correctly.
  • Checking this at one secret random point is enough, because two different polynomials agree at very few points. Nobody may know that point, yet the prover must work with it.
  • A one-time setup solves this by publishing the point’s powers locked inside elliptic-curve points (the trusted setup), so the prover can combine them blindly without learning the point.
  • The prover sends a few curve points that stand for the polynomials’ values at the secret point (the proof). The knowledge-of-exponent assumption forces the prover to have built them from the published powers.
  • The verifier checks the key equation with a pairing, a special map on curve points that multiplies hidden values without revealing them. A handful of pairing checks suffices, whatever the program’s size.
  • Fresh randomness mixed into the proof hides the prover’s secrets (zero knowledge). Because the secret point sits inside the public setup, no challenge has to be sent, so one message is enough (non-interactive).

A worked example

Zcash’s Sapling payments use the Groth16 system. Each spend carries a proof that the spender knows a note in the commitment tree and computed its nullifier correctly. The proof is three curve points, 192 bytes in all, and the check is one equation with three pairings. A circuit with a hundred gates and one with a million produce proofs of the same size.

What it guarantees

  • The proof stays a few curve points, and the check takes a few pairings, however long the computation was (succinctness).
  • The prover sends one message and needs no live exchange (non-interactivity).
  • The prover must actually know a valid secret input, under the stated assumptions (argument of knowledge). The guarantee holds against provers with limited computing power.
  • The trust sits in the setup. Whoever keeps the secret behind the public numbers can forge proofs, so ceremonies spread that secret over many people.
  • The assumptions come from elliptic curves, including knowledge of exponent, which cannot be derived from ordinary curve security. The FRI paper notes that quantum computers can create false proofs in polynomial time for such systems.
  • Checking is cheap and proving is not. In 2017 Vitalik Buterin put the time to prove one Zcash transaction at about 20 to 40 seconds.

Common misunderstandings

  • The zk is a separate property. A succinct argument can leak its inputs, and the ethereum.org documentation notes that validity proofs used for scaling do not make transactions confidential by themselves.
  • Not every SNARK needs a trusted setup. Zcash’s Orchard pool uses Halo 2, whose parameters the software generates on the fly with no parameter files.
  • Succinct means short compared with the computation behind it. A Groth16 proof is 192 bytes in Zcash, and other systems produce larger ones.
  • A setup secret lets its holder forge proofs. A ceremony with many independent participants makes holding the whole secret implausible.

Where it is used

Zcash has used zk-SNARKs for shielded payments since 2016, with Groth16 in its Sapling pool and Halo 2 in its Orchard pool. The ethereum.org documentation also describes zk-rollups, which prove batches of transactions with SNARKs or STARKs.

History

Bitansky, Canetti, Chiesa and Tromer introduced the term SNARK in a 2011 paper. Pinocchio (2013) made 288-byte proofs practical, Zerocash (2014) applied them to payments, Zcash launched in 2016, and Jens Groth’s system of the same year cut a proof to three group elements. Zcash’s Sapling parameters came from a multi-party ceremony.

In Redacted

Redacted proves every private action with a STARK, a zero-knowledge proof whose only cryptographic building block is a hash, for every account from day one. It needs no trusted setup and no elliptic curves, the kind of cryptography expected to hold against quantum computers.

Bunker mode →

Related terms

Sources: Zk-SNARKs: Under the Hood, Vitalik Buterin, 2017 · On the Size of Pairing-based Non-interactive Arguments, Jens Groth, 2016 · Pinocchio: Nearly Practical Verifiable Computation, Parno, Gentry, Howell and Raykova, 2013 · Zcash Protocol Specification · Zero-knowledge rollups, ethereum.org

Updated November 1, 2026. All terms