Zero Knowledge Proof Research by OKX Ventures
Introduction
Overview
- How do zero-knowledge proofs work
- Circuit Codes
· Develop in Ethereum
· Develop in other blockchains - ZKP Applications
· Privacy Certificate
· ZK-DID
· ZK-NFT
· Computation outsourcing
Key Investment Opportunities
- Capacity Expansion
- ZK hardware acceleration
· Background
· Tier 1 projects in this segment ( primary market ) - ZK Cross-Chain Communication Protocol: Full Chain DApp
· Overview
· Related Projects
· Conclusion - zkp proof mechanism innovation (difficult to implement)
- ZK-DID and ZK-NFT
- Other niche directions
——————————————————————————————————————
Introduction
ZKPs ( Zero-knowledge proofs ) have proofed more use cases, inceptions like zkBridge and data index, and other flourishing opportunities in cryptography, as we can learn from the ZK Layer 2 leaders such as Starkware and scroll. It is exciting that a breakthrough was made in interoperability by a combination of ZKP + Light Client, and it also adds impetus to web3 expansion that web 2 developers could easily and comfortably migrate to web3 in ZK-EVM (Ethereum Virtual Machine) introduced by written in zkWasm / Rust. Besides, ZKP improved scalability in a way by moving computation and state storage off-chain, this is also known as validity proof which is useful for any case in off-chain execution.
OKX Ventures tracked the VCs put investments that were built on ZK-evm in 2022, while leaning on infrastructures currently, for example, ZK Circuit Complier, ZK Hardware Accelerating, ZK Oracle and zkBridge. And tendency emerged that zk-VMs are increasing though Dapps will readily compatible with zk-EVM, mapping out Ethereum won’t be the only one in web3, frankly ZK-vm are more friendly to developers than zk-EVM.
Overview
In cryptography, a zero-knowledge proof is a method by which one party (the prover) can prove to another party (the verifier) that a given statement is true while the prover avoids conveying any additional information apart from the fact that the statement is indeed true. ZKP was first proposed in 1985 by researchers including Shafi Goldwasser, The specific concern they raised was information leakage. How much extra information is the Verifier going to learn during proof is more important.
It is obscure to adopt technology in the real world in 1900s, until the birth of bitcoin in 2009. ZKP systems can be used to build blockchain-based privacy and scalability solutions. Now we hear that great numbers of capitals and teams are joining this development journey.
How do zero-knowledge proofs work
There are two main types of zero-knowledge proofs， and zero-knowledge protocols rely on algorithms that take some data as input and return ‘true’ or ‘false’ as output.
Interactive zero-knowledge proofs require interaction between the individual (or computer system) proving their knowledge and the individual validating the proof.
Typically in “ Response “. The prover accepts the question, calculates the answer, and returns it to the verifier. The prover’s response allows the verifier to check if the former really has access to the witness. To ensure the prover isn’t guessing blindly and getting the correct answers by chance, the verifier picks more questions to ask.
Non-interactive zero-knowledge proofs are for independent verification. The prover and verifier have a shared key. This allows the prover to demonstrate their knowledge of some information (i.e., witness) without providing the information itself, which means that it required only one round of communication between participants (prover and verifier).
This technology is popular use in blockchain proving systems today. We see nodes are validators to verify and layer2&users are provers.
Common ones are
· ZK-SNARKs — Zero-Knowledge Succinct Non-Interactive Argument of Knowledge.
· ZK-STARKs — Zero-Knowledge Scalable Transparent Argument of Knowledge.
Circuit Codes
AppliedZKP requires circuit programming, where the ZKP proof code is converted into a series of simple constraint expressions R1CS and then, using Lagrangian interpolation, into a huge polynomial QAP that is finally constrained in the form of a gate circuit. Thus the ZKP logic code is called a “circuit”.
Code Logic
- Flatten the problem polynomial and construct the corresponding circuit.
- Generate R1CS (Rank 1 Constraint System) according to the circuit.
- Convert R1CS to QAP (Quadratic Arithmetic Program)， Setup parameters of the QAP problem, to get Proving Key and Verify Key.
- Create proof based on RICS and Proving Key.
- Verify proof.
Circuits programming languages
- Develop in Ethereum
i. Cairo
Proving System: STARK
Cairo is A language for scaling dApps using STARKs.StarkNet software stack. run by writing in Cairo.
ii. zkEVM
Like EVM, zkEVM is a virtual machine that transitions between states as the result of program operations, but zkEVM proves the correctness of each part of the computation by generating proofs.
Essentially, zkEVM uses a mechanism to prove that the execution steps follow the rules. Teams from zkSync、Polygon、Scroll、Starkware made great progress in building with zkevm to realize EVM compatibility.
2. Develop in other blockchains
i. zkApps
zkApps are smart contracts that allow developers to leverage Mina Protocol’s unique zero-knowledge technology. They can execute unlimited off-chain computations at a flat fee.
ii. Aleo
Aleo is the developer platform for building fully private, scalable and cost-effective applications Using zero-knowledge cryptography. It introduced LEO, a Rust-inspired statically typed programming language designed by Aleo.
Source:https://www.chaincatcher.com/article/2087467
ZKP application areas
- Privacy Certificate
Zcash is probably the first widely used application of ZKP, which builds on the Bitcoin source code and applies ZKP to the transfer of tokens, making the information about the transaction completely confidential but at the same time verifiable by nodes on the blockchain.
Tornado Cash is a coin blender running on Ethereum that uses ZKP to prove nodes on the Merkle-Tree. It allows users to deposit a fixed amount of tokens into the pool and then use the Proof generated by ZKP to prove that they have deposited the funds, but without revealing the transaction information they had when they deposited.
ZK-DID
ZK-DID is a one-stop solution for decentralized identity. At its core, it is a verifiable credential system that can verify credentials with zero-knowledge proof without compromising user privacy, such as KYC/AML/CFT scenarios.
Representative projects: zCloak, polyhedra
ZK-NFT
ZK-NFT is actually more than NFT, but encapsulates various standard tokens and various data under the chain (from read-write state to read-only state), and encrypted by ZK pointers, thus being able to protect the privacy of related information.
2. Computation outsourcing
In blockchain, each node has limited computing power, but with ZKP technology, it is possible for a node to outsource a large number of calculations to off-chain nodes, and then it is only necessary to verify the results and proofs of calculations submitted by outsourcing to know whether the calculations are correct or not.
A good example of this is zksync1.0, which performs ethereum token transfers and transactions off-chain, and then submits the results to the node, which can know whether it performed the computation according to its declared method by verifying the ZKP proof.
3. Data compression
Filecoin uses ZKP to construct a spatio-temporal proof system that proves that a user has stored a specific file locally, which has been proven to have stored up to 18 EiB.
Mina is another example. In many high-speed blockchain systems, the data of transactions is very large, and the system needs to keep all the blocks for the verification of consensus protocols, so the system has extremely high hardware requirements, and permanent storage means that blockchain nodes will need to continuously increase disk space and data indexing capabilities. At this time, the verification data can be compressed with the help of ZKP. Mina compresses the ledger to 11 KB by recursive zero-knowledge proofs, but still verifies the correctness of the blocks.
Key Investment Opportunities
- Capacity Expansion
Layer2， not to be elaborated here
2. ZK hardware acceleration
Background
The generation of ZK proofs is one of the most central steps in a ZK project. Unfortunately, with existing ZK proof systems, generating ZK proofs is usually computationally intensive. As the complexity of the project increases and the size of the ZK circuit grows, the amount of computation required for ZK proof generation increases exponentially. For example, for large zkEVM/zkVM projects such as Scroll, zkSync, etc., it can take hours or even days of computation to generate ZK proofs entirely by CPU. In practice, most projects need to limit the generation of ZK proofs to a few seconds and minutes. Computation times of hours or longer are completely unacceptable for most ZK projects, especially for scaling projects such as zkEVM/zkVM.
In addition, the computational complexity of ZK proof generation is hardly likely to be reduced on a theoretical level in the future time window of about 2 years before the ZK project goes live. Therefore, in order to ensure the availability of the project, the ZK project must adopt the technical solution of “accelerated ZK proof generation” to accelerate ZK proof generation to the level of seconds or minutes before the project goes live. High-performance hardware acceleration of ZK proof generation is currently the preferred method.
The current ZK hardware acceleration solution is implemented by the following three types of hardware:
- GPU
- FPGAs
- ASICs
Currently, there are two main types of hardware acceleration solutions available on the market: GPU and FPGA. The GPU/FPGA acceleration solution is relatively easy to implement. Therefore, in order to capture the market faster, most vendors will implement GPU/FPGA solutions first. Due to the high hardware cost of GPU and FPGA, the power consumption is relatively large and the absolute performance is limited. Therefore, ASIC solutions are an integral part of the ZK hardware acceleration ecosystem that cannot be ignored.
Source:https://www.theblockbeats.info/news/34797
Tier 1 projects in this segment ( primary market )
There are currently three tier 1 players in this segment, Supranational, Ulvantanna, and Cysic.
Supranational
Supranational has been in the GPU acceleration ZK track since 2019, and recently started to get involved in the FPGA/ASIC space. Supranational already has a very mature open-source GPU-based acceleration solution with industry-leading performance. Supranational is an early entrant to the market, has some industry resources and good cash flow.
Ulvantanna
The founding team is from Jump crypto and has received investment from paradigm and bain crypto, so its strength should not be underestimated.
Cysic
Cysic is committed to designing advanced ASIC chips to help reduce ZK proof generation time, and has built a top-notch hardware design and development team that has completed FPGA-based POC design. Based on the POC results, Cysic’s ZK hardware acceleration capabilities have been proven to be industry leading. The lead investor in the first round was Polychain
Currently, in addition to dedicated hardware acceleration teams, many ZK project owners are also exploring hardware acceleration solutions internally, such as zkSync and Scroll
3. ZK Cross-Chain Communication Protocol: Full Chain DApp
Overview
ZKP provides a completely new way to communicate across chains. It does not completely solve the security problems of traditional cross-chain bridges, but because ZKP can provide concise proofs with much smaller proof sizes than before, it can consume less storage to relay the source chain state to the target chain. In addition, it is relatively inexpensive to verify SNARK proofs on the target chain. The cost of in-chain verification is also much lower. These two important features of ZKP enable low-cost cross-chain message and state delivery. Verifying the source chain state on the target chain enables IBC-style cross-chain bridging. This greatly increases cross-chain security.
The workflow for using ZKP for relaying messages can be broken down into the following steps.
- Decide which data to pass to the target chain
- Obtain a proof of storage (proof that the data exists in EVM storage)
- Generate ZK proofs based on the storage proofs
- Passing the ZK proof from the starting chain to the target chain
- Expand the ZK proof on the target chain
- Read cross-chain information at the target chain
Related Projects
- Succinct Labs
- Lagrange
- zkBridge
- Herodotous
- nil
Succinct Labs uses a light client-side approach to verify the consensus of the starting chain’s consensus layer on the target chain. zKP is used to generate consensus proofs.
Lagrange Labs builds non-interactive cross-chain proofs of state, and Lagrange Attestation Network is responsible for creating the state root. Each Lagrange Node contains a portion of a sharded private key that is used to prove the state of a particular chain. Each state root is a threshold-signed Verkle Root that can be used to prove the state of a particular chain at a particular time. The state roots are completely generic and can be used in state proofs to prove the current state of any contract or wallet in the chain.
Herodotus uses ZKP’s storage proofs to provide smart contracts with access to on-chain data from Ether. It has an MPC Optimistic Relayer to relay promises. It uses off-chain compression to expand the relayed blockchain header off-chain and create proofs.
zkBridge uses the MPC relay network to generate the ZKP of the block header and relays it to the target chain. It uses deVrigo and recursive proofs to achieve very fast proof times, but the MPC part has a high complexity. The first user initiates a cross-chain message request. The sender in the initial chain then forwards the block header to the relay network. The verifier in the relay network generates a proof of the block header and passes it to the update contract. The update contract verifies the proof and accepts it. The update contract forwards the proof to the recipient, who forwards it to the applications and users in the target chain.
Conclusion
In the past, contract deployments were mainly focused on one chain. When scaling to another chain, applications had to be redeployed. Using the ZK-based cross-chain message relay protocol will enable a paradigm shift from single-chain applications to cross-chain applications. Large projects can easily scale to different chains.
There are many application chains on Cosmos because Cosmos has better interoperability and the cross-chain protocol supported by ZK would be a better tool to connect non-Cosmos application chains to the EVM or layer2 ecosystem. Many of the Rollup SDKs under development can benefit from the cross-chain protocol supported by ZK.
DApp developers can deploy their DApp components in different chains. For example, some chains may be a good choice for computation due to their low computation costs. Some chains may be optimized for privacy, which will serve as a privacy feature of the Dapp. Some chains can host files, and some are suitable for providing front ends. Cross-chain messaging protocols can glue these components together and allow developers to take full advantage of each blockchain.
Source:https://mp.weixin.qq.com/s/Vs7t9G2k0rcm3kpAY3bF8w
4. zkp proof mechanism innovation (difficult to implement)
For example, PolyHedra has made a meaningful innovation in ZKP proof mechanism, summarized by a distributed approach to generate SNARK proofs faster, and then develop zk full-stack projects based on this, thus realizing the interconnection of Web2 and Web3 worlds
5. ZK-DID ZK-NFT
6. Other niche directions
The most notable new technology from the Nil Foundation, for example, is actually zkLLVM, a “low-level virtual machine” that allows developers to build using the mainstream programming languages Rust and C++, thus significantly reducing their workload. The founders of the zkEVM platform Scroll, for example, have said that they have helped save months of time on projects by manually building circuits with a special software library developed in the Rust programming language.
The key here is the zero-knowledge circuit, which is part of building zkEVM (zkEVM is divided into three parts: the execution environment, the proof circuit, and the verifier contract) to complete the proof generation process.
Compiling zero-knowledge circuits often means involving niche programming languages, domain-specific software libraries, and a strong understanding of cryptography, making it a complex and responsive task.
Nil Foundation has built a mainstream language compiler on top of LLVM, trying to be the best tool for developers to compile zero-knowledge circuits.
