Unlocking the Future of Blockchain: Exploring ZK-Rollups and zkEVM

Posted on: October 23, 2024 | Reading time: 22 minutes | Word count: 4613 words | Author: Dang Duong Minh Nhat

In our previous exploration, we delved into the foundational structures that underpin decentralized networks. Building on that foundation, this blog focuses on the innovative concepts of zk-Rollups and zkEVMs, technologies poised to revolutionize scalability and efficiency on the Ethereum blockchain. As we navigate through the complexities of these solutions, we’ll uncover how they tackle current limitations and pave the way for a more interconnected decentralized ecosystem.

Table of Contents

Scaling Blockchain: Understanding Layer-1 and Layer-2 Solutions

Blockchain technology has transformed the way we think about trust, transparency, and transactions. However, as the number of users and applications grows, so does the need for increased transaction capacity. To address this, developers are exploring two primary approaches to scaling blockchain ecosystems: Layer-1 and Layer-2 solutions. Let’s dive into these concepts to understand how they work and their implications for the future of blockchain.

Layer-1 Scaling: Enhancing the Blockchain Itself

Layer-1 scaling involves making changes to the blockchain’s core protocol to increase its transaction capacity. The idea is straightforward: if we can make the blockchain handle more transactions per second (TPS), we can alleviate congestion and improve user experience. However, this approach comes with its own set of challenges.

Line Source Image

The Challenge of Bigger Blocks

One common method for Layer-1 scaling is to increase the block size. While larger blocks can indeed accommodate more transactions, they pose significant verification challenges. As blocks grow larger, they become more difficult to validate. This complexity can lead to a centralization risk, where only a few powerful nodes can afford to process these larger blocks, undermining the very decentralized nature of blockchain.

Sustainable Solutions: Sharding

To address these challenges, developers are turning to techniques like sharding. Sharding involves breaking the blockchain into smaller, more manageable pieces (or “shards”) that can be processed concurrently by multiple nodes. This division of labor increases efficiency and scalability without sacrificing decentralization. Notably, the Eth2 upgrade is currently implementing sharding to enhance its transaction capacity.

Layer-2 Scaling: Offloading Activity from the Blockchain

While Layer-1 scaling focuses on improving the blockchain itself, Layer-2 scaling takes a different approach. Instead of pushing all activities onto the blockchain, Layer-2 solutions allow users to conduct the bulk of their transactions off-chain. This off-chain processing alleviates congestion on the main blockchain while still leveraging its security features.

How Layer-2 Works

Layer-2 protocols operate by utilizing a smart contract on the main blockchain. This contract has two main responsibilities:

  1. Processing Deposits and Withdrawals: Users can deposit funds into the Layer-2 protocol and withdraw them back to the Layer-1 blockchain when needed.
  2. Verifying Off-Chain Activity: The smart contract verifies proofs that the off-chain transactions comply with the established rules.

The magic of Layer-2 lies in how these proofs are generated and verified. Various methods exist to create these proofs, but they all share a crucial property: verifying them on-chain is significantly cheaper than executing the original computation off-chain. This efficiency makes Layer-2 solutions appealing for users looking to reduce costs and enhance transaction speeds.

The Benefits of Layer-2 Solutions

Layer-2 scaling solutions offer several advantages:

  • Increased Speed: With most transactions handled off-chain, users experience faster confirmation times.
  • Reduced Costs: By minimizing the on-chain activity, users can save on transaction fees, making blockchain more accessible.
  • Enhanced Scalability: Layer-2 can effectively manage a higher volume of transactions, allowing blockchains to support a growing user base and application ecosystem.

Unpacking Rollups: The Future of Ethereum Scaling

As the Ethereum ecosystem expands, the demand for more efficient transaction processing has given rise to innovative solutions known as rollups. These technologies allow existing Ethereum applications to migrate seamlessly with minimal code changes while enhancing scalability. But what exactly are rollups, and how do they work? Let’s break it down.

What Are Rollups?

At their core, rollups are layer-2 scaling solutions designed to process transactions off the main Ethereum blockchain (Layer 1) while leveraging its security. They are fully general-purpose, meaning you can run an Ethereum Virtual Machine (EVM) within a rollup, allowing developers to deploy existing Ethereum applications without extensive rewrites.

The Mechanics of Rollups

So, how does a rollup operate? Here’s a step-by-step explanation:

The Smart Contract

