Detailed information on the projects built in zkRollup and the main zkRollup use cases

Source: Four Pillars; Compilation: Baishui, Bitchain Vision

summary

• In 2023, zkRollups transitioned from the research phase to the production phase, with projects such as Starknet, zkSync, Scroll, Polygon zkEVM and Linea launching their respective solutions.

• With the development of new concepts such as coprocessors, prover markets, shared prover and zk aggregation layer, the zkRollup ecosystem has become more efficient and decentralized.

• The operation of zkRollup involves three main stages: execution, proof generation, and proof verification, and various projects focus on optimizing every component in the zkRollup supply chain.

• zkRollups, such as zkSync, Starknet, Merlin and SNARKnado, are developing their infrastructure, but they are still in the early stages of optimizing supply chains.

In 2022, zkRollups is mainly in the research stage.2023 marks the beginning of their future.Many projects, including Starknet, zkSync, Scroll, Polygon zkEVM and Linea, have put their Rollup into the product.The benefits are obvious because it has shorter finalization time, safer interoperability and lower operating costs compared to Optimistic rollups.Despite these advances, zkRollups is still in the experimental stage compared to Optimistic rollups, and its technology roadmap is often changed.

So, what will happen to the future of zkRollups?New terms such as coprocessors, prover markets, shared prover and zk aggregation layers often appear in many projects.zkRollup is being developed in different ways, and in the zkRollup ecosystem, many components are being built to make zkRollups more efficient and decentralized.If we consider how zkRollups works, the process involves three phases: execution, proof generation of execution, and proof verification.Each stage has corresponding projects.To summarize briefly:

• Execution: zkVM, coprocessor

• Proof generation: Proof market, Proof aggregator

• Proof Verification: Settlement Layer

Each of these categories is in its early stages, but as this supply chain becomes more developed, the zkRollup ecosystem will become more efficient.In this article, we will first explore the basics of zk and then dive into the projects being built in the zkRollup supply chain, as well as some of the major zkRollups in Ethereum and Bitcoin.

1. Basics of ZKP and zkRollup

The zkRollup mentioned in the title of this article is a rollup method using zero-knowledge proof (ZKP).If you encounter the term zero-crossing knowledge proof in the blockchain ecosystem, you may have some understanding of it (if not, don’t worry; it will be explained later).However, if you ask why and how to apply this technology to rollup, you may have a hard time answering immediately.

To find the answer to this question, in this chapter we will explore what zero-knowledge proofs and zkRollup are, how they work, and why ZKP technology is a great fit for rollup.

1.1 What is ZKP?

1.1.1 ZKP Overview

Before digging into the details of ZKP, let’s take a look at the components involved in this process.There are two main components:

• Proofreader:The prover holds a statement they want to prove to the validator during the ZKP process.

• Verification:The validator participates in the ZKP process to determine whether the prover’s statement is true based on the evidence provided.

Now, let’s take a look at ZKP in detail.ZKP is an encryption technology in which the prover can prove a specific fact without revealing the fact itself or any relevant information.ZKP has three main characteristics: integrity, reliability, and zero knowledge:

• Integrity:If the proofor’s statement is true, the verifier will be convinced that the statement is true.

• reliability:If the proofor’s statement is wrong, the proofor cannot deceive the proofor into believing it is true.

• Zero knowledge:During the proofing process, the verifier will not obtain any other information except the authenticity or falseness of the statement.

1.1.2 ZKP Example

It may not be easy to understand just by looking at the definition, so let’s use a well-known example “Ali Baba’s Cave” to explain the zero-knowledge proof.

Consider the following scenario: In Alibaba’s cave, there are two paths A and B that converge deep in the cave but are blocked by a secret door.The proofor (P) claims to have the key through this secret door, while the verifier (V) wants to verify that P does have the key.

The verification process follows the following steps: P Enter the cave and select path A or B.V does not know which path P has taken, but can ask P to come out through a specific path.If P has a key, P can come out from any path.After repeating this process several times, V can be sure that P has the key.However, V will not know anything about the shape or nature of the key.

Features of applying it to zero-knowledge proof:

• Integrity:If P always follows V’s instructions during multiple repetitions, V can be sure that P has the key.

