Dialogue Polygon zkEVM: MATIC One Token is Enough

Interview: Jack, BlockBeats

Compiled by: Laughing, BlockBeats

It seems that since the Montenegro EDCON, ZK has become the topic everyone is discussing. However, in reality, the heat of the ZK track has not diminished since the Arbitrum airdrop at the beginning of the year. With the launch of zkSync Era, the expectations for "ZK airdrops" have reached new heights. In addition to zkSync and Starknet, zkEVM projects like Scroll and Linea have also become key targets for "yield farmers."

Interestingly, despite the unprecedented high expectations for ZK track airdrops, most people still have a relatively vague understanding of the sub-concepts in this field. ZK Rollup, zkEVM, zk-SNARK, zk-STARK, etc., each seems important, yet few truly understand them. It must be acknowledged that the strong technical nature of the ZK track indeed adds considerable difficulty for many to grasp this field.

As one of the earliest teams to invest in ZK scaling development, Polygon has undergone multiple iterations of its products and has a deep understanding and insight into ZK Rollup. Polygon zkEVM is also one of the few zkEVMs that have been launched. Therefore, BlockBeats recently interviewed Jordi Baylina, the technical lead of Polygon zkEVM, to discuss the current state of development in the ZK track, opportunities, and the future outlook of Polygon zkEVM.

About ZK Rollup and zkEVM

BlockBeats: First of all, Jordi, could you briefly explain the difference between ZK Rollups and zkEVM to our readers? And why do we need an EVM verified by ZK?

Jordi Baylina: From the user's perspective, the biggest difference between OP Rollups and ZK Rollups is the time required to withdraw funds. For example, when you deposit 1 ETH into Optimism or Arbitrum, it takes at least a week to get that money back. If you want to leave your funds there, it's not a big deal. But when your funds are in multiple Rollup systems, it becomes more complicated, and transferring funds can be difficult. When you want to move funds to another Rollup, it also takes a week or two. This is the biggest problem faced by OP Rollups.

In the case of ZK Rollup, you can exit the Rollup after generating a verification proof. Currently, on Polygon zkEVM, this time is about one hour, but it can be as short as 30 seconds. And 30 seconds versus two weeks is a significant difference. Thirty seconds actually allows you to transact on another Rollup and then return to the same Rollup. So if you want your funds to connect with the world and you can transfer funds here, it has higher availability. I mean, you won't get stuck in a situation where your funds cannot be transferred, which is important.

BlockBeats: How does Polygon zkEVM differ from other ZK Rollups like Starknet and zkSync?

Jordi Baylina: The biggest difference with Polygon zkEVM is that it is an EVM, which means it is fully compatible with Ethereum. Users just need to connect MetaMask to do the same things they can do on Ethereum. You can deploy smart contracts, interact with smart contracts, create tokens, transfer funds, create multi-signatures, and whatever you want to do without any special tools; you just use the same tools available on Ethereum, such as MetaMask, etherscan, HardHat, etc. All tools available for Ethereum can be used, and you don't need any specific other tools.

BlockBeats: There is a common viewpoint in the community that "ZK and EVM are incompatible." Why is that?

Jordi Baylina: The EVM was not originally designed with ZK proofs in mind. The design of the EVM was completed around 2014-2015, while the relevant concepts of ZK proofs emerged around 2018-2019, so ZK proofs were not considered during the design of the EVM. However, at Polygon, we successfully built zkEVM through our own design, which means we built a proof system, a zkProver (zero-knowledge proof generator) that can verify any Ethereum transaction.

It can verify in the same way as any Ethereum client, which means we have achieved full compatibility with Ethereum. So if you know how to develop on Ethereum, you should also know how to develop on zkEVM. You don't need anything else special. From a developer's perspective, they will hardly feel any difference, except for differences in gas prices and throughput.

BlockBeats: Polygon itself is already an EVM-compatible sidechain. Why is it building another Layer 2 scaling solution?

Jordi Baylina: Polygon has two parts. One is Polygon PoS, which is the original Polygon network, and the other is Polygon zkEVM. They are two independent networks that are not currently connected. Polygon PoS is a Layer 1 sidechain, similar to Gnosis, Avalanche, or other Layer 1 sidechains. Polygon zkEVM is a ZK Rollup and also an EVM that is compatible with Ethereum. Ultimately, you will see them merge together, which will be highly scalable.