A rollup is governed by a smart contract that maintains a state root—the Merkle root of the rollup’s current state, including account balances, contract code, and other data. This smart contract is pivotal for ensuring the integrity of the rollup’s state.

Line Source Image

Batching Transactions

Users can submit a batch—a collection of transactions packaged together in a compressed format. Each batch includes:

  • The previous state root (the state before the transactions in the batch are applied).
  • The new state root (the state after the transactions are processed).

When a batch is submitted, the smart contract checks that the previous state root matches the current state root. If everything aligns, the contract updates the state root to the new one.

Line Source Image

Deposits and Withdrawals

To facilitate interactions with assets outside the rollup, the smart contract allows transactions that input or output assets not directly within the rollup’s state. Here’s how it works:

  • Deposits: If a batch includes transactions that take assets from the outside, the submitting transaction must transfer these assets to the rollup contract.
  • Withdrawals: When processing a batch that outputs assets to the outside, the smart contract initiates the corresponding withdrawals.

Ensuring Correctness of State Roots

A crucial question arises: How do we ensure that the post-state roots in the batches are accurate? If anyone could submit a batch with any post-state root without consequence, they could easily steal funds from the rollup. To address this, there are two distinct approaches leading to two types of rollups: Optimistic Rollups and ZK Rollups.

Optimistic Rollups vs. ZK Rollups

Optimistic Rollups

Optimistic rollups operate on the principle of fraud proofs. Here’s how they function:

  • The rollup contract keeps a history of all state roots and the hashes of each batch.
  • If someone identifies an incorrect post-state root in a submitted batch, they can publish a proof to the chain that demonstrates the error.
  • The contract verifies this proof and reverts the faulty batch along with all subsequent batches, ensuring the integrity of the rollup.

This model relies on the assumption that most transactions are valid, hence the term “optimistic.”

ZK Rollups

In contrast, ZK rollups utilize validity proofs to maintain correctness. Every batch submitted includes a cryptographic proof called a ZK-SNARK (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge), which confirms that the post-state root is the correct result of executing the transactions in that batch. The benefits of ZK rollups include:

  • Fast Verification: Regardless of the complexity of the computation, the proof can be quickly verified on-chain, making them highly efficient.
  • Security: ZK rollups provide stronger guarantees against fraud because each batch is backed by cryptographic proof.

Understanding Zero-Knowledge Rollups: A Deep Dive into Layer 2 Scaling

As the Ethereum ecosystem continues to grow, the demand for faster, more efficient transactions is becoming increasingly urgent. Enter Zero-Knowledge Rollups (ZK-rollups)—a revolutionary solution that promises to enhance scalability while maintaining the security and integrity that Ethereum is known for. But what exactly are ZK-rollups, and how do they function? Let’s explore this exciting technology in detail.

What Are Zero-Knowledge Rollups?

ZK-rollups are a layer-2 scaling solution that enables the bundling of multiple transactions into a single batch, executed off-chain. This method significantly reduces the amount of data that needs to be posted to the Ethereum blockchain. Instead of sending each transaction individually, ZK-rollup operators submit a summary of the changes required to represent all the transactions in a batch, accompanied by validity proofs to ensure the correctness of those changes.

Line Source Image

Interacting with Ethereum: The Role of ZK-rollups

ZK-rollups operate as an off-chain protocol atop the Ethereum blockchain, managed by smart contracts that ensure the system’s integrity. Here’s how the interaction unfolds:

Core Architecture

  1. On-chain Contracts: The ZK-rollup protocol is controlled by smart contracts on Ethereum. This includes a primary contract that tracks rollup blocks, monitors state updates, and manages deposits. A secondary verifier contract checks the validity proofs submitted by block producers, solidifying Ethereum’s role as the foundational layer.
  2. Off-chain Virtual Machine (VM): While transactions are executed off-chain, they occur in a separate virtual machine independent of the Ethereum Virtual Machine (EVM). This off-chain VM serves as the execution environment for transactions, ensuring efficiency while the validity proofs are ultimately verified on the Ethereum mainnet.

The Security Framework of ZK-rollups

