Author: Zeke, YBB Capital Source: medium Translation: Shan Ouba, Golden Finance

Abstract

• ZK coprocessors can be seen as off-chain computing plug-ins derived from the concept of modularity, similar to the GPU in traditional computers, which offloads graphics computing tasks from the CPU to handle specific computing tasks.

• They can be used to handle complex calculations and large amounts of data, reduce gas fees and expand smart contract functions.

• Unlike Rollups, ZK coprocessors are stateless, can be used across chains, and are suitable for complex computing scenarios.

• Developing ZK coprocessors is challenging, with high performance costs and lack of standardization. The hardware cost is also quite high. Although the field has matured a lot compared to a year ago, it is still in its early stages.

• As the era of modularity enters fractal expansion, blockchain faces problems such as liquidity shortage, user fragmentation, lack of innovation and cross-chain interoperability issues, forming a paradox with the vertically expanded L1 chain. ZK coprocessors may provide a way to overcome these challenges, support existing and emerging applications, and bring a new narrative to the blockchain field.

I. Another branch of modular infrastructure: ZK coprocessor

1.1 Overview of ZK coprocessor

Zero-knowledge coprocessor can be understood as an off-chain computing plug-in derived from the modular concept, similar to the GPU in traditional computers that offloads graphics computing tasks from the CPU and handles specific computing tasks. Under this design framework, tasks that public chains are not good at, such as "heavy data" and "complex computing logic", can be handed over to zero-knowledge coprocessors for calculation. The chain only receives the returned calculation results, and uses zero-knowledge proofs to ensure their correctness, ultimately achieving trusted off-chain calculations for complex tasks.

Currently, popular applications such as AI, SocialFi, DEX, and GameFi have an urgent need for high performance and cost control. In traditional solutions, these "heavy applications" with extremely high performance requirements often choose the asset on-chain + off-chain application model, or design a separate application chain. However, both methods have inherent problems: the former has a "black box", and the latter faces problems such as high development costs, separation from the original chain ecology, and liquidity fragmentation. In addition, the main chain virtual machine also imposes great restrictions on the development and operation of such applications (such as lack of application layer standards, complex development languages, etc.).

ZK coprocessors are designed to solve these problems. To give a more specific example, we can imagine the blockchain as a terminal that cannot connect to the network (such as a mobile phone or computer). In this scenario, we can run relatively simple applications completely on the chain, such as Uniswap or other DeFi applications. But when more complex applications appear, such as running applications like ChatGPT, the performance and storage of the public chain will be completely insufficient, resulting in gas explosion. In the Web2 scenario, when we run ChatGPT, our ordinary terminal itself cannot handle the GPT-4o large language model. We need to connect to OpenAI's server to transfer the problem. After the server calculates and infers the result, we get the answer directly. The ZK coprocessor is like a remote server for the blockchain. Different coprocessor projects may have subtle design differences depending on the project type, but the underlying logic is roughly the same - off-chain calculation + ZK proof or storage proof for verification.

Taking Rise Zero's Bonsai deployment as an example, this architecture is very intuitive. The project integrates seamlessly into Rise Zero’s own zkVM, and developers can use Bonsai as a coprocessor in just two simple steps:

• Write a zkVM application to handle the application logic.

• Write a Solidity contract that asks Bonsai to run your zkVM application and process the results.

1.2 Differences from Rollups

From the above definition, the implementation logic and goals of Rollups and ZK Coprocessors are highly overlapped, but Rollups are more like a multi-core extension of the main chain. The specific differences between the two are as follows:

1. Main purpose:

• Rollups: Enhance blockchain transaction throughput and reduce transaction fees.

• ZK coprocessors: Expand smart contract computing capabilities to handle more complex logic and larger data volumes.

2. Working Principle:

• Rollups: Aggregate on-chain transactions and submit them to the main chain together with fraud proofs or ZK proofs.

• ZK Coprocessor: Similar to ZK Rollups, but designed for different application scenarios. ZK Rollups are not suitable for coprocessor tasks due to chain-specific constraints and rules.

3. State Management:

• Rollups: Maintain their state and synchronize with the main chain regularly.

• ZK Coprocessor: Stateless, each computation is stateless.

4. Application scenarios:

• Rollups: Mainly serves end users and is suitable for high-frequency trading.

• ZK coprocessor: Mainly serves enterprises and is suitable for scenarios that require complex calculations, such as advanced financial models, big data analysis, etc.

5. Relationship with the main chain:

• Rollups: are regarded as extensions of the main chain and usually focus on a specific blockchain network.

• ZK coprocessor: can serve multiple blockchains, not limited to a specific main chain, and can also serve Rollups.

Therefore, the two are not mutually exclusive but complementary, and ZK Coprocessors can still provide services even if Rollup exists in the form of an application chain.