In fact, this is precisely the direction Polygon has been striving for, which is why we created PoS to become a better scaling Layer 1. But all Layer 1s have some limitations, namely the consensus mechanism. You can compromise a bit on security, but you cannot achieve the same level of security and decentralization as Ethereum at the same time. Polygon PoS is a trade-off that can provide very fast and cheap transactions, with some compromises on security, but that does not mean it is insecure; it just does not have the same level of security and decentralization as Ethereum. There exists different balances in this "impossible triangle," which may be sufficient for many applications. But for a Layer 1, the consensus layer always has some limitations.

Real blockchain scalability needs to be achieved through Layer 2 technology, which is why Polygon has invested heavily in building Layer 2 technology, specifically ZK Rollup technology. Of course, we have attempted Supernets in the scaling efforts of Polygon PoS, but that is a way of developing within the Layer 1 ecosystem. For the overall scalability of blockchain, Polygon is indeed very focused on ZK Rollups.

BlockBeats: Many ZK Rollups have adopted zk-SNARK, but Polygon zkEVM combines both zk-SNARK and zk-STARK. There has been a lot of recent discussion about the two; what is your view on zk-SNARK and STARK?

Jordi Baylina: Currently, STARK is the fastest proof system we know of. Additionally, an important factor is that it is very easy to achieve full recursion on top of STARKs. This allows us to aggregate many blocks in a single transaction, which is very convenient. Moreover, we use something different from StarWare, which we call small prime field STARK, which is even 10 times faster than regular STARK.

Note from BlockBeats: In mathematics, "small prime field" refers to a finite field characterized by a small prime number (also known as a finite prime field or Galois field). In this field, all operations are performed modulo this prime number. Small prime fields are often used in areas such as cryptography and coding theory because they have important properties, such as good grouping effects and reversibility.

BlockBeats: In the ZK Rollup field, it seems everyone is striving for EVM compatibility or equivalence, but the leading Starknet is not EVM compatible.

Jordi Baylina: You could say Starknet is a Layer 2 for Ethereum because it is built on top of Ethereum. However, a distinction lies in whether it is compatible and equivalent to Ethereum, and Starknet is not compatible. If you directly connect MetaMask to this port and start using it, it is equivalent. Or you can use Remix to create a smart contract and deploy it there; it should run exactly like it does on Ethereum.

But Starknet uses a different language and compares itself to different things, like a different chain. You cannot go to Remix (the Ethereum development environment) to generate a smart contract and then deploy it on Cairo; you need to use their own tools.

BlockBeats: Projects like Kakarot choose to build a zkEVM on top of Starknet. What do you think of this technical implementation path? How does it differ from Polygon zkEVM on a technical level?

Jordi Baylina: For the Kakarot team, they are trying to achieve compatibility with Ethereum, but the technology stack they are using to achieve this goal is somewhat slow. While the specifics need further observation, I think their efficiency may not be very high. The current issue is that this project heavily relies on the way zkEVM is built. Kakarot is built on Cairo, which is relatively slow, and EVM is very complex, so building on top of Cairo will be very inefficient. This is a two-layer technology stack; maybe it can work, but I think the scale will be small.

Instead of using a general-purpose virtual machine like Cairo, we built a custom virtual machine. It's like building a dedicated processor for executing a specific program. We customized the virtual machine instead of using the Cairo language. This virtual machine is specifically designed for building zkEVM, just like designing a computer that can only run a single program.

BlockBeats: So Polygon zkEVM was designed to use Solidity from the start?

Jordi Baylina: Polygon uses EVM, so it uses the same underlying technology as Ethereum. This means you can develop using Solidity, and once you develop in Solidity, you can deploy not only on Ethereum but also on zkEVM because they use the same processor, which is the Ethereum Virtual Machine. StarkNet uses Cairo, which does not simply use EVM.

About OP Rollup and zkEVM Track

BlockBeats: A year or two ago, everyone thought OP Rollups were the mainstream solution for scaling in the short term. But now, several mainstream ZK Rollups have successively launched their mainnets. Do you think OP Rollups still hold significant value for Ethereum scaling?