ZK-rollups are often described as hybrid scaling solutions. They operate independently while relying on Ethereum for security. Here are the critical aspects:

  • Data Availability: ZK-rollups publish state data for every transaction processed off-chain to Ethereum. This transparency enables users and businesses to reproduce the rollup’s state independently. The data is available to all network participants, ensuring that anyone can verify the rollup’s integrity.
  • Transaction Finality: Ethereum acts as a settlement layer for ZK-rollups. Transactions on layer 2 are only finalized once the mainnet contract accepts the validity proof, mitigating the risk of malicious operators attempting to corrupt the chain.
  • Censorship Resistance: Most ZK-rollups utilize a “supernode” or operator to execute transactions and produce batches. While this ensures efficiency, it poses a risk of censorship. If users suspect that their transactions are being excluded, they can directly submit transactions to the rollup contract on the mainnet, allowing for an exit without relying on the operator’s consent.

How ZK-Rollups Work: A Step-by-Step Guide to Layer 2 Transactions

Step 1: User Transactions

Users start by signing their transactions and submitting them to Layer 2 (L2) operators for processing. These operators are responsible for including transactions in the next batch. Depending on the ZK-rollup design, the operator could either be a centralized entity known as a sequencer, who handles all transactions, or a decentralized set of operators using a proof-of-stake system.

In the decentralized model, prospective operators deposit funds into the rollup contract. The size of their stake influences their chances of being selected to produce the next rollup batch. If an operator acts maliciously, their stake can be slashed, incentivizing them to maintain the integrity of the network.

Step 2: Publishing Transaction Data

Once transactions are collected, the ZK-rollup operator publishes the transaction data on Ethereum as calldata. This area is used to pass arguments to smart contract functions and persists on-chain as part of Ethereum’s history logs. Calldata is a cost-effective way to store transaction data because it doesn’t affect Ethereum’s state.

The operator calls a function in the rollup contract, passing the compressed transaction data as arguments. This helps minimize storage costs for users since a significant portion of rollup fees is tied to on-chain data storage.

Step 3: State Commitments

The state of the ZK-rollup, which includes all Layer 2 accounts and balances, is represented as a Merkle tree. The cryptographic hash of this tree’s root, known as the Merkle root, is stored in the on-chain contract, allowing the protocol to track changes in the rollup’s state.

When a new batch of transactions is executed, the operator computes a new state root and submits it to the on-chain contract. If the accompanying validity proof is authenticated, this new Merkle root becomes the rollup’s canonical state root.

Step 4: Validity Proofs

Before submitting the new state root, the ZK-rollup operator must provide a validity proof that verifies the correctness of the batched transactions. Validity proofs confirm that the proposed changes are valid without revealing the underlying data.

ZK-rollups typically use ZK-SNARKs (Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge) or ZK-STARKs (Zero-Knowledge Scalable Transparent Arguments of Knowledge) for these proofs. Both methods validate off-chain computation while ensuring privacy and security.

ZK-SNARKs vs. ZK-STARKs

  • ZK-SNARKs require a trusted setup for generating public parameters, which can introduce security risks if not handled correctly. However, they produce small proofs and allow for fast verification on-chain.
  • ZK-STARKs, on the other hand, do not require a trusted setup and offer better scalability and quantum resistance. They do produce larger proofs, which can be more expensive to verify on Ethereum.

Step 5: Proof Generation

When the operator has enough transactions, they aggregate them into a batch and compile inputs for the proving circuit, which generates the validity proof. This process involves:

  1. Verifying that the sender and receiver accounts are valid.
  2. Ensuring the sender has sufficient funds.
  3. Confirming that the transaction details align with the sender’s public key.

The proving circuit loops through each transaction, updating balances and generating new state roots after each transaction is processed. This final Merkle root reflects the rollup’s updated state.

Step 6: Proof Verification

After the proving circuit has created the validity proof, the L2 operator submits it to the verifier contract on Ethereum. The contract checks:

  • The pre-state root (the old state).
  • The post-state root (the new state after transactions).
  • The batch root (the Merkle root of the batch).
  • The transaction inputs.

If everything checks out, the rollup contract updates its state tree to reflect the new state.

Unlocking the Future of Ethereum: The Promise of zk-Rollups

In the ever-evolving landscape of blockchain technology, zk-Rollups have emerged as a frontrunner in scaling solutions for Ethereum. Celebrated for their robust security and swift finalization times, zk-Rollups promise to revolutionize how we think about decentralized applications (DApps) on the Ethereum network. However, despite their advantages, significant hurdles remain for developers looking to leverage this technology fully.

The Advantages of zk-Rollups

Security Meets Efficiency

