Exclusive interview with Polygon zkEVM: One Token is Enough for MATIC

Exclusive interview with Polygon zkEVM: One token sufficient for MATIC

Polygon PoS and Polygon zkEVM will eventually merge together, making it highly scalable.

Interview: Jack, BlockBeats

Compile: Laughing, BlockBeats

It seems that since the EDCON in Montenegro, ZK has become a topic that everyone is discussing. In fact, 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 expectation of “ZK airdrop” has also been pushed to a new high. In addition to zkSync and Starknet, Scroll, Linea and other zkEVM projects have also become the focus of “wool party”.

However, interestingly, although the bearish expectations of the ZK track are unprecedentedly high, most people still have relatively vague concepts of the subdivisions of this field. ZK Rollup, zkEVM, zk-SNARK, zk-STARK, etc., each seems important, but none of them is too clear. It must be admitted that the strong technical nature of the ZK track has indeed added a lot of difficulty for many people to understand this field.

Polygon, as the earliest team to invest in ZK expansion development, has undergone multiple iterations of its own products, and has a deep understanding and insight into ZK Rollup, and Polygon zkEVM is also one of the few zkEVMs that have been launched. Therefore, BlockBeats recently interviewed Jordi Baylina, the technical leader of Polygon zkEVM, and asked this “tech geek” about the development status, opportunities, and future prospects of the ZK track.

About ZK Rollup and zkEVM

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

Jordi Baylina: From the user’s point of view, 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 withdraw the money. If you want to keep the funds there, the problem is not that big. But when your funds are in multiple Rollup systems, the problem becomes more complicated, and the funds are difficult to transfer. When you want to transfer 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 the verification proof. Currently, on Polygon zkEVM, this time is about an hour, but it can be as short as 30 seconds. And 30 seconds is a big difference from two weeks. 30 seconds actually allows you to trade on another Rollup and then come back to the same Rollup. So if you want your funds to be connected to the world and you can transfer funds here, there is higher availability. I mean, you won’t get stuck in a situation where your funds cannot be transferred, and that’s important.

BlockBeats: What are the differences between Polygon zkEVM and other ZK Rollups like Starknet and zkSync?

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

BlockBeats: There is a common view in the community that “ZK and EVM are not compatible”. Why is this view?

Jordi Baylina: When EVM was originally designed, ZK proof was not taken into account. The design of EVM was completed around 2014-2015, while the related ZK proof concept appeared around 2018-2019. Therefore, the factor of ZK proof was not considered when designing EVM. But in Polygon, we successfully built zkEVM through our own design, that is, we built a proof system, a zkProver (zero-knowledge proof generator) that can verify any Ethereum transaction.

It can be verified in the same way as any Ethereum client, which means that we have achieved full compatibility with Ethereum. Therefore, 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 the developer’s point of view, they will hardly feel any difference except for the differences in gas prices and throughput.

BlockBeats: Polygon itself is already an EVM-compatible sidechain, why does it need to build 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 yet connected. Polygon PoS is a Layer 1 sidechain, just like Gnosis, Avalanche, or other Layer 1 sidechains. Polygon zkEVM is a ZK Rollup, which is also an EVM and is compatible with Ethereum. Eventually, you will see them merged together, and it will be very scalable.

Actually, this is exactly what Polygon has been working on, so we created PoS, which can be a better scaling Layer 1. But all Layer 1s have some limitations, which are the consensus mechanisms. You can compromise a little bit on security, but you cannot have the same level of security as Ethereum at the same time. Polygon PoS is a trade-off that offers very fast and cheap transactions, with some compromise on security, but it doesn’t mean it’s not secure, it just doesn’t have the same level of security and decentralization as Ethereum. There are different balances in this “impossible triangle”, and for many applications, this may be enough. But for a Layer 1, there are always some limitations on the consensus layer.

The real blockchain scaling needs to be achieved through Layer 2 technology, so Polygon has invested heavily in building Layer 2 technology, specifically ZK Rollup technology. Of course, we have done Supernets in the scaling attempt of Polygon PoS, but this is a way of developing in the Layer 1 ecosystem. For the overall blockchain scaling, Polygon is indeed very focused on ZK Rollups.