Jordi Baylina: OP Rollups were a good solution when ZK Rollups were not fully ready. But now that ZK Rollups are ready, I think there is not much point in using OP Rollups anymore. Two years ago, when zkEVM was still being built, everyone thought it would take about five years of work, so OP Rollups might have been a very reasonable choice during those five years. But just two years later, zkEVM has made great progress, and we have reached that goal ahead of schedule.

Comparing OP Rollups, Starknet, and Polygon zkEVM, one major difference is that Polygon zkEVM is the only one that has truly implemented zkEVM and is fully compatible with Ethereum. zkSync is compatible at the Solidity level, but you need to use specific tools to compile it; it is not EVM. Starknet, on the other hand, is not compatible with Ethereum.

BlockBeats: In your opinion, what key factors have accelerated the development of ZK Rollups?

Jordi Baylina: The main factor is that when we combine all the tools and technologies together, their synergy plays a crucial role. This is an engineering process, like putting together many known parts. We have proven that this is possible to some extent and have solved many challenges along the way.

For example, in terms of proof time and the data centers needed to compute proofs, we initially needed hours. Now, generating a proof on a large machine only takes a minute. So you can see the progress made in these two years. This is not a single factor; as I mentioned earlier, for instance, we shifted from large prime fields to small prime fields, adopted STARKS, accelerated the hash functions used in them, and learned how to perform arithmetic processing and implement keccak256 efficiently in circuits. We created a very good architecture that allows different teams to work in parallel. We have layers for restrictions, cryptography, and ROM (Read-Only Memory), which effectively implement the testing layer. These different layers enable us to work efficiently in parallel, which is why we can quickly build this system.

BlockBeats: However, many voices from the community still complain that transferring assets between Ethereum and Layer 2, or interacting on Layer 2, takes a long time, and gas fees are not significantly cheaper. Why is that?

Jordi Baylina: When it comes to transferring assets between L1 and L2, the situation in Ethereum's zkEVM is not like that. From Layer 1 to Layer 2, it requires processing through two layers. Therefore, you need to complete a transaction on Layer 1 for it to be finalized, which takes about 12 minutes.

I think there is no other reason except that they are not executing the operations correctly. Currently, depositing funds in Polygon zkEVM takes 12 minutes, and we generate one proof per hour to withdraw funds, so the entire process should not exceed one and a half hours, even though this may fluctuate. That is to say, we know it will take at most one hour, and it may be shorter.

The current gas fee is 10% of Layer 1 gas fees because we need to pay for data availability. But I can tell you that in about six months, at the beginning of next year, we plan to increase it again, adding 50 times on top of the existing 10 times. This 50 times increase mainly comes from data compression, which is an area we are currently researching. The other 10 times comes from EIP-4844.

Note from BlockBeats: EIP-4844 (also known as the proto-danksharding proposal) was co-created by Vitalik Buterin and other programmers from the Ethereum ecosystem. The main goal of EIP-4844 is to reduce gas fees on the network without sacrificing decentralization, especially for Rollup solutions. Rollup solutions like Arbitrum and Optimism can reduce gas fees by 100 to 1000 times.

BlockBeats: Currently, the competition in the zkEVM track is very fierce. Polygon zkEVM, Consensys, and Scroll are all vying for L2 users, while many users still cannot distinguish between them and Starknet and zkSync. In your opinion, what are the similarities and differences between Polygon zkEVM and other zkEVM projects?

Jordi Baylina: Scroll has many similarities with us; Scroll is a zkEVM, and so are we. zkSync, however, is not; it is a zkSolidity, and it does not have EVM in its technical implementation. Starknet is not even EVM; it is more like a sidechain. But that does not mean there is a good or bad distinction; they are different things.

zkEVM is one that implements EVM, meaning you can use zero-knowledge proof EVM. This is interchangeable, meaning you should be able to use it in exactly the same way as Ethereum. In the zkEVM space, we are discussing Scroll, Consensys (Linea), and Polygon zkEVM, which can be said to be the three most advanced zkEVM projects currently, each with its strengths and weaknesses. Of course, there is also Taiko, but that is a Type 1 zkEVM.

Among them, Consensys focuses more on architectural design to make the end-user feel no difference from EVM. Of course, they have not launched their mainnet yet, so we will need to wait to observe its actual performance once the mainnet is live. But from the user's perspective, there should not be too much difference.

