ZKP 2020-08-05

Zokrates Hello World Walkthrough

1. create root.zok

   • circuit definition in high level zokrates language
   ​​​# a simple circuit which proves knowledge of a square root
   ​​​# of a certain field element `b`
   ​​​def main(private field a, field b) -> (field):
   ​​​   field result = if a * a == b then 1 else 0 fi
   ​​​   return result
   

   • prover provides a and b and calculates result: 1 if b is the square of a, 0 otherwise
   • prover shares b, result and proof
   • verifier can check that prover knew a number a such that main(a, b) == result
   • in other words, verifier can check that prover knew square root of b, without learning the square root.

2. zokrates compile -i root.zok

   • transforms high level circuit definition to quadratic arithmetic program (QAP)
   • creates 3 files: abi.json, out, out.ztf
   • out.ztf is human readable R1CS intermediary representation, out the binary QAP equivalent
   ​​​R1CS
   ​​​====
   ​​​
   ​​​def main(_0, _1) -> (1):
   ​​​     (1 * _0) * (1 * _0) == 1 * _4
   ​​​     # _2, _3 = ConditionEq((-1) * _1 + 1 * _4)
   ​​​     ((-1) * _1 + 1 * _4) * (1 * _3) == 1 * _2
   ​​​     (1 * ~one + (-1) * _2) * ((-1) * _1 + 1 * _4) == 0
   ​​​     (1 * ~one) * (1 * ~one + (-1) * _2) == 1 * ~out_0
   ​​​      return ~out_0
   

   • insert explanation here ;-)

3. zokrates setup

   • creates proving.key, verification.key for binary compiled out representation of circuit
   • this is the most important step, what exactly happens here?
   • to be shared with all provers and verifiers

4. zokrates compute-witness -a 337 113569

   • independent of setup
   • creates a new file witness based on out
   • executes the QAP with the given input variables and saves all assignments to variables of the QAP in witness.
   • witness is not to be shared (contains private variables), just in preparation of proof generation

5. zokrates generate-proof

   • creates proof.json based on out (?), witness, proving.key
   • another crucial step, to be understood later
   • creates a bunch of curve points and such from the witness and the proving key
   • proof is to be shared with the verifier

6. zokrates export-verifier

   • creates verifier.sol from out (?), verifier.key
   • verifier solidity contract
   • to be deployed on chain
   • can verify any valid proof
   • to be understood

7. deploy on chain

8. verify proof

  1
  |
  2 - \
 /|\  |
4.| 3 |
 \|/ \|
  5.  6
  |   |
  8.- 7