• reliability:If P actually has no key, but lie about it, it is inevitable that P will not be able to follow V’s instructions, thus proving that P’s statement is wrong.

• Zero knowledge:V is convinced by multiple iterations that P has the key, but knows nothing about the appearance or properties of the key.

1.2 So what are Rollup and zkRollup?

So far, we have explored A to Z of zero-knowledge proofs.However, it must be remembered that the focus of this article is zkRollups.Now let’s dive into what rollups and zkRollups are.

1.2.1 Rollup Quick Overview

Rollup is a Layer 2 extension solution that processes transactions on the Layer 2 blockchain and then publishes the Rollup status to the Layer 1 blockchain for recording and management.

There have been many proposals to solve the scalability problem of Ethereum.The earliest one was sharding, which was to divide the Ethereum network into several smaller “shards” to significantly improve transaction throughput.Similar to how multiple computers handle tasks simultaneously, sharding enables the Ethereum network to process more transactions quickly and efficiently.

Despite many benefits, Ethereum developers abandoned direct sharding due to concerns about potential centralization and technical challenges, resulting in latency.Instead, they adopted an approach to indirect sharding through the Layer 2 solution.In this method, the process of batch transferring transaction data to Layer 1 is called rollup.Currently, Optimistic Rollup and zkRolups are the two main types leading the ecosystem.

1.2.2 Why ZK Proof and Rollup are perfect matches

The difference between zkRollups and Optimistic rollups is that it uses validity proof rather than fraud proof.zkRollups uses zk-SNARK or zk-STARK to compress large amounts of transactions into a single small proof and document and verify on the Layer 1 blockchain.Unlike Optimistic rollups, this approach significantly improves processing speed and efficiency and does not require a dispute period for error results.

The non-interactive nature of zero-knowledge proof is crucial to the efficiency and convenience of zkRollups.It allows rollups to independently manage rollup processes, maximizing efficiency by bundling transaction data to Layer 1 based on its own schedule.This non-interactive approach prevents potential latency and inefficiency that can occur with more interactive processes between Layer 1 and rollup.

Simplicity is another key factor in the effectiveness of zkRollups.zk-SNARKs and zk-STARKs are able to compress large amounts of data into small proofs, which ensures economic efficiency when sending transaction data to a more expensive but safer Layer 1.This compression capability allows zkRollups to process multiple transactions as a single batch, greatly enhancing the scalability of Layer 1 while providing users with a more cost-effective blockchain infrastructure in a rollup environment.

1.2.3 Running of zkRollup

Let’s further explore how zkRollup works and what components are involved.zkRollup is mainly operated by two components:

• Sequencer:sequencer collects and processes transactions occurring in layer 2 and submits the processing results to layer 1.While some rollup projects have independent entities to sort and generate validity proofs, we treat them here as combination roles for simplicity.

• Rollup Contract:rollup contract is a smart contract on layer 1 that determines the status and transactions of rollups.It receives, stores, and verifies data submitted by the sequencer, ensuring proper storage and management after the data is verified.

The operation process of zkRollup is as follows:

• [Sequencer <> L2] Transaction batch processing and state change calculation:Aggregate multiple transactions executed on Layer 2 into a batch, execute each transaction in the batch, and generate a state root that records the new state changes.

• [Sequencer <> L2] Validity proof generation:Use the new state root to generate validity proof to prove the correctness of the state root.This proof ensures that all transactions within the batch have been executed correctly without revealing the details of each transaction.

• [Sequencer <> L2] Submission of status root and validity proof:The generated validity proof, state root and hidden transaction data are submitted to the Layer 1 Rollup contract.The Rollup contract verifies submitted data.

• [Sequencer <> Rollup Contract (L1)] Verify and update:The Layer 1 Rollup contract receives validity proof, status root, and verification transaction data from the sequencer.It validates the data, updates the status root, and stores the verification transaction data if there is no problem.If problems are found, verification and stored procedures are not performed.

2. zkRollup Supply Chain Overview

From a bird’s eye view, let’s take a look at how the entire supply chain of zkRollups works.zkRollups involves three main processes: execution, proof generation, and verification.