Comparison of mainstream ZK Rollups and zkEVM technical architectures, image source: Dewhales Research (Note: Polygon Hermez is the current Polygon zkEVM)

I think the architecture of Consensys is very similar to Polygon zkEVM, both focusing heavily on state, with the difference lying in the cryptographic part. I find their lattice-based solution interesting, and we can pay attention to their implementation; perhaps this is an advantage. But from an architectural perspective, we are very similar. Scroll is somewhat different; it does not have as many layers; it is more streamlined and cohesive.

Note from BlockBeats: In cryptography, lattice-based cryptography is a branch of cryptography based on lattice theory, utilizing the mathematical properties of lattice structures to construct secure cryptographic systems. A lattice is a set of linearly independent vectors in a multidimensional vector space. Lattice-based cryptography leverages the difficulty of solving lattice problems, the most famous of which are the Shortest Vector Problem (SVP) and the Closest Vector Problem (CVP). These problems are typically hard to solve in high-dimensional spaces, requiring enormous computational resources and time even with modern computers. Compared to traditional number-theoretic or elliptic curve-based cryptography, lattice-based cryptography has certain advantages in resisting quantum computing attacks. Since there are currently no known efficient quantum algorithms to solve lattice problems, lattice-based cryptography is seen as a viable option against quantum computing attacks and is widely researched and applied.

BlockBeats: You mentioned in your EDCON speech that the Polygon zkEVM team often communicates with "rival teams" like Scroll. What topics do you mainly discuss? How do you view the competitive relationship between each other?

Jordi Baylina: We usually discuss very technical topics. For example, how your project handles transactions, how to sort them, how to implement this specific code, how to solve this problem, how to solve that problem; we share a lot of insights on these topics.

In my view, we are not competing; to be precise, at least not in a competitive relationship on a technical level, and we are also trying to avoid competition, which is what I talked about in the panel. We are not competing with anyone; rather, we pursue a collaborative attitude. This is a very complex technology, and you need to elevate yourself to a higher level. I have learned a lot from others while also imparting knowledge to others; this is how we move forward. Of course, there may be competition at the product level, marketing, and adjustments, but for users, this is not necessarily a bad thing.

About ZK Acceleration

BlockBeats: Does zkEVM also require a sequencer?

Jordi Baylina: Currently, zkEVM uses a centralized sequencer. Like other sidechains, sidechains need sequencers, and the sequencer can be centralized or decentralized. Most sidechains currently use centralized sequencers, but they all plan to build decentralized sequencers. In Polygon, there is a mechanism called "Proof of Efficiency," but currently, it is a centralized sequencer, and we are working hard to find better solutions.

BlockBeats: To decentralize the sequencer, will you launch a new token?

Jordi Baylina: We already have a token, which is MATIC; there is no need to launch a new token. We already have an excellent, powerful, and valuable token. This token can be used for the consensus layer, such as Polygon PoS, and can also be used for decentralized sequencers, etc. It is very useful in many ways and will be a very important token for maintaining this infrastructure.

BlockBeats: How long do you think it will take for the sequencer to become fully decentralized?

Jordi Baylina: I am not responsible for this part at Polygon; there are other teams working on this issue. I hope it can be achieved as soon as possible, but I am not sure; it may take six months to a year. This will not be a quick process; I don't think it will be achieved next month. But at least there is a complete team at Polygon dedicated to developing in this direction.

BlockBeats: Additionally, many people are researching the opportunities of "ZK mining." What is your view on this matter?

Jordi Baylina: Currently, proof generators are very centralized, but in the future, decentralized proof generators will be realized. This is possible. It may take some time, but it will happen. Specifically, there are two things that need to be decentralized: one is sorting, and the other is verification; both processes need to be decentralized, with sorting being key. The proof generator is just a machine for computation, nothing more.

BlockBeats: So there are indeed opportunities here?

Jordi Baylina: Yes, absolutely. Although it is not the right time yet, there will be opportunities in the future.

BlockBeats: Finally, how does Polygon as a whole view zkEVM?

Jordi Baylina: ZK will be a core part; we see a ZK-based Layer 2 ecosystem where many sidechains can interact with each other. I am not worried about issues related to proof generators or Ethereum regulation. I am more concerned about the sequencer; we need a decentralized sequencer.