At the heart of zk-Rollups lies a brilliant concept: aggregating countless transactions into a single Rollup block and generating a succinct proof off-chain. This proof is then submitted to Ethereum’s Layer 1, where a smart contract merely needs to verify it. By avoiding the need to re-execute every transaction, zk-Rollups save on gas fees significantly—proof verification is far cheaper than executing computations repeatedly.

As Vitalik Buterin, Ethereum’s co-founder, puts it: “In the medium to long term, ZK rollups will win out in all use cases as ZK-SNARK technology improves.” This technology not only makes transactions faster and cheaper but also maintains the security guarantees that Ethereum Layer 1 offers.

Data Compression

Another noteworthy advantage of zk-Rollups is their ability to compress data. By keeping only the essential information on-chain for verification, zk-Rollups ensure that the Ethereum blockchain remains efficient and uncluttered. This allows for a more scalable environment, paving the way for future innovations.

The Current Limitations

Despite these promising features, zk-Rollups currently face significant limitations, particularly in their application scope. At this stage, their usage is largely confined to payments and swaps. The hurdles arise from two primary challenges:

Developer Unfriendliness

To build DApps on zk-Rollups, developers must write their smart contract logic in a specialized language known as R1CS (Rank-1 Constraint System). Unfortunately, R1CS is not only syntactically complex but also requires an extensive understanding of zero-knowledge proofs. This steep learning curve can deter many developers from exploring zk-Rollup opportunities, thus limiting innovation.

Line Source Image

Lack of Composability

Another critical drawback is the absence of composability within zk-Rollups. Composability allows different applications to interact seamlessly within Layer 2, which is vital for creating interconnected DeFi ecosystems. Without this capability, zk-Rollup applications are isolated, significantly undermining the potential for building rich, integrated decentralized finance solutions.

Line Source Image

The Path Forward: Enhancing Developer Experience

To unlock the full potential of zk-Rollups, it’s essential to address these limitations head-on. The goal is to provide a seamless developer experience and enable composability within Layer 2.

Supporting Native EVM Verification

One promising solution lies in supporting native EVM (Ethereum Virtual Machine) verification directly within zk-Rollups. By allowing existing Ethereum applications to migrate to zk-Rollups with minimal adjustments, developers can harness the benefits of this scaling solution without needing to learn a new programming language or face the challenges of isolation.

This approach will not only make zk-Rollups more accessible to developers but also encourage a flourishing ecosystem of interconnected DApps. With enhanced composability, DeFi applications can interact more effectively, creating synergies that lead to innovative financial products and services.

Two Approaches to Building DApps in zk-Rollups

Application-Specific Circuits (ASIC)

The first method involves creating application-specific circuits, or ASICs, tailored for individual DApps. This traditional approach leverages zero-knowledge proofs by designing custom circuits that can handle the specific logic and requirements of each application.

Advantages:

  • Efficiency: Customized circuits can optimize performance, reducing overhead for specific DApps.
  • Tailored Solutions: Developers can fine-tune the circuit to meet the unique needs of their application.

Challenges:

  • Complexity: Designing ASICs requires significant expertise in circuit design and zero-knowledge proofs, making it less accessible for many developers.
  • Composability Issues: Since each circuit is static and specific to a single application, it limits interaction between different DApps, undermining the potential for a cohesive ecosystem.

Universal EVM Circuits

The second approach proposes building a universal circuit based on the Ethereum Virtual Machine (EVM). Instead of creating individual circuits for each DApp, this method focuses on verifying program execution at a lower level, similar to how a CPU operates.

Line Source Image

Advantages:

  • Developer Accessibility: Developers can write smart contracts using familiar high-level languages without needing to design custom circuits.
  • Flexibility: This approach allows for greater composability since any DApp can run on the same universal circuit.

Challenges:

  • High Overhead: One significant drawback is the large computational overhead. For instance, even a simple operation like addition incurs the overhead of an entire EVM circuit. This can lead to inefficiencies, especially with complex DApps requiring numerous execution steps.

Understanding zkEVM: The Future of Ethereum Scaling

As the demand for efficient and scalable solutions on the Ethereum network grows, a new concept has emerged at the forefront of blockchain technology: the zkEVM. But what exactly is a zkEVM, and why is it significant?

What is a zkEVM?