• implement:This occurs off-chain, where transactions are executed in batches on a separate rollup network, thus updating the rollup status.

• Proof generation:Compile transaction batch and status root input.Proof route processing transactions, generates concise zk proofs, cryptographically proof of the validity of state transitions without revealing data.

• Proof Verification:zk proof and related data are submitted to validator contracts on the settlement layer (mainly Ethereum) for verification.If valid, the rollup contract will update its status to reflect the new post status and complete the changes after a brief time buffer.

There are projects specifically for each process to make zkRollups run more efficiently.In the next section, let’s dive into what each process is and which projects are working on them.

2.1 Execution – Execute in the ZK route

Execution is performed separately from settlement layers, the calculation is performed on a separate machine, and the proof of execution is generated in the zk route.This execution environment can be divided into two parts: zkVM and Co-Processor.

2.1.1 zkVM

Source: Foresight Ventures: zk, zkVM, zkEVM and its future | Author: Foresight Ventures | Medium

zkVM (Zero Knowledge Virtual Machine) is a specialized virtual machine designed to perform calculations and generate zero knowledge proofs to verify the correctness of these calculations without revealing the underlying data.There are several types of zkVM, each of which is tailored to specific virtual machines and programming languages.Here are some categories of these items:

• zkEVM:It is designed to replicate the EVM environment while combining zero-knowledge proof capabilities.This allows existing Ethereum smart contracts and dApps to seamlessly port to zkEVM-based Rollup.However, due to the complexity of developing zk routes for EVM and its frequent upgrades, pure EVM has compatibility issues.

• General purpose zkVM based on RISC-V and MIPS:zkRISC is a specific implementation of zkVM developed by RISC Zero.It is designed as a general purpose zkVM that can perform arbitrary calculations and generate zero-knowledge proofs.It allows the deployment of programming languages ​​such as C, Python, and Rust and generates proof of execution.

• CairoVM:Cairo VMs are designed to optimize the generation of proof of validity of program execution.Unlike zkEVM solutions that focus on making EVM compatible with Rollup, Cairo VM is designed from the outset to maximize the efficiency of STARK proven.This approach enables better performance and scalability without being restricted by EVM.However, there are obstacles to building dapps because developers need to learn a new language.

2.1.2 Coprocessor

Source: Phala’s Path 2024: Blockchain’s Coprocessors – AI, Hooks and DePin

Coprocessors are developed as off-chain processors to assist in specific computing.For example, the Graphics Processing Unit (GPU) manages the large amount of parallel computing required for 3D rendering, allowing the central CPU to focus on general-purpose processing.In this sense, coprocessors support blockchain for complex execution, which is expensive on blockchain.Each type of coprocessor is designed to maximize the efficiency of handling its dedicated workloads.

By leveraging ZKP, coprocessors can implement trustless and verifiable off-chain computing, ensuring the correctness and integrity of results without leaking sensitive data.Some known projects include:

• Axiom:Axiom is developing a “ZK coprocessor” system that allows smart contracts to query historical blockchain data and perform complex calculations off-chain while maintaining data privacy and integrity through ZKP.

• Phat Contracts (Phala Network):Phat Contracts is a collaborative processor that enhances scalability, enables gas-free experience, supports multi-chain functionality and provides secure access to off-chain data for dApps.

2.2 Proof generation – generate zero-knowledge proof

To prove the validity of the state transition, the rollup operator (proverb) generates ZKP.This proof confirms that the new state root is correctly calculated from the previous state.Since generating ZKP requires a large amount of computing resources, there are limitations in the proof generation process, especially for large transaction batches or complex smart contracts.This may limit the throughput of zkRollups and the types of applications they can effectively support.

Furthermore, since the entities that generate zk proofs require expertise in the field and need to keep the hardware up to date, the management costs can be high, not to mention the risk of centralization.Therefore, some progress has been made in the field to make it more efficient.The method is divided into two parts: establishing a proof generation market to outsource the generation process, and creating an aggregation layer to make it more cost-effective.

2.2.1 Proof Generate Market

Source: Gevulot Introduction | Gevulot