BlockBeats: Many ZK Rollups use zk-SNARK, but Polygon zkEVM combines zk-SNARK and zk-STARK. There has been a lot of discussion recently about the two, how do you see zk-SNARK and STARK?

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

BlockBeats note: In mathematics, a “small prime field” is a finite field (also called a finite prime field or Galois field) characterized by a small prime number. In this field, all operations are performed modulo this prime number. Small prime fields are frequently used in cryptography and coding theory, because they have some important properties, such as good grouping effects and reversibility.

BlockBeats: In the field of ZK Rollup, it seems that everyone is striving to achieve EVM compatibility or even equivalence, but Starknet, as the leader, is not EVM compatible.

Jordi Baylina: You can say that Starknet is Ethereum’s Layer 2, because they are built on top of Ethereum. But in reality, one difference is whether it is compatible and equivalent with Ethereum, and Starknet is not. If you connect MetaMask directly to this port and start using it, it is equivalent. Or you can use Remix to create a smart contract and deploy it in it, and it should run exactly like Ethereum.

But Starknet uses a different language and is compared to different things, like a different chain. You can’t generate a smart contract on Remix (Ethereum development environment) and then deploy it on Cairo, you need to use their own tools.

BlockBeats: What do you think of the technical implementation path of projects like the zkEVM project Kakarot, which chooses to build a zkEVM on top of Starknet? What are the differences from Polygon zkEVM at the technical level?

Jordi Baylina: For the Kakarot team, they are trying to achieve compatibility with Ethereum, but in order to achieve this goal, the speed of their technology stack is a bit slow. Although the specific situation still needs further observation, I think their efficiency may not be very high. The current problem is that this project is very dependent on the way zkEVM is built. And Kakarot is built on Cairo, which is relatively slow, and the EVM is very complicated, 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 very small.

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

BlockBeats: So will Polygon zkEVM use Solidity for development from the beginning?

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

About OP Rollup and zkEVM Track

BlockBeats: A year or two ago, people still thought that OP Rollups were the mainstream solution for scaling in the short term. However, now, several mainstream ZK Rollups have launched on the mainnet. Do you think OP Rollups still have significant value for Ethereum scaling?

Jordi Baylina: OP Rollups are a good solution when ZK Rollups are not yet fully ready. But now that ZK Rollups are ready, I don’t think there is much point in using OP Rollups. Two years ago, when zkEVM was still under construction, it was thought to take about five years of work, so OP Rollups might have been a very reasonable choice during those five years. But after only two years, zkEVM has made good progress, and we achieved that goal ahead of schedule.

One major difference between OP Rollups, Starknet, and Polygon zkEVM is that Polygon zkEVM is the only zkEVM that has been truly implemented and is fully compatible with Ethereum. zkSync is compatible at the Solidity level, but you need to use specific tools to compile, and it is not EVM. And Starnet is not compatible with Ethereum.

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

Jordi Baylina: The most important thing is the combined effect of all the tools and technologies when we put them all together. This is an engineering process, like putting many known parts together. We have shown that this is possible to some extent, and we have overcome many challenges in the process.

For example, in terms of proof time and data center required for computing proofs, we initially needed several hours. Now, building a proof on a large machine takes only one minute. So you can see the progress made in the last two years. This is not a single factor, as I said before, such as our transition from large prime fields to small prime fields, we adopted STARKS, accelerated the hash functions used in them, learned how to do arithmetic, and how to efficiently implement keccak256 in circuits. We created a very good architecture that allows different teams to work in parallel. We have restriction layers, cryptographic layers, and ROM (read-only memory) layers, which are actually implementing the test layer. These different layers allow us to work efficiently in parallel, which is why we can build this system quickly.

BlockBeats: But many voices from the community are still complaining that it takes a long time to transfer assets between Ethereum and Layer 2, or to interact on Layer 2, and gas fees are not much cheaper. Why is this?

Jordi Baylina: As far as transferring assets between L1 and L2 on Ethereum’s zkEVM is concerned, this is not the case. It requires two layers of processing from Layer 1 to Layer 2. Therefore, you need to complete the transaction in Layer 1 to make it finally confirmed, which takes about 12 minutes.