At its core, a zkEVM is an EVM-compatible virtual machine that incorporates zero-knowledge proof computation. Unlike traditional virtual machines, a zkEVM not only executes programs but also proves the correctness of that execution. This includes validating both the inputs and outputs used during operations, ensuring that all processes are accurate and trustworthy.

Breaking Down the Definition

To better understand what a zkEVM is, let’s dissect its two key components:

EVM Compatibility

The Ethereum Virtual Machine (EVM) is the runtime environment for executing smart contracts on the Ethereum network. Think of it as a “world computer” that allows decentralized applications (dApps) to run seamlessly.

An EVM-compatible virtual machine can execute programs written for the EVM, such as smart contracts developed in Solidity or other Ethereum-friendly languages. zkEVMs are designed to be EVM-compatible, which means developers can run existing Ethereum smart contracts with minimal modifications. This compatibility is crucial because it lowers the barrier to entry for developers looking to leverage the benefits of zkEVM technology.

Support for Zero-Knowledge Technology

While the EVM was never originally designed to support zero-knowledge proofs, recent advancements in research have made it possible to integrate these proofs into EVM computation. This integration is vital as it allows for greater scalability and privacy on the Ethereum network.

Different zkEVM projects employ various approaches to merge EVM execution with zero-knowledge proof computation. Each method comes with its own set of trade-offs, which we’ll delve into later.

The Workflow of zkEVM: Revolutionizing Ethereum Transactions

As Ethereum continues to evolve, understanding the differences between Layer 1 and Layer 2 solutions is crucial for developers and users alike. Enter the zkEVM, a cutting-edge approach that enhances transaction efficiency and scalability.

Layer 1 vs. Layer 2: The Basics

Layer 1: The Traditional Approach

On Layer 1, transactions involve a straightforward but resource-intensive process. Here’s how it works:

  1. Storage: Deployed smart contracts’ bytecodes are stored in Ethereum’s storage.
  2. Broadcasting: Transactions are broadcasted across a peer-to-peer (P2P) network.
  3. Execution: Each full node retrieves the corresponding bytecode, executes it on the EVM, and strives to reach the same state based on the transaction input.

This method relies on re-executing the smart contract bytecodes, which can be slow and expensive, especially as network congestion increases.

Layer 2: The zkEVM Advantage

In contrast, zkEVM introduces a more efficient workflow. Here’s how it operates:

  1. Bytecode Storage: Similar to Layer 1, bytecodes are stored in the same way.
  2. Off-Chain Transactions: Transactions are sent off-chain to a centralized zkEVM node instead of being executed on every node.
  3. Proof Generation: Rather than executing bytecode directly, the zkEVM generates a succinct validity proof to confirm that state updates were applied correctly.
  4. Verification on Layer 1: Finally, this proof is submitted to a Layer 1 contract for verification, allowing the state to be updated without re-executing the transactions.

This streamlined process significantly reduces costs and increases speed, making zkEVM a game changer for the Ethereum network.

Deep Dive into the zkEVM Execution Process

The zkEVM’s core strength lies in its ability to generate zero-knowledge proofs that validate various elements of computation. Let’s break down what needs to be proven:

  1. Bytecode Access
    • Was the appropriate program code loaded correctly from the right address?
      • This ensures that the zkEVM is working with the correct bytecode.
  2. Read-Write Operations
    • Did the program fetch the correct values from the stack, memory, or storage before computation?
    • Did the program write the correct output values back after execution?
      • These steps are crucial for maintaining data integrity throughout the transaction process.
  3. Computation
    • Were the opcodes executed in the correct order without skipping any steps?
      • Each opcode comprises three sub-steps: reading elements, performing computations, and writing results. Ensuring these are executed accurately is vital for the overall correctness of the transaction.

The Architecture of zkEVM

The zkEVM consists of three integral components: the execution environment, the proving circuit, and the verifier contract. Let’s look at each part in detail.

The Execution Environment

This is where the smart contracts are executed. The zkEVM’s execution environment mirrors the EVM’s functionality: it takes the initial state and current transaction, processes them, and outputs a new final state. This ensures that the logic remains consistent with existing Ethereum contracts.

The Proving Circuit

The proving circuit is responsible for generating the zero-knowledge proofs that validate the transactions computed in the execution environment. Here’s how it works:

  • Input Data: It uses pre-state information, transaction inputs, and post-state details to create proofs.
  • Proof Generation: After processing these inputs, the circuit produces a succinct proof verifying the validity of the state transition.