Key features provided by the proof market include decentralized proof generation, auction mechanisms, and hardware utilization and cost efficiency.The application submits a proof request to the network, and the proofor uses the proof generation hardware to respond to it to ensure that the proof request is effectively processed.The auction mechanism matches these requests with the proofreader, thereby enabling competitive proof pricing.In addition, provers use dedicated hardware, reducing proof costs, and the decentralized market allows aggregation of proof requests from different applications, thereby improving hardware utilization and cost-effectiveness.

Prove the market also ensures review resistance and rapid ending, and implements a pledge mechanism.The market guarantees resistance to short-term review, so the prover’s bid is not unfairly blocked or ignored.Proofers need to be staked with the network to prevent malicious activity and ensure the reliability and integrity of the network.

Finally, the market utilizes economies of scale.Coordinating ZKP generation at scale reduces end users’ costs.Aggregated proof order flow enables proofers to invest in and operate more efficient infrastructure.Since proofs can be aggregated for optimization, applications can also benefit from reduced on-chain validation costs.Some projects include:

• Succinct Network:Succinct Labs is developing a decentralized prover market as part of its Succinct Network to create unified protocols for ZKP.This market will allow applications to outsource their proof generation to a dedicated network of proofers, providing more efficient and cost-effective solutions for ZKP-based systems.The prover market will operate through an auction mechanism that matches the application’s proof requests to a different set of proverbs.

• =nil; Foundation:=nil; Foundation has developed a proof market, a decentralized distributed system designed to serve as a spot market for ZKP.This market allows proof requesters (such as applications) to outsource the generation of zkProof to dedicated proof producers.Prove that the market runs on the =nil; Foundation’s database management system, and its function is more like “Proof DEX” than a centralized service.

• Gevulot:Gevulot is not a traditional prover market, but a decentralized proof layer of the modular stack.It is a permissionless and programmable layer 1 blockchain designed specifically to deploy proof systems as on-chain programs.Unlike the typical prover market, Gevulot allows users to deploy prover and validator programs directly on the blockchain, similar to deploying smart contracts on Ethereum.This approach enables applications to benefit from decentralized proofs without having to guide their prover network or rely on centralized solutions.

2.2.2 Proof Aggregation

Source: Proof It: Shared Proof, Proof Aggregation and Proof Market – Delphi Digital

ZKP aggregation is a technique that combines multiple ZKPs into one proof that reduces the overall cost of validating these proofs on-chain.This is especially beneficial for Rollup, which relies heavily on ZKP.Some notable items include:

• Polygon AggLayer:It aims to achieve smooth interoperability between L2 solutions in the Polygon ecosystem by leveraging aggregated ZKP and unified bridge contracts (LxLy Bridge).Aggregation proof ensures that dependency chain states are consistent with bundles, preventing invalid Rollup states from settled on Ethereum (if it depends on the invalid state of another chain).

• Nebra:Its product Universal Proof Aggregation (UPA) is a protocol used to aggregate ZKP.Nebra’s UPA can aggregate proofs from different routes, proof systems, and parties, reducing on-chain validation gas costs by more than 10 times.Nebra worked with projects like AltLayer to integrate UPA into their Rollup solutions, enabling AltLayer users and dApps to benefit from significantly reducing costs.

• Electron Labs:Electron Labs developed Quantum, an aggregation layer that uses zk-recursion to aggregate proofs from different protocols and various proof schemes into a “super proof”.This super proof is then verified on Ethereum, sharing the verification cost of multiple protocols and providing cheaper verification for a single protocol.

2.3 Proof Verification

The proof generation process in zkRollups is very computationally intensive.However, these proofs are verified on the Ethereum mainnet with relatively light weight, achieving scalability while maintaining the security of the underlying blockchain.

ZK verification smart contracts in Ethereum use efficient encryption algorithms to verify validity proofs.If proven to be valid, the proposed state transition is correct and the new state root is accepted, thus updating the rollup state on the mainnet.Some projects (such as Aligned Layer) provide faster and cheaper verification by leveraging validators in Ethereum.

2.3.1 Alignment layer

Source: whitepaper.alignedlayer.com

Aligned Layer is a decentralized ZKP verification and aggregation layer designed for Ethereum.As the EigenLayer Active Verification Service (AVS), it leverages the economic security of Ethereum through a process called “restaking” to ensure that ZKP is accurately verified and settled on the Ethereum blockchain.