I think there is no reason other than they did not perform the operation correctly. Currently, it takes 12 minutes to deposit funds in Polygon zkEVM, and we generate a proof every 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 that it will take no more than one hour, and it may be shorter.

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

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

BlockBeats: Currently, the competition in the zkEVM field is fierce. Polygon zkEVM, Consensys, and Scroll are all vying for L2 users, and 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 a lot in common with us, Scroll is a zkEVM, and we are also a zkEVM. But zkSync is not, it is a zkSolidity, and it does not have EVM in the technical implementation process. And Starknet is not even EVM, it is more like a sidechain. But this does not mean that they are good or bad, they are different things.

zkEVM is an implementation of the EVM, which means you can use zero-knowledge proof EVM. This is interchangeable, meaning you should be able to use it in the same way as Ethereum. In the field of zkEVM, we will discuss Scroll, Consensys (Linea), and Polygon zkEVM. They can be said to be the most advanced three zkEVM projects currently available, each with its own advantages and disadvantages. Of course, there is also Taiko, but that is a Type 1 zkEVM.

Among them, Consensys focuses more on architectural design to make end users feel no different from the EVM. Of course, their mainnet is not yet online, so we need to observe their actual performance after the mainnet is launched. But from the user’s perspective, there should not be too much difference.

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

I think Consensys architecture is very similar to Polygon zkEVM, both of which are very concerned about state, and the difference between them is in the cryptographic part. I think their lattice-based scheme is very interesting, and we can pay attention to their implementation method, which may be an advantage. But from the perspective of architecture, we are very similar. Scroll is somewhat different, with less hierarchical structure and more simplification and cohesion.

BlockBeats note: In cryptography, lattice-based cryptography is a branch of cryptography based on lattice theory, which uses the mathematical properties of lattices to construct secure cryptographic systems. A lattice is a collection of linearly independent vectors in a multi-dimensional vector space. Lattice-based cryptography takes advantage of the difficulty of lattice problems, with the most famous problems being the Shortest Vector Problem (SVP) and the Closest Vector Problem (CVP). These problems are usually difficult to solve in high-dimensional space, even with modern computers requiring huge computing resources and time. Compared with traditional number-theoretic or elliptic curve-based cryptography, lattice-based cryptography has certain advantages in resisting quantum computing attacks. Since there is currently no known efficient quantum algorithm to solve lattice problems, lattice-based cryptography is considered a feasible choice for resisting 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 such as Scroll. What topics do you mainly discuss in your communication? 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, 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 opinion, we are not competing, at least not at the technical level, and we are also trying to avoid competition, which is what I talked about at the round table. We are not competing with anyone, but pursuing a cooperative attitude. This is a very complex technology, you have to put yourself at a higher level. I have learned a lot from others, and I have also imparted knowledge to others. This is the way we move forward. Of course, there may be competition in the product level, market promotion, and adjustment, but it is not a bad thing for users.

About ZK acceleration

BlockBeats: Does zkEVM also need a sorter?

Jordi Baylina: Currently, zkEVM uses a centralized sorter. Like other sidechains, sidechains require sorters, which can be centralized or decentralized. Currently, most sidechains use centralized sorters, but they also plan to build decentralized sorters. There is a mechanism called “Proof of Efficiency” in Polygon, but it is currently a centralized sorter, and we are working hard to find a better solution.

BlockBeats: Will you launch a new Token to make the sorter decentralized?

Jordi Baylina: We already have a token, which is MATIC, and 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, or for decentralized sorters, and so on. It is very useful in many ways and will be a very important token for maintaining this infrastructure.

BlockBeats: How long does it take for the sorter to become fully decentralized?

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

BlockBeats: Also, many people are researching the opportunity for “ZK mining”. What’s your take on this?

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

BlockBeats: So there is indeed an opportunity here?

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

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

Jordi Baylina: ZK will be a core part, and we see a Layer 2 ecosystem based on ZK, where many side chains can interact with each other. I am not worried about proof generators, Ethereum supervision and other issues. I am more concerned about the sorter, and we need a decentralized sorter.