Line Source Image

This succinct proof is what makes zkEVM efficient and powerful.

The Verifier Contract

Once the validity proofs are generated, they are submitted to a smart contract deployed on Layer 1 (Ethereum) for verification. Here’s the process:

  • Input Submission: The pre-states and transaction information are sent to the verifier contract.
  • Proof Verification: The contract computes the provided proof, confirming that the outputs were correctly derived from the inputs.

This mechanism allows the zkEVM to maintain security and integrity while minimizing the need for costly and time-consuming re-executions.

Understanding zkEVM Opcodes: The Building Blocks of Zero-Knowledge Execution

As the Ethereum ecosystem continues to evolve, zkEVMs (zero-knowledge Ethereum Virtual Machines) are at the forefront of enhancing scalability and privacy on the blockchain. A crucial component of zkEVMs is their opcodes—low-level machine instructions that play a vital role in executing smart contracts efficiently.

What Are zkEVM Opcodes?

At its core, zkEVM opcodes are the low-level instructions that zkEVMs use to execute programs in an EVM-compatible environment. Similar to the regular Ethereum Virtual Machine (EVM), contracts written in high-level languages (like Solidity) need to be compiled into bytecode, which specifies the opcodes used when the program is deployed.

However, unlike standard EVM opcodes, zkEVM opcodes are designed specifically to operate efficiently within the constraints of zero-knowledge proof systems. This distinction is essential for ensuring that the performance and security benefits of zk-rollups can be realized without compromising on functionality.

Why Do We Need zkEVM Opcodes?

Regular EVM opcodes are not optimal for zero-knowledge proving circuits due to their inherent complexity and inefficiency. As zkEVMs aim to validate transactions off-chain while ensuring security on-chain, the design of their opcodes must cater to this unique requirement.

The Need for Efficiency

In a zk-rollup, the goal is to minimize the computational overhead while maximizing the speed of transaction verification. Efficient opcodes help in achieving this by ensuring that the proofs generated for state transitions are succinct and verifiable without unnecessary overhead.

Approaches to Creating zkEVM Opcodes

There are primarily two approaches to implementing zkEVM opcodes:

Building ZK Circuits for Native EVM Opcodes

This approach involves creating zero-knowledge circuits that represent the native EVM opcodes. Here’s a closer look at how this works:

  • Implementation: Developers must implement all EVM instruction sets within an arithmetic circuit, a process that can be complex and time-consuming.
  • Benefits: The primary advantage of this approach is that developers can utilize existing blockchain development tools and easily port existing Ethereum contracts to zk-rollups with minimal modifications. This compatibility fosters a smoother transition for developers who are already familiar with the EVM ecosystem.

Creating New Languages for ZK Proof Computation

The second approach focuses on designing new programming languages tailored for zero-knowledge proof computation:

  • Custom Opcode Development: This method requires the development of custom opcodes that can efficiently handle validity proofs.
  • Direct Writing or Compilation: Developers can either write smart contracts directly in this new language or compile their Solidity source code into the custom zkEVM opcodes.

While this approach can be simpler to implement, it comes with its own set of challenges. For instance, developers may lose access to existing Ethereum infrastructure and tools, making it harder to leverage the rich ecosystem that Ethereum currently offers.

The Trade-offs

Both approaches have their pros and cons. Building ZK circuits for native EVM opcodes may offer better integration with existing tools but can be labor-intensive. Conversely, creating new languages can streamline development but may alienate developers from the established Ethereum ecosystem.

References

  1. Vitalik Buterin. (2021, January 05). An Incomplete Guide to Rollups. Retrieved from https://vitalik.eth.limo/general/2021/01/05/rollup.html
  2. Zero-knowledge rollups. Ethereum. Retrieved from: https://ethereum.org/en/developers/docs/scaling/zk-rollups/
  3. Ye Zhang@Scroll. (2022, March 15). zkEVM. Retrieved from: https://hackmd.io/@yezhang/S1_KMMbGt
  4. Alchemy. (2022, June 21). What is a zkEVM? Retrieved from: https://www.alchemy.com/overviews/zkevm

Connect with Me

Connect with me on Facebook, LinkedIn, via email at dangduongminhnhat2003@gmail.com, GitHub, or by phone at +84829258815.

zkRollups  zkEVM  Ethereum  Blockchain  Zero-Knowledge Proofs