Aligned Layer provides two different operating modes to meet different needs.The fast mode is optimized for minimum verification costs and low latency, making it ideal for applications that require fast and cost-effective proof verification.On the other hand, slow mode uses proof aggregation to make full use of Ethereum’s security guarantees, thus providing comprehensive security.This dual-mode approach allows Aligned Layer to provide flexible solutions that balance speed and security based on the specific requirements of different use cases.

3. zkRollups Analysis

As stated in Section 2, various projects are optimizing the zkRollup supply chain.Let’s take a closer look at the most notable zkRollup projects in production, especially EVM-compatible projects zkSync and Starknet, and Bitcoin-compatible projects Merlin Chain and SNARKnado.

3.1 zkSync

zkSync is a zkRollup solution developed by Matter Labs to solve the scalability challenges faced by the Ethereum network.While zkSync initially focused on scaling Ethereum, its ambitions go far beyond being an L2 solution.Matter Labs envisions zkSync as the foundation of a comprehensive cross-chain ecosystem, aiming to seamlessly connect various zkSync-based aggregations.To achieve this, zkSync is developing a complex but user-friendly cross-chain environment that includes zkRollup technology, ZK Chain and Hyperbridge.Let’s take a look at each concept.

3.1.1 zkRollup—Economic efficiency optimization

zkSync adopts zkRollup technology based on zk-SNARK, and the proof generation and verification method of zk-SNARK, which has a small proof size and fast verification speed.However, as the advantages of zk-STARK such as quantum resistance and large-scale processing are highlighted, zkSync is also trying to partially use zk-STARK, such as the proof generation system called “Boojum”, which uses the zk-STARK method to perform proof generation.

3.1.2 Structural components

• Sequencer:Sequencer in zkSync arranges and processes transactions according to specific rules.Sequencer includes Prover, which generates proof and transaction data that cannot be viewed in detail and sends it to Layer 1.

• Prover:Prover in zkSync uses zk-SNARK to generate proofs. The data used in the proof generation process includes transaction data that cannot be viewed in detail and data before and after state changes representing the state changes of the L2 chain.The generated proof is verified by the Rollup contract on Layer 1.

• Settlement:zkSync is verified using the data generated on Layer 2 and updated in the Layer 1 smart contract.If there is a verification problem, transactions in the affected batch will not be updated.This process is modular, and the following will introduce each ZK Chain to connect one or more smart contracts.

3.1.3 ZK Chain

ZK Chain is a blockchain that goes beyond Layer 2, including the infrastructure provided by zkSync.It is called transcending Layer 2 because zkSync adopts an unrestricted hierarchical structure, including fractal structures such as L3.

The most well-known ZK Chain is zkSync Era built by zkSync.It is EVM compatible and allows simple dapp deployment.However, for zkSync’s ultimate cross-chain ecosystem goal, the relationship between different ZK Chains is crucial.zkSync focuses on how to connect with other future ZK Chain.

An example of using the ZK Chain environment is Hyperbridge.With Hyperbridge, users can conveniently send all assets from the link chain to their chain-specific wallet.When users need to use assets on their chain, repeaters facilitate the bridging, destruction and issuance of assets.

For example, if you use a cross-chain Uniswap and the user on the era.zksync chain wants to redeem 1 ETH to 10,000 DAI, the process is as follows:

• Generate “1 ETH → 10,000 DAI” transaction from the era.zksync chain wallet.

• The repeater transfers 1 ETH to uni.chain and redeems it for 10,000 DAI.

• The repeater then transfers the exchanged 10,000 DAI back to the era.zksync chain.

• This way, users can easily perform cross-chain transactions using zkSync’s environment without having to learn more about other chains.

3.1.4 EVM compatibility

zkSync currently claims 99% compatibility with Solidity and Vyper.Initially, zkSync supported the Rust-like language Zinc to achieve a more suitable and efficient zkEVM.However, they shifted their focus to Solidity compatibility, with Zinc development halted since September 2021 to ensure full optimization.

3.2 Starknet

