Context: explaining the first zkSNARK-powered Ante Test! https://goerli.etherscan.io/address/0x10F9dc103caa6B12C389f4c8EbC094133c162DE9#code

What is a zkSNARK?

• zkSNARKs (zero-knowledge Succinct Non-interactive ARguments of Knowledge) are a mathematical technique to:

  • prove any computation was “done correctly” (“argument of knowledge”)
  • …without necessarily revealing inputs or leaking information (“zero knowledge”)
  • …in an efficient (“succinct”) and self-serve (“non-interactive”) way (ie verifying the proof requires no back-and-forth or intermediation).

• Notably, the resulting “proof” can be verified in O(1) (constant time).

  • This is independent of how complex, or long, the underlying computation “being proved” is!

• Most importantly, this means it can easily be checked within a Solidity smart contract, on-chain, with a (roughly) fixed gas cost, regardless of the complexity of the underlying computation.

  <aside> 💡 TL;DR: zkSNARKs can be seen as a way to “compress” evidence that a lengthy computation was done correctly, for cheap, trustless verification in a resource-constrained, adversarial environment.

  </aside>

How are zkSNARKs relevant to Ante?

• Recap: An Ante Test is an on-chain smart contract that tests, real-time, if a particular guarantee is holding.
  • Thus, Ante Tests are bound by the same computational constraints as other smart contracts;
  • Checking historical guarantees, or “past actions,” on-chain is intractable for deep historical queries.
• Thus, using a zkSNARK to check the validity of a claim of a past state of e.g. Ethereum Mainnet allows for gas-efficient verification of that claim, on-chain.
  • With zkSNARKs, Ante could certify not just “this on-chain guarantee holds in the current block,” but also, “this on-chain guarantee has not failed before.”
    • Example: instead of only testing “protocol XYZ holds more than N of its XYZ token,” one can test, “protocol XYZ has ALWAYS held more than N of its XYZ token, since creation.”
• Furthermore, a zkSNARK allows us to potentially check a proof of not just ONE action or inaction, but a very long list all at once.
  • Imagine a list of “bad actions” that all DAOs eventually agree to never do — a zkSNARK that proves a historical bad action could be checked rapidly.
  • We believe the existence of transparent yet privacy-preserving “accountability tools” helps increase baseline user safety across the space.
  • Example: instead of certifying “ABCDAO did not do [bad action B] in block N,” a zkSNARK Ante Test could instead be structured to check, “ABCDAO has never done [any of bad action B1, B2, …, B9999]”
    • This would still be cheap (gas-wise) to verify on mainnet (ballpark 300k gas on Ethereum mainnet, regardless of the underlying complexity of the computation being proved).

How does the zk Ante Test work?

• The first live zkSNARK-powered Ante Test was deployed on Goerli testnet in August, which uses the zkAttestor service.
• The Ante Test uses zkA to check the validity of a zkSNARK proving a light client proof was valid (which calculates USDT past circulation).
  • The test checks that USDT circulation has always been lower the M2 (the money supply) in the past.
  • A challenger attempting to falsify the test would need to identity a historic block in which they believe USDT circulation was greater than M2.
    • They would then need to generate a light client proof from an archive node and then generate a zkSNARK proof that that light client proof was valid (the zkA service can help with this), and cache it trustlessly into the zkA on-chain service.
    • Technical detail: the actual specific claim is actually, “the data stored at the storage slot of the USDT smart contract that corresponds to totalSupply was actually value X at block height N.”
  • After the corresponding zkSNARK proof is cached on-chain, the challenger would want to set variables in the Ante Test, making a claim about at a specific block height in the past where the USDT circulation was above M2.
    • The Ante Test then checks if a corresponding zkSNARK proof for said claim was valid and cached in the zkA service, which can help falsify (or not-falsify) the Ante Test.