1.3 Use Cases

In theory, the application scope of ZK coprocessors is very wide, covering projects in all areas of blockchain. ZK coprocessors enable Dapps to have functions closer to centralized Web2 applications. Here are some example use cases collected from online sources:

Data-driven DApp development:

ZK coprocessors enable developers to create data-driven Dapps that utilize complete on-chain historical data for complex calculations without the need for additional trust assumptions. This opens up unprecedented possibilities for Dapp development, such as:

• Advanced data analysis: On-chain data analysis capabilities similar to Dune Analytics.

• Complex business logic: Implement complex algorithms and business logic in traditional centralized applications.

• Cross-chain applications: Build cross-chain Dapps based on multi-chain data.

VIP trader program for DEX:

A typical application scenario is to implement a volume-based discount program in DEX, namely the "VIP trader loyalty program". Such programs are common in CEX, but rare in DEX.

With the help of ZK coprocessor, DEX can:

• Track users' historical trading volume.

• Calculate users' VIP level.

• Dynamically adjust transaction fees based on VIP level. This feature helps DEX improve user retention, increase liquidity, and ultimately increase revenue.

Data enhancement for smart contracts:

ZK coprocessor can serve as a powerful middleware to provide data capture, calculation, and verification services for smart contracts, thereby reducing costs and improving efficiency. This enables smart contracts to:

• Access and process large amounts of historical data.

• Perform complex off-chain calculations.

• Implement more advanced business logic.

Cross-chain bridge technology:

Some ZK-based cross-chain bridge technologies, such as Herodotus and Lagrange, can also be regarded as applications of ZK coprocessors. These technologies mainly focus on data extraction and verification, providing a trusted data foundation for cross-chain communication.

1.4 ZK coprocessor is not perfect

Although the ZK coprocessor has so many advantages, it is not perfect at this stage and there are still some problems. I have summarized the following points:

1. Development: The concept of ZK is difficult for many developers to grasp. Development requires relevant cryptographic knowledge and proficiency in specific development languages ​​and tools.

2. High hardware cost: ZK hardware used for off-chain computing must be borne entirely by the project party. ZK hardware is expensive and evolves rapidly. It may be eliminated at any time. Whether a commercial closed loop can be formed is a question worth thinking about.

3. Crowded field: Technically speaking, there will not be much difference in implementation, and the final result may be similar to the current Layer2 landscape, where some outstanding projects stand out and the rest are basically ignored.

4. ZK Circuits: Performing off-chain computations in a ZK coprocessor requires converting traditional computer programs into ZK circuits. Writing custom circuits for each application is cumbersome, and writing circuits using zkVM in a virtual machine incurs a lot of computational overhead due to different computational models.

II. Key Elements for Mass Adoption

(This section is highly subjective and only represents the author's personal opinion.)

This cycle is mainly led by modular infrastructure. If modularity is the right path, this cycle may be the last step towards mass adoption. However, at this stage, we all have a common feeling: why do we only see some old applications being repackaged, why are there more chains than applications, and why new token standards like Inscription are hailed as the greatest innovation of this cycle?

The fundamental reason for the lack of fresh narratives is that the current modular infrastructure is not enough to support super applications, especially the lack of some prerequisites (cross-chain interoperability, user barriers, etc.), resulting in the most serious fragmentation in the history of blockchain. As the core of the modular era, Rollups has indeed accelerated the process, but it has also brought many problems, such as liquidity fragmentation, user dispersion, and restrictions on application innovation by the chain or virtual machine itself. In addition, Celestia, another "key player" in modularization, has pioneered a path where DA is not necessarily on Ethereum, further exacerbating fragmentation. Whether it is ideologically driven or DA cost-driven, the result is that BTC is forced to become a DA, and other public chains aim to provide more cost-effective DA solutions. The current situation is that each public chain has at least one or even dozens of Layer2 projects. In addition, all infrastructure and ecological projects have deeply learned the token staking strategy pioneered by Blur, requiring users to stake tokens within the project. This model allows whales to benefit from three aspects (interest, ETH or BTC appreciation, free tokens), while also further compressing on-chain liquidity.

In the past bull market, funds would only flow in a few to a dozen public chains, and even mainly concentrated on Ethereum. Now, funds are scattered across hundreds of public chains and bet on thousands of similar projects, resulting in a decrease in on-chain activity. Even Ethereum lacks on-chain activity. Therefore, Eastern players PVP in the BTC ecosystem, while Western players PVP in Solana out of necessity.

Therefore, my current focus is on how to promote the aggregated liquidity of all chains and support the emergence of new gameplay and super applications. In the field of cross-chain interoperability, traditional leading projects have been performing poorly and are still similar to traditional cross-chain bridges. The new interoperability solutions we have discussed in previous reports are mainly aimed at aggregating multiple chains into one chain. Examples include AggLayer, Superchain, Elastic Chain, JAM, etc., which will not be introduced here one by one. In summary, cross-chain aggregation is a necessary obstacle for modular infrastructure, but it will take a long time to overcome.

ZK coprocessors are a key part of the current stage. They can strengthen Layer2 and complement Layer1. Is there a way to temporarily overcome the cross-chain and trilemma and allow us to implement some current-era applications on some Layer1 or Layer2 with extensive liquidity? After all, blockchain applications lack fresh narratives. In addition, it may be more ideal to achieve diversified game modes, gas control, large-scale applications, cross-chain capabilities, and lower user barriers through integrated coprocessor solutions than to rely on centralization.

III. Project Overview

The ZK Coprocessor field emerged around 2023 and is relatively mature at this stage. According to Messari's classification, the field currently covers three major verticals (general computing, interoperability and cross-chain, AI and machine training), with a total of 18 projects. Most of these projects have been supported by head VCs. Below we introduce several projects from different verticals.

3.1 Giza

Giza is deployed on Starknet zkML (zero-knowledge machine learning) protocol, officially supported by StarkWare. It focuses on enabling AI models to be verifiably used in blockchain smart contracts. Developers can deploy AI models on the Giza network, then verify the correctness of the model reasoning through zero-knowledge proofs and provide the results to smart contracts in a trustless manner. This allows developers to build on-chain applications that combine AI capabilities while maintaining the decentralization and verifiability of the blockchain.

Giza completes the workflow in three steps:

• Model conversion: Giza converts the commonly used ONNX format AI model into a format that can be run on a zero-knowledge proof system. This allows developers to train models using familiar tools and then deploy them on the Giza network.

• Off-chain reasoning: When a smart contract requests AI model reasoning, Giza performs the actual calculations off-chain. This avoids the high cost of running complex AI models directly on the blockchain.

• Zero-knowledge verification: Giza generates a zero-knowledge proof for each model inference, proving that the calculation was performed correctly. These proofs are verified on-chain, ensuring the correctness of the inference results without repeating the entire calculation process on-chain.

Giza's approach allows AI models to serve as a trusted input source for smart contracts without relying on centralized oracles or trusted execution environments. This opens up new possibilities for blockchain applications, such as AI-based asset management, fraud detection, and dynamic pricing. It is one of the few projects in the current Web3 x AI field that has a logical closure and cleverly utilizes coprocessors in the AI ​​field.

3.2 Risc Zero

Risc Zero is a leading coprocessor project backed by multiple top VCs. It focuses on making any calculation verifiably executable in blockchain smart contracts. Developers can write programs in Rust and deploy them on the RISC Zero network. RISC Zero then verifies the correctness of program execution through zero-knowledge proofs and provides the results to smart contracts in a trustless manner. This allows developers to build complex on-chain applications while maintaining the decentralization and verifiability of the blockchain.

We briefly mentioned deployment and workflow before. Here, we introduce two key components in detail:

• Bonsai: Bonsai is a coprocessor component in RISC Zero that is seamlessly integrated into the zkVM of the RISC-V instruction set architecture. It allows developers to quickly integrate high-performance zero-knowledge proofs into Ethereum, L1 blockchains, Cosmos application chains, L2 Rollups, and dApps in a few days. It provides direct smart contract calls, verifiable off-chain computing, cross-chain interoperability, and general Rollup capabilities, while adopting a decentralized first distributed architecture. Combining recursive proofs, custom circuit compilers, state continuation, and continuously improving proof algorithms, it enables anyone to generate high-performance zero-knowledge proofs for a variety of applications.

• zkVM: zkVM is a verifiable computer that operates similarly to a real embedded RISC-V microprocessor. It is based on the RISC-V instruction set architecture and allows developers to write programs that can generate zero-knowledge proofs in high-level programming languages ​​such as Rust, C++, Solidity, and Go. It supports more than 70% of popular Rust packages, seamlessly combines general computing with zero-knowledge proofs, and can generate efficient zero-knowledge proofs for calculations of arbitrary complexity while maintaining the privacy of the computation process and the verifiability of the results. zkVM uses zero-knowledge technologies such as STARK and SNARK to achieve efficient proof generation and verification through components such as Recursion Prover and STARK-to-SNARK Prover, supporting off-chain execution and on-chain verification.

Risc Zero has integrated with multiple ETH Layer2 solutions and demonstrated various use cases for Bonsai. An interesting example is Bonsai Pay. This demo uses RISC Zero's zkVM and Bonsai proof service to allow users to send or withdraw ETH and tokens on Ethereum using their Google account. It shows how RISC Zero can seamlessly integrate on-chain applications with OAuth2.0 (the standard used by major identity providers such as Google), providing a use case that lowers the barrier for Web3 users through traditional Web2 applications. Other examples include DAO-based applications.

3.3 =nil;

=nil; is an investment project supported by well-known institutions such as Mina, Polychain, Starkware, Blockchain Capital, etc. It is worth noting that zk technology pioneers such as Mina and Starkware are also among the supporters, indicating that the project is highly recognized technically. =nil; is also mentioned in our report "Hashrate Market", focusing on Proof Market (decentralized proof generation market). In addition, =nil; has another sub-product called zkLLVM.

zkLLVM, developed by the =nil; Foundation, is an innovative circuit compiler that automatically converts application code written in mainstream programming languages ​​such as C++ and Rust into efficient provable circuits for Ethereum without the need for specialized zero-knowledge domain-specific languages ​​(DSLs). This greatly simplifies the development process, lowers the barrier to entry, and improves performance by avoiding zkVM. It supports hardware acceleration to speed up proof generation, making it suitable for a variety of ZK application scenarios such as rollups, cross-chain bridges, oracles, machine learning, and games. It is tightly integrated with the =nil; Foundation's Proof Market, providing developers with end-to-end support from circuit creation to proof generation.

3.4 Brevis

Brevis, a subproject of Celer Network, is an intelligent zero-knowledge (ZK) coprocessor for blockchains that enables dApps to access, compute, and utilize arbitrary data across multiple blockchains in a completely trustless manner. Like other coprocessors, Brevis has a wide range of use cases, such as data-driven DeFi, zkBridges, on-chain user acquisition, zkDID, and social account abstraction.

The Brevis architecture consists of three main parts:

• zkFabric: zkFabric is the relay component of the Brevis architecture. Its main task is to collect and synchronize block header information from all connected blockchains, and then generate consensus proofs for each collected block header through the ZK light client circuit.

• zkQueryNet: zkQueryNet is an open ZK query engine market that can directly accept data queries from on-chain smart contracts and generate query results and corresponding ZK query proofs through ZK query engine circuits. These engines range from highly specialized (e.g., calculating the transaction volume of DEX in a specific period) to highly general data index abstractions and high-level query languages ​​to meet various application needs.

• zkAggregatorRollup: As the aggregation and storage layer of zkFabric and zkQueryNet, it is responsible for verifying the proofs of these two components, storing the proved data, and submitting its ZK-proven state root to all connected blockchains, allowing dApps to directly access the proved query results in their on-chain smart contract business logic.

Through this modular architecture, Brevis can provide trustless, efficient and flexible access to all supported public chain smart contracts. UNI's V4 version also adopts this solution and integrates it with Hooks (a system for integrating various user-defined logics) to facilitate the reading of historical blockchain data, reduce gas fees, and ensure decentralization. This is an example of a zk coprocessor driving DEX.

3.5 Lagrange 

Lagrange is an interoperability zero-knowledge proof coprocessor protocol led by 1kx and Founders Fund. It is mainly aimed at providing trustless cross-chain interoperability and supporting applications that require complex computing of large-scale data. Unlike traditional node bridges, Lagrange's cross-chain interoperability is mainly achieved through its innovative zero-knowledge proof big data and national committee mechanism.

• ZK Big Data: This is Lagrange's core product, responsible for processing and verifying cross-chain data and generating related zero-knowledge proofs. The component includes a highly parallel ZK coprocessor for performing complex off-chain computations and generating zero-knowledge proofs; a specially designed verifiable database that supports unlimited storage slots and direct SQL queries from smart contracts; a dynamic update mechanism that only updates changed data points to reduce proof time; and an integration function that allows developers to access historical data using SQL queries directly from smart contracts without writing complex circuits. Together, they form a large-scale blockchain data processing and verification system.

• State Committee: This component is a decentralized verification network consisting of multiple independent nodes, each of which stakes ETH as collateral. These nodes act as ZK light clients and specialize in verifying the status of certain optimized rollups. The State Committee is integrated with EigenLayer's AVS, using a re-staking mechanism to enhance security, supporting an unlimited number of participating nodes, and achieving super-linear security growth. It also provides a "fast mode" that allows users to perform cross-chain operations without waiting for the challenge window, greatly improving the user experience. The combination of these two technologies enables Lagrange to efficiently process large-scale data, perform complex calculations, and securely transmit and verify results between different blockchains, supporting the development of complex cross-chain applications.

Lagrange has been integrated with EigenLayer, Mantle, Base, Frax, Polymer, LayerZero, Omni, AltLayer, etc., and will become the first ZK AVS linked to the Ethereum ecosystem.