Starknet is similar to zkSync, both are layer 2 solutions based on zkRollup, but its technology stack and internal technology are different.It is worth noting that it uses zk-STARK instead of zk-SNARK and uses its own smart contract language Cairo.

3.2.1 zk Rollup – Focus on high-capacity Rollup processing

Starknet uses zk-STARK to generate and verify proofs related to Rollup.Similar to zkSync, it only uses front and back state changes to manage Rollup data more efficiently at Tier 1.

Additionally, due to Starknet adopting zk-STARK, it benefits from a trustless environment and the ability to process large numbers of transactions simultaneously.This makes Starknet the first choice for high-trade DeFi dApps or gaming dApps.

3.2.2 Structural Features

Structurally speaking, Starknet adopts a similar architecture to other zkRollups.But what makes it different is actively leveraging the zk-STARK zero-knowledge proof model and maintaining EVM compatibility through its proprietary programming language Cairo.

Source: Starknet Architecture: Overview

• Sequencer:Sequencer in Starknet plays a crucial role in managing the verification and execution of transactions and proposing blocks.Its main function is to batch process transactions.Unverified transactions are restricted by Sequencer, and only verified transactions are included in the block.The Sequencer also includes a proofer responsible for sending completed rollup data to Layer 1.

• Proof:Proofers in Starknet use zk-STARK to generate proofs.During the proof generation process, the proof holds each transaction execution step to create an Execution Trace and tracks state changes in the L2 chain, recording State Diff.The proof generation process requires a large amount of computing resources and is designed to support parallel processing, allowing multiple provers to divide the work and execute tasks simultaneously.

• Settlement:The data generated on Layer 2 is transferred to Layer 1 (such as Ethereum), where the components accept transactions and manage proof and state differences.These components are processed by two smart contracts: the validator contract and the Starknet core contract.The validator contract analyzes proof received from Tier 2 and exercises a veto on the transaction if any problem is found.If the validity of the proof is confirmed, it is transferred to the Starknet core contract, which updates the Layer 1 chain with the provided state changes.This update status will be added to the Layer 1 chain block, which will be affected by Layer 1 once the block passes through the Layer 1 process.

3.2.3 EVM Compatibility

Starknet is developing its own unique EVM compatibility path through the Cairo language.To deploy smart contracts on Starknet, Cairo must be used.While Cairo does not support many Solidity features yet, while Cairo developer numbers are increasing, it still lags behind Solidity in community size and adoption.

Cairo, the smart contract language of Starknet, inherits the functions of Rust.It is optimized for zk-STARK proof generation, and can efficiently execute and generate proofs of smart contracts.Overcoming the barriers to using Cairo allows you to deploy and execute smart contracts in a better environment and aggregate data to layer 1 securely.

The following table outlines the main differences between Cairo and Solidity.

3.3 Merlin Chain

Merlin Chain is a Bitcoin-based layer 2 zkRollup solution developed by Bitmap Tech, which focuses primarily on Ethereum.Merlin Chain is based on Polygon’s zero-knowledge proof technology, which has the advantage of EVM compatibility, while safely storing Rollup data to Bitcoin L1.In this way, Merlin Chain aims to increase liquidity and expand the ecosystem within the Bitcoin network, including BTC, with the slogan “Make Bitcoin interesting again.”

3.3.1 zkRollup – A hybrid approach to bitcoin features

Merlin Chain uses zkRollup technology that combines zk-SNARK and zk-STARK.Initially, due to the structural characteristics of the Bitcoin network, ZKP could not be directly verified on the Bitcoin network.However, after the Taproot upgrade, partial verification becomes feasible.Merlin Chain uses Taproot to record off-chain Rollup data and proof data generated onto the Bitcoin network.

In Merlin Chain, zkProver is responsible for verifying the validity of transaction data and generating proofs based on the verified data.The stages of this process are as follows:

• Merlin Chain’s sequence node stores current status information in the database.

• The sequence node sends the transaction to zkProver.

• zkProver accesses the database to retrieve the data required for transaction verification.

• Once zkProver completes transaction verification, it generates a proof and sends it to the sequence node.

The process involves several steps.First, use zkEVM based on zk assembly language (zkASM) developed by the Polygon zkEVM team to verify and process transactions.The generated data is then aggregated and compressed using zk-STARK’s high capacity processing capability to optimize the economic efficiency of Rollup.Finally, zk-SNARK is used to generate proofs that produce a consistent proof size.The generated data and proofs are then verified in the decentralized Merlin Chain oracle network environment and uploaded to the Bitcoin network via Taproot.

3.3.3 Future Upgrade: Proof of On-chain Fraud

While zkRollup seems to be well applied to the L2 solution for the Ethereum ecosystem (as described in Section 3.2.1), it itself does not guarantee the validity and accuracy of in-rollup transactions.To bridge the gap caused by differences in Bitcoin’s network structure, Merlin Chain uniquely plans to introduce an on-chain fraud prevention mechanism similar to optical rollup.

On-chain fraud prevention mechanisms operate in the relationship between rollup data proposers and challengers.If the challenger believes that the rollup data is incorrect, they can challenge transaction data, ZK status information and ZK proof uploaded to the Bitcoin network.Most L2 transactions do not require re-verification on the Bitcoin network (L1), but if challenges are raised against previously proposed rollup data, the data and transactions must be re-executed and verified.If a character is found to be at fault, they will be punished.

3.3.4 EVM Compatibility

Merlin Chain implements EVM compatibility by using zkASM-based zkEVM in its zkProver.This allows smart contracts developed using existing Ethereum development tools and infrastructure to be executed on the Bitcoin network, providing the advantage of extending Ethereum’s capabilities to Bitcoin.

3.4 SNARKnado

SNARKnado is a Bitcoin-based layer 2 solution implemented by Alpen Labs using zk-SNARK.Alpen Labs aims to leverage SNARKnado to make blockchain focus more on verification rather than computing, enabling higher scalability and efficiency in the Bitcoin ecosystem.

3.4.1 zkRollup – BitVM’s successor

SNARKnado is a modified model that is further optimized for zk-SNARK, which draws on the prover-challenger structure used in the BitVM Optimism method.This makes it performance by about eight times compared to BitVM.However, it still doesn’t meet the advantage of BitVM2 allowing anyone to challenge, as SNARKnado currently limits the challenge capabilities to allowed roles.

3.4.2 Structural characteristics

Proof Verification Method – Bipartite Polynomial

Using zk-SNARK allows SNARKnado to manage Rollup data and proof data on Bitcoin at a smaller proof size, but Bitcoin’s limitations on complex calculations require optimization of proof verification.SNARKnado solves this problem by using binary polynomial transformation to prove the data.The verification process is performed through on-chain calculations enabled by Taproot upgrade.

When the prover receives a challenge, they disclose some of the data required for the challenge and conduct a verification process with the challenger.The binary polynomial method is used to verify, determining which role (proverb or challenger) is wrong.

3.4.3 SNARKnado with BitVM or BitVM2

SNARKnado has many similarities with BitVM, especially as a midpoint between BitVM and BitVM2.So, what is the difference between them?(Since BitVM2 is a more advanced model than BitVM, comparisons will focus mainly on BitVM2.)

First, consider the use of internal resources of Bitcoin.BitVM2 inherently displays a linear increase in on-chain resource usage, while SNARKnado reduces this increase to the square root level, optimizing on-chain resource usage.Another difference is the accessibility of the characters that can issue challenges.While SNARKnado limits challenges to allowed roles, BitVM2 allows anyone to issue challenges without permission.

3.4.4 EVM Compatibility

According to the latest records from Alpen Labs, EVM compatibility has not been officially supported and there are currently no future plans for EVM compatibility.

4. Looking to the future

Looking back at the recently launched zkRollups mainnet, we see zkSync Era in August 2023 and Polygon zkEVM in December 2023.These projects have not been launched for a long time, so most projects are still under active development.In addition, the development scope is no longer limited to zkEVM.General purpose zkVM, zkWasm, and off-chain coprocessors are also performing part of development, where custom zk routes are used.

As basic execution and proof generation become more reliable, efforts are being made to improve supply chain efficiency.Strategies include establishing a prover market, aggregating multiple proofs, and creating verification layers for cost-effective verification.It is expected that zkRollups’ supply chain will become more efficient and affordable in the future.