The zkWars are heating up. With 3 different teams recently announcing their zkEVM, we’re joined by Alex Gluchowski of zkSync and Ye Zhang of Scroll.
Optimism’s Ben Jones cohosts as we explore why zkEVM is such a big deal, the respective roadmaps to mainnet, and of course… wen token?
------ 📣 Forta | Help Make Web3 a Safer Place https://bankless.cc/Forta
------ 🚀 SUBSCRIBE TO NEWSLETTER: https://newsletter.banklesshq.com/ 🎙️ SUBSCRIBE TO PODCAST: http://podcast.banklesshq.com/
------ BANKLESS SPONSOR TOOLS:
🚀 ROCKET POOL | ETH STAKING https://bankless.cc/RocketPool
⚖️ ARBITRUM | SCALING ETHEREUM https://bankless.cc/Arbitrum
❎ ACROSS | BRIDGE TO LAYER 2 https://bankless.cc/Across
🦁 BRAVE | THE BROWSER NATIVE WALLET https://bankless.cc/Brave
🌴 MAKER DAO | DECENTRALIZED LENDING https://bankless.cc/MakerDAO
🔐 LEDGER | SECURE STAKING https://bankless.cc/Ledger
------ Topics Covered:
0:00 Intro 3:15 Crypto 101 10:00 Alex and Ye 13:25 zkSync 18:20 Scroll 22:30 What's Different about zkSync 31:10 What's Different about Scroll 37:15 zkProof Performance 41:30 Decentralizing Provers 46:30 Approaching Developers 57:07 Challenges to Upgrading 1:03:40 Vibe Check 1:09:20 Centralized Keys 1:17:45 Closing
------ Resources:
Ben Jones https://twitter.com/ben_chain
Alex Gluchowski https://twitter.com/gluk64
Ye Zhang https://twitter.com/yezhang1998
----- Not financial or tax advice. This channel is strictly educational and is not investment advice or a solicitation to buy or sell any assets or to make any financial decisions. This video is not tax advice. Talk to your accountant. Do your own research.
Disclosure. From time-to-time I may add links in this newsletter to products I use. I may receive commission if you make a purchase through one of these links. Additionally, the Bankless writers hold crypto assets. See our investment disclosures here: https://newsletter.banklesshq.com/p/bankless-disclosures
No summary for this episode yet.
Hey, Bankless Nation. Welcome to another live edition of State of the Nation. Today, we're going to talk about the Zero Knowledge EVM, the ZK EVM. David, guide us through. This is going to be formatted a little bit differently in that after the intro, I am actually stepping out. So who do we have on the show? How are we formatting this and who is helping us out today? We've got my good friend Ben Jones from Optimism. Ben is going to be our technical co-moderator here to help us unpack the ZK EVM. Ryan, you and I, I think we're pretty smart, but there's way smarter people in this industry and there's way more technical things in this industry that we just kind of need some help unpacking.
We're bringing in some extra help from the optimistic roll-up world to help us unpack the ZK side of things. So coming in in the second half of the show, once we get there, we'll have Alex from ZK Sync and Ye from Scroll. And Ben is going to help us guide us through this conversation to understand a little bit more about the world of the ZK. It's a world that's heating up. I think the title of this episode is the ZK EVM Wars. And I think, you know, appropriately, it was like three weeks ago, all three ZK EVMs announced something big the exact same week. So the ZK Wars are heating up. David, also got to tell them a little bit about our friends at Forta.
And I think this is really important that we talk about tools like Forta right now. Because since, did you know, since 2021, 138 Web3 projects have been hacked. And that's cost victims a total of $2.3 billion. And of course, yesterday, David, we just saw the latest bridge hack, $190 million out of the Nomad Bridge. and so we reset the clock. Now it's been zero days since the last incident. Tell us a little bit about how Florida is trying to fix this. Yeah, we can all do our best with smart contract audits and formal verification and blah, blah, blah, blah, blah. And everyone should be doing that.
But you can also do an additional layer of protection, which is real-time mempool monitoring. And so the way I like to explain this is there's that game in the 90s where asteroids were coming in and you would shoot the asteroids before they hit the Earth. this is like that but like smart contract exploits so you like zap the malicious transactions before they actually execute uh and this is what ford provides for the world real-time monitoring of your defi app your nft project your dow your treasury anything that's at risk that's in the world of ethereum uh this is a a missile defense system for your smart that's a cool analogy david look what they're projecting here 36 billion dollars compound balancer liquidity instap maker lido all of these folks use ford so if you want to learn more go check it out the ford network at ford.
org there's a link in the show notes bankless.cc slash afforda all right i'm going to ask you the question i ask before every state of the nation before we get there ryan i want to talk about a little bit about just some intro stuff uh because we've got okay and so uh before there's gonna be a bunch of questions that i think we don't actually necessarily have to uh ask every single participant here in this stream. So we're going to get some beginner questions out of the way. And Ben's going to help us with that here. So Ben, I want to start with this very first question, which is, what is the EVM and why is it important?
And then we'll get to what does it mean to zero knowledge EVM? Oh, good question. And thanks for having me on, y'all. OK, what is the EVM? What the heck does that mean? Okay, basically, it is a way to interpret Ethereum programs or Ethereum smart contracts. So basically, a virtual machine is this notion that you map a bunch of basically numbers, right? Everything in a computer is expressed as a number. And you map certain numbers to certain instructions. Instruction like add or like divide or like call when you want to go and call another smart contract. This is the basis for how you construct smart contracts on Ethereum.
Here in virtual. write some solidity code happens behind the scenes is that's taken from text onto goes through something called the compiler that turns into a bunch of numbers which is all the instructions that implement the program that you write that's the evm very important i would say crucially important it is one of the things that makes ethereum ethereum okay and so we have that that's what the ethereum layer one is uh what does it mean for to have a zk evm why are so many people hyped on a ZK? Yes. So I think they're hyped for scalability. It's very interesting because ZK EVM, right, what is the ZK there?
It's zero knowledge, right? And interestingly, it does use these things called zero knowledge proofs. Arguably, ZK isn't the most important part of the zero knowledge proof, right? So when you think of a ZK SNARK, right, might be this zero knowledge, succinct non-interactive argument of knowledge. A really key letter in that acronym is the S, is the succinct. Because the point of these proofs is that you can basically prove something in a very short manner. So a ZK EVM is about taking the EVM and converting it or running it inside a zero knowledge environment that lets you prove things succinctly.
So what does that mean? Basically, it means you can take the EVM and you can write a proof that says the result of these 10 transactions is state x, state y. You prove the results of the Ethereum virtual machine. But what's interesting about this is you could make that not 10 transactions, but 100 or 1,000, and still the proof size stays the same. So you can see why this might be very compelling. Can I just bake this down into kind of layman's language here? So the EVM thing, that's the thing that turns Ethereum from a calculator into a computer. And the EVM thing is the thing that Bitcoin does not have, and the reason it functions more like a calculator.
You can't run programs on top of it, right? And then the ZK part makes the EVM thing, the computer part of Ethereum, much more scalable because it compresses it into this very tiny size. Yeah, I think that's a good way of thinking about it. There's a little more nuance in terms of like, you know, for example, if you're posting 10 transactions versus 1,000 transactions and you're still rolling those up, right? If we're talking about a ZK pull-up, right? Then there's still some cost there that fundamentally can't be compressed in quite the same way. It can compress quite a bit, but it doesn't disappear.
There's more nuance, but that's absolutely the case. What would you say, why are people so stoked on a ZK EVM? Why is this such an important thing to fight over? Why are there so many teams racing to gain that? Right, yeah. I mean, so there's a few reasons. The core of it, though, is that the EVM is what powers Ethereum, and it's what has all the network. So I'm a co-founder of Optimism, which is an optimistic role of protocol. We spent a lot of time making the optimistic pull-ups work with the EVM. Why did we do that? It's because that's where all the applications and all the developers live.
So to build a good scaling solution, we want to do that. And it's definitely been a limitation of ZK scaling solutions so far that they can't go ahead and take advantage of this. I think people are excited because there's potential with the AVM build on that network. One last question before we get to the panelists. Ben, what are you hoping to get out of this conversation? What should listeners pay attention to listening to this? What are you also hoping to learn here? Good question. So it depends on who the listener is, right? I think that one of the things obvious listeners would be like a user of these protocols, right?
So I think you want to listen to what are the security properties like that you're interacting with? What is the roadmap of this thing that you're interacting with? I think if you're a developer, then really what you want to be thinking about is what does it actually mean to practice application? There's different ways that you can go about implementing. There's different levels of support for different and aspects of the that you'll have access to. And so I think that's two bits of framing. As for what I want personally, oh, man, everything under the sun, really, I feel like, but including those questions.
I'm secretly most excited to hear how we can get into it. that's a whole nother can you guys um also go over so i'm going to be grabbing the popcorn here and just and just watching as a bystander but just throwing throwing my one question in is can you guys talk a little bit about bridges i know that's not um typically like exclusive to zk but it's it's kind of like a roll-up type technology and i'm um i think a lot of people listening are probably increasingly concerned about the security of bridges from one chain to another or from main net to roll up from a main net to an alt L1. So I'd love to hear a bit more about that.
And guys, we're going to get right to the episode. We're talking all about ZK EVMs. But before we do, we want to thank the sponsors that made this episode possible. get even more by running a node. Rocketpool is the only staking provider that allows anyone to permissionlessly join their network of validating Ethereum nodes. Setting up your Rocketpool node is easier than running a node solo and you only need 16 ETH to get started. You get an extra 15% staking commission on the pooled ETH that uses your node to stake. You also get RPL token rewards on top. So if you're bullish e-staking, you can boost your yield by adding your node to the decentralized Rocketpool network, which currently has over 1,000 independent node operators.
It's It's yield farming, but with Ethereum notes. You can get started at rocketpool.net and you can also join the Rocketpool community in their Discord. You can find me hanging out there sometimes in the chat. So I'll see you there. Arbitrum is an Ethereum layer two scaling solution that is going to completely change how we use DeFi and NFTs. Some of the coolest new NFT collections have chosen Arbitrum as their home while DeFi protocols continue to see increased liquidity and usage. You can now bridge straight into Arbitrum for more than 10 different exchanges, including Binance, FTX, Huobi, and Crypto.
com. Once on Arbitrum, you'll enjoy fast transactions with cheap fees, allowing you to explore new frontiers of the crypto universe. New to Arbitrum, for a limited time, you can get Arbitrum NFTs designed by the famous artists Ratwell and Sugoi for joining the Arbitrum Odyssey. The Odyssey is an eight-week-long event where you can play on-chain activities and receive a free NFT as a reward. Find out more by visiting the Discord at discord.gg slash Arbitrum. You can also bridge your assets to Arbitrum at bridge.arbitrum.io and access all of Arbitrum's apps at portal.arbitrum.one in order to experience DeFi and NFTs the way it was always meant to be, fast, cheap, secure, and friction-free.
MakerDAO is the OG DeFi protocol, the first DeFi protocol to ever exist, even before we called it DeFi. MakerDAO produces DAI, the industry's most battle-tested and resilient stablecoin. Using Maker, you don't need to sell your collateral if you need liquidity. Instead, you can spin up a Maker vault and use your collateral to mint DAI directly. With Maker, the power to mint new money is in your hands. And there's something new in the MakerDAO ecosystem. Every time a new MakerDAO is opened, the owner can claim a POAP, which contributes funds to One Tree Planted, an organization with ongoing global reforestation efforts, creating a world where digital participation and the health of our environment can live side by side.
Soon, Maker will be present on all chains and Layer 2s, bringing the biggest and best DeFi credit facility to everywhere there is DeFi. So follow Maker on Twitter, at MakerDAO, and learn from the oldest and most resilient DAO in existence. And we are back. I believe we fixed the audio issues, so chat, make sure, let me know if we have not. In the top right corner, we're talking to Alex Glokowski from the ZK Sync Protocol. Alex, welcome to the show. Cheers. And then in the bottom half in the middle, we got Ye from Scroll. Ye, welcome to the show. So, beautiful. Before we get into some of the technical details of the project, I just want to kind of go through the context or the background, the genesis of each of your guys' respective teams.
Alex, could you kind of just walk us through the history of ZK Sync? Where did it come from? Bitcoin, Ethereum, and all the school. Hang on. Okay. I know this is not audio issues. I just had you guys muted. So we're going to start over again. Okay. In the top right corner, we got Alex Sklokowski from ZK Sync. Alex, welcome to the show. Hello, everyone. Very excited to be here. And then in the bottom half, we got Ye from Skrull. Ye, welcome to Bankless. Hi. Thanks for having me. Okay, third time's the charm. Before we get into some of the technical details, I just want to go around into the background of each of your respective teams just to get a little bit of context about where each one came from.
So, Alex, we'll start with you. Where did ZK Sync come from? What's the genesis story? What's the background? Can you kind of walk us through that? Absolutely. Very happy to. So I'll start with my personal background. You might know that I was born in Soviet Ukraine and I grew up kind of like after the collapse of Soviet Union. And I was very impacted by the thing, the economic and social collapse and all the things that were going there. And it brought me to conclusion that there is nothing more impactful you can do in this world today than increase freedom. increase freedom of society, increase individual freedom and that is what brought me to crypto part of that is the potential of crypto to enhance world's freedom which I think is unparalleled with anything else and the second part of my motivation was the technological challenges and I have a software background, I was CTO for the last couple of years before moving into the space and I just was looking at it was three and a half years ago Ethereum was just getting started, all the protocols were just being built, and there were a lot of issues around usability and security, and everything was missing.
Then I looked into what's going to be the endgame. I was always interested in the endgame. How do we get this thing in the hands of everyone in the world? And it was clear that all the problems that are very apparent are going to be solved very soon by some teams, except scalability. That seemed like a really big black box. So I looked into what's going on in scalability space, and there was Plasma. And Ben, I know you are working on Plasma. My co-founder, Alex Vlasov, was also working on that. So I met him at DEF CON 3, I guess, in Prague. And we came from, we both encountered the idea of zero-knowledge proofs, of 16 zero-knowledge proofs.
And we both had an immediate thought that, oh you can apply that to plasma and solve most of its issues and actually get something that will work and bring us to mass adoption and back then crypto protocols were not like zk protocols were not as mature as they are today but it was pretty clear that over the course of next two three five years we will get something that is workable in production but we actually got there a lot sooner A year later, Sonic appeared, and two years later, we got Flonk. And that was something very, very useful. And Starks appeared around the same time. And all the protocols are now getting converged towards like very, you know, like everything is going in the same direction.
We will have incredibly fast protocols, provers, you know, like all the mature tooling around that to get us to scale Ethereum with ZK in no time. And before I hand it over to Ye from Scroll, Alex, ZK Sync has been around Ethereum for a while. I remember using ZK Sync to pay for Gitcoin grants in 2020 or something. Can you just speed run us through how ZK Sync has integrated itself into Ethereum over the last few years? Sure, so when we started out the project, We built the very first working ZK rollup on Ethereum. It was like, we called it back then Ignis, but we had to rename it to ZK Sync short afterwards because of conflict.
And it took us two more years to build the fully productive mainnet version for simple payments and swaps. It's live on mainnet for two years. It took us one year and it's now live for two years. and after that it was very clear that most people will need smart contracts and simple application-specific ZK roll-ups or roll-ups or scalability systems are going to be very, very niche and you really need this generic programmability with your incomplete programs. So we set out to build what is now known as ZK-AVM, the generic EVM-compatible framework that is scalable under SDK conditions. We launched the internal testnet over a year ago.
We opened it to the public with Unisync, a Uniswap demo last fall, and the testnet is open to everyone since over half a year. and we just announced a few weeks ago that we will be live on May 9th. 100 days, and it's now 87 days for me. I'm sure, Alex, that you wake up every single morning and be like, there's 87 days left. We don't have a huge counter, and it just goes. All right, let's turn the conversation to Ye from Scroll. Ye, can you explain a little bit about the background behind Scroll? Scroll is newer on the scene, and so this is something that's new for a lot of listeners, including myself.
Can you just explain a little bit about the background of Skrull? Where did Skrull come from? Yeah, yeah, sure. Happy to. So Skrull started one and a half a year ago. We have three co-founders, including me, Hai Chen, and Sandy. We were actually introduced by our mutual friend in the East community. So before that, I was doing ZK research. It's pure about crypto and ZK stuff about math and crypto. Now, you are curious into cryptocurrency. And I was working on the proving algorithms and hardware acceleration for the owner proof. Because years ago, the proving is the biggest bottleneck for using zero-node proof in practice.
So that's the problem I work on, like how to make prover more practical and faster and how to support a larger circuit. And Hai Chen is an expert in building robot systems. He got his PhD from University of Washington. He has years of experience working in Amazon, building very complicated systems, like based on compilers, programming language and GPUs. So he has tons of experience of how to, you know, build a, make a system more practical and run in real world. And Sandy is more, you know, like, because three of us like diverse a lot in our background. Sandy has been in the broader crypto space for many years.
She has been doing investment in crypto since 2017. She has incubated many application level projects and also institutional facing product like products. she was attracted to Ethereum more strongly due to the rapidly growing community, the ethos of Ethereum, and also innovations from dev developers. And when we met, it was instantly clear that we shared the same vision on what was important. And there was nothing more exciting than us scaling the base layer of Ethereum and onboarding the next billion of users for Ethereum. Because for a long time, it wasn't very clear that whether ZKVM would even be technically possible.
And previously, ZKROP can only support like payments, swap, very simple applications using some fixed circuit. But recent innovations, because we are working on in this area, we know that recent innovations have made that finally possible. And we all want to build something which is truly impactful for the whole ECM community. And also we were joined by our common vision to use this, you know, combining with ZK research, advanced technology, who really solve the scalability issue of Ethereum. So that's basically the genesis of Scrooge. And although like we are new, but we have grown really fast.
We have 40 people in our team now, and 30 are engineers and researchers, who most are just strongly technical focused. And we have an incredibly strong technical team with mostly people who have a strong math and crypto background. And this background is immensely useful for understanding the backbone of ZK-EVM, which highly relies on the owner proof, basically on math and the crypto stuff. And many members of our team had years of blockchain development experience and has been active contributor to a lot of open source repos like Foundry and stuff like that. And because our region is aligned with Ethereum of being decentralized, many members of our team are also like, you know, quite global and decentralized.
We work remotely. We have people across Asia, US and Europe, like including like China, Singapore, New York, Bay Area, Poland, Ukraine, Australia, a lot of other places. So I'm very proud of, you know, our current team. And we are super focused on building, like although we are installed like previously, and we want to build the best user and developer-friendly ZQM solution. and we work well together as a remote team. And also we have been very careful like in how we grow this team by bringing on the colleagues who are highly value aligned with high in quality and also the right motivation to work with us in this space.
Nice. Yeah, beautiful. All right, David, I wanna ask some questions. Can I get into it? Go for it, let's do it. Okay, okay, okay, okay. So, all right, I think the first question that I would like to ask the both of you is, It's very clear that ZKVM, to your point in your intro questions to me, David, it's been a problem on the horizon that we've been thinking about for a very long time. And when we first started the ZK scaling stuff, we did not start with the EVM, right? Because it's a very, very hard problem. So obviously there's been huge strides made, to your point earlier, Alex, and I have a suspicion that there are different approaches being taken to solve this problem.
Usually when there's a hard problem, you get a few different strategies or ways. So what I'm really curious to hear from the folks on this panel are, what do you think are the unique things about the approach that you take? And what are the things that are shared between the different approaches? And notably, right, we have two panelists here. There are a few other teams building ZK EVMs as well. So I'm really curious to hear from you guys what you think the lay of the landscape is and what your strategy in particular is to tackle this in some unique way. And Alex, we'll start with you. Sure.
Sure. So the approach we are taking goes back to how we think about the strategy of building ZK-SYNC. And that goes back to the mission. Our mission is to accelerate the mass adoption of crypto for personal sovereignty. And accelerate means move faster. We believe that it's coming no matter what. But we want it to arrive not in 10 years, but in two years. and to move faster you need to be very pragmatic so what we're like how we what we learned from building the first version is that you're much better off launching something that works and then gradually iterating over that then like waiting for a perfect solution trying to construct this abstract beauty in vacuum so like where i have this picture which you might know like this is how we operate right with building gradually and not trying to get perfection And how it started, actually, we initially, there was no real way from the limitations of provers, like from the protocols themselves, to build a Turing-complete version of EVM.
So we tried to build a non-Turing-complete version of smart contracts, and we had to construct a new language called Zinc. So, we had to build a compiler team, and we took Rust as a base, not the Solidity, because we thought if you have to learn a new language, which is going to have a lot of internal limitations, it doesn't really matter. You need to learn from scratch, so let's take something that is more familiar to a broader audience. We quickly learned that it's going to be very problematic to force people to relearn the language and like to adopt the developer tools, everything like that, that's just going to be a mess for adoption.
That's not what engineers want on the one hand. On the other hand, there were some breakthroughs in the cryptography, like in Plonk, recursive Plonk, in improved efficiency for certain gadgets, for certain cryptographic functions that are required to build something like EVM that we thought, okay, we're going to take on the challenge and actually build a full zkav out something fully compatible with ethereum where you can take existing smart contracts written in native solidity or viper and just pick them and launch them on this thing uh and we looked again like what's going to be the fastest way to get there so our head of engineering anthony rose is actually coming from spacex used to to be in charge of the satellite factory there uh and we borrowed this concept of the critical path from spacex like what's the the shortest possible way for us to get to the goal.
And it turned out that we can reuse our compiler skills and build something very similar to what we now know StarCrew is doing with Cairo, namely create a virtual machine that is optimized for probability under zero-knowledge probes. It's specifically optimized to be very efficient under snarks. And then create this virtual machine with all the conventions of Solidity and EVM. So that all the calls, all the interactions, all the interfaces are exactly the same as EVM, but you just have a different set of public codes underneath. And then we can use the compiler to take the code written for EVM and bring it over here.
And this is the approach we're taking. As far as I know, no other ZK EVM team is working in this direction. Stockware is doing this for Kyra, but you have to relearn it, like the Cairo language. They have some to transpile code from Solidity to Cairo, called Warp, but you actually have to maintain the code in Cairo. There is no way for you to keep Solidity as a source of truth as your basic code. And it would be very, very hard to keep the same code base between layer one and layer two or between different layers. That was something that was not acceptable to us. We want the code base to be exactly the same, executable as well in mainnet as in anywhere.
That's our approach. I'll pass over to Ye. Ben, does that generate any follow-up questions or should we throw it to Ye? Okay, wait. Let me just make sure I'm following right, Alex. So basically what we've said is we talked about in the intro of the show that we have this thing called the Ethereum virtual machine. It's how you interpret smart contracts in Ethereum mainnet. Basically, what you've written is a virtual machine that's very similar, that's meant to be very mappable and close and related, that is optimized for ZK proving. And then you can basically relatively easily take Solidity code that is meant to go to the EVM target and compile instead to this other target.
Is that right? That is correct. So we don't have a native compiler from Solidity. We are using the CGDT compiler to produce the intermediate Yule representation of the code. Yule IR, oh yes. Exactly. And then we're going from Yule to our virtual machine, which is a lot easier to make that step. And in between, we're using LLVM as our compiler framework, which is a very mature, very well-tested, battle-tested framework with a lot of tooling, a lot of optimization. So our code is actually a lot more optimal than what Solidity compiler natively produces for AVM. We have three times less opcodes in the final result.
And yeah, so this approach is the fastest to bring to production. And yeah, we started working on this for like since two years. So we have something that's very, very mature in compiler. it works in like you know we are recovering all the tests from ethereum uh test suits and it's running in a very stable way on our test net which is public like a lot of teams are deploying there we have hundreds of teams already working on testnet everything works really really well uh but the the most important thing is it will produce the uh resulting virtual machine bytecodes that are very optimal. The execution, the proof generation for the zkvm, for optimized zkvm is going to be orders of magnitude less than the approaches that try to mimic EVM at bytecode level.
So we are talking about like very, very low cost per transactions, which we can scale to to both support the high load of DeFi, NFTs, but also like very broad use cases, just gaming and like, you know, all the new things that are coming to blockchain, once we can actually support the scale of tens, hundreds of thousands TPS. And in those cases, it really matters. Like if your transaction costs like 10 cents or 0.1 cent, it matters a lot. You cannot just like, this is the quantitative step unlocks qualitative difference in what you can actually build and execute and run on in these networks. Beautiful.
All right. Let's turn to Ye from Scroll. Ye, can you talk about the competitive difference that Scroll is bringing to the table? How is the approach to the ZK-EVM from Scroll side of things unique from the others that you would find in the same landscape? Yeah, yeah, yeah, sure. I think technology-wise, there are mainly two differences. One is on the ZK-EVM side, and the other is on the infrastructure side. Firstly, on the ZQM side, our goal is that we want to have the deepest level of compatibility with the ECM down to the client implementation. So by saying that, we are not only being compatible with the solidity at the language level, like either you are you or any other, we will be compatible with EVM itself at the bytecode level, which means anything as far as you can use the existing compiler to compile down to the EVM bytecode, and we can prove that it's correct.
And also, like, by seeing client implementation, we are reusing the existing Ethereum node implementation called gas to generate our layer 2 blocks. So this is pretty similar to what Optimism is doing, like, just try to reuse the implementation from Ethereum to inherit the performance, the security, and also, like, in the long upgrade, we will be more aligned with Ethereum. So there is no compiling. There's no interpreting in between. So it brings us another level of compatibility more than just the RPC interfaces, but it's a deeper level of compatibility on the implementation side. And for users, it means they can do whatever they can on Ethereum using the same UI and UX.
And for developers, they can reuse all the Ethereum toolings, even include some debug toolings, like where you definitely need to down to the bytecode level. Like for example, you need to look up some stack information and things like that. And they can migrate their code to scroll without any modification. And also like, you know, this brings us another benefit, like where our implementation will be the most closest to the end goal of Ethereum, where ZKey VM can eventually be used to prove for layer one mainnet blocks. So in that sense, we are not only building for ourselves, we are not building just for layer two purpose, but we are actually co-building this for the future of Ethereum because it's very beneficial for Ethereum in the long term.
So that's from the compatibility and the ZKVM side. And another thing I want to mention is that on the infrastructure side, we have designed a decentralized prover network. So there is both a technical difference, innovation there, and also a strategic difference. Because a big problem we're mentioning by maybe Optimist or other teams say that the proofing cost is large because generating proof is usually slow and considered to have very high costs. It's very expensive. But we can actually solve this problem by allowing many people to generate proof in parallel. And also, this can drive the efficiency of proving hardware to the extreme and eventually even have the A6 to support this proof generation.
Anyone can just use this type of hardware or use general-purpose GPU or whatever they can to generate proof for us, for our platform. We are prioritizing this because this is also not only the technical advantage but also strategic differences because more immediately, especially with the ETH merge, miners could potentially just be our provers. They can can reuse their GPU machines to join Provers and join our ecosystem if they don't want to switch to another work chain. So that's both technical innovation and also a strategic move for us. Let me ask. OK, so I want to do the same thing and make sure that it's following.
So basically what Ye said, I think, correct me if I'm wrong, is that you effectively have a program that is written, I would assume that's running in some sort of lower level ZK VM, that is this Turing complete machine. And then you're running an EVM interpreter on top of that, basically. Is that right? We are not even having this middle layer. We are directly... For example, if you receive a transaction, you execute it on guess, and then you output some information, like the execution trace, which opcode you are actually executing. And then you use this trace as a witness to feed into this circuit and prove that it's a valid trace using a very certain proof.
And then this proof, as far as you have this proof, it means, oh, this trace is valid, so this transaction is correct. So there is no middle stuff. You just reuse every information from the existing client implementation. Yeah. Got it. And that circuit, I guess what I'm getting at is that circuit. So when you feed in, So it makes sense to me that you run the transaction on Geth, like the vanilla thing. And Geth has a wonderful thing called a transaction trace, which will give you sort of a step-by-step set of these instructions of the Ethereum virtual machine that we talked about. Geth will break that down instruction by instruction.
It went here, and then it went there, and then it went there. So that all makes sense. But then what is actually running when that information is transferred to the prover? What is the circuit running? Is there some sort of turn-complete thing that is then running the EVM on top of it? Is it, have you actually written like an EVM like circuit for all of this? What is that part of the stack? Yeah. Yeah. So basically what we are doing to handle this is that for each opcode, we will implement some sub-circuits to prove it's correct. For example, if, if you are add opcode and we prove that this, this number adds to this number equal to this number.
So we have a specialized sub-circuits for each opcode. It's a one-to-one mapping. And then like, because, and then like EVM circuit, we compose those sub-circuits together and then open or like, you know, or like using some selectors, we call that selector in circuit. But basically, if you meet with this opcode, you open this certain constraints. And if you meet with the other opcode, you open the next. And then like, you know, you prove that this is correct. And by constraining each opcode. I'm interested. I'm really interested to hear from you, Alex, on this. Like, it's interesting. I know I've been on a panel with you and you love parallelized proof generation as well.
I think all the ZKers do it. I totally do as well. But it also seemed like earlier you said you had a bit of a different approach for performance reasons. So I'm just curious to hear what each other's perspective is on these things. Is the performance of ZK-Proofs an issue or not? I feel like I get conflating answers sometimes. That's a great question. That's a really great question. So I don't see that we have different strategies here. All ZK teams will eventually work towards decentralizing the prover. we are working on this definitely this is very important to us we don't want to be any single point of failure, we don't want to run any operator that controls the validation of the transactions going to on or the generation it will be decentralized we can reuse Ethereum miners indeed, we've been working on the GPU prover hardware for the last two years as well and we have some pretty amazing results.
Like the GPU prover that we have that runs on ordinary consumer GPUs is something like 50 times faster than, like 50 times cheaper than the proofs produced on CPUs. And for the broader concept, it's really important to understand that whenever we talk about the prover efficiency, we always are talking about the armatized cost per transaction. Prover is always distributed. It's always done in parallel. No one is running a prover on a single machine. If they do, it will take them hours to generate a single prover. What we're doing, what probably other teams are doing as well, is we run it on as many machines as we need in parallel.
and since the structure of the circuit is that we kind of progressively combine many circuits together our latency to generate proofs with GPUs is going to be like less than a minute so we'll be able to like really to get the blocks really fast so what really matters at the end is like what is the cost of this proof generation divided by the number of transactions what is the cost production. And that is where the differences will materialize very significantly with our approach, or like with StarCraft's building, versus what Scroll, like this very ambitious goal of Scroll to make EVM circuit, like circuit level compatibility.
That is going to be like several orders of magnitude higher. We're very curious to see what the numbers actually are, but that is very complex, and that is very complex also to maintain. So huge respect to the team who are trying to make this, we didn't trust ourselves. We went for a much simpler approach because we know that the more complexity you add, it grows non-linearly with the number of systems you add and with the number of layers you add to each system. It just explodes at the end. So this is with regard to GPS. Sorry, finish up, Alex, and I'll ask my next question. So this is with regard to decentralizing the prover and GPUs.
And I just want to add that we decided explicitly not to reuse Geth, as not to rely on standard nodes for a transaction for the block building, for deciding what goes into transactions, because Geth is known to have very strong limitations on throughput that it will bring with itself. like if we're building a system that should be capable of running tens of thousands of transactions per second, we should redesign the node from scratch. We're writing it in Rust. It's highly optimized. We also have a very strong engineering team working on optimization of the node because we don't want the node to be the bottom.
I think, Alex, you just opened up the conversation to the EVM compatibility versus EVM equivalence conversation. But before, I wanted to go back and just make sure we really knocked down the decentralizing the prover for the layman, because that part of the conversation made me feel like a dog driving a car. Can you, Ben, can you walk us through why is, what does it mean to decentralize the prover? Like, why is that significant for just, like, the average user to pay attention to? Sure. So I'll talk about this. I'm not the ZK expert. It's like these folks, but I have a rough sense. So basically, when you construct these zero-knowledge proofs, right, that is an operation called proving, right?
Unlike the operation called verifying, which is like in a ZK role, what the smart contract on chain does, what all the nodes do then downstream of that. So in general, what you have to do basically when you produce a zero-knowledge proof is a bunch of extra cryptographic moon math-y computation that will give you some fancy numbers that allow the verifier in this succinct manner, right, in this short, you know, constant or logarithmic sized manner to check whether or not the proof is valid, right? And so this is a computationally intensive operation to do it in the zero knowledge succinct manner that we're talking about.
You basically, if you want to prove something, it's kind of like you don't just run the computation because that's not a proof. That's just you doing it. You have to run the computation in some sort of circuit, zero knowledge, math context that gives you some cryptographic steps along the way that you can sort of combine and aggregate and get this succinct proof. Okay. I'm guessing that doing the ZK stuff is like adding like an order of magnitude of difficulty upon the computation. Yeah. These guys can talk about those numbers much better than I can, but it adds overhead for sure. For sure adds overhead.
And is that like the cost for like when a transaction fee happens on like a ZK rollup? Is that the cost of this thing? Is that related? Are these related? So it will be related, right? I think I haven't looked into the details of either of these folks' fee markets, but that is, I think, what would be a very reasonable thing for a fee market to do. I think probably a requirement. There's additional costs, right? Because even in a ZK roll-up, you're still rolling up that data, right? Which means you're posting it to Ethereum or whatever, right? I know at least Alex has like other more plasma type things that don't require that.
So it's going to be a chunk of the cost. Absolutely. Okay. Okay, cool. Is there anything that Ben and I just said to stand out to you guys that you guys want to add on a comment to? That's good to me. Cool. Yeah, yeah. All right. So we definitely got to talk about EVM compatibility and EVM equivalents, because I think that's really... Alex, you said that Geth is really just not optimized for some of this parallel proving magic. But yay, from what I've gathered, Scroll is really going after what Alex called the very ambitious task of figuring out how to make Geth and a ZK role work together. So I think that's where we want to take this conversation next.
But before we do that, we've got to talk about some of these fantastic sponsors that make the show possible. There is a brand new staking feature in the Ledger Live app today. We all like staking the assets that we're bullish on. And now you can stake seven different coins inside the Ledger Live app. Cosmos, Polkadot, Tron, Algorand, Tezos, Solana, and of course, Ethereum. With Ledger Live, you can take money from your bank account, buy your most bullish crypto asset, and stake that asset to its network all inside the Ledger Live app. Through a partnership with Figment, Ledger also lets you choose which validator you want to stake your assets with.
And Ledger is running its own validating nodes, offering a convenient way to participate in network validation. And it even comes with slashing insurance. Ledger Live is truly becoming the battle station for the bankless world. So go download Ledger Live. If you have a Ledger already, you probably already have it. And get started securely staking your crypto assets. The Brave Browser is the user-first browser for the Web3 internet with over 60 million monthly active users. And inside the Brave Browser, you'll find the Brave Wallet. the secure multi-chain crypto wallet built right into the browser.
Web3 is freedom from big tech and Wall Street, more control and better privacy. But there's a weak point in Web3, your crypto wallet. And most crypto wallets are browser extensions, which can easily be spoofed. But the Brave wallet is different. No extensions are required, which gives Brave browser an extra level of security versus other wallets. Brave wallet is your secure passport for the possibilities of Web3 and supports multiple chains, including Ethereum and Solana. You can even buy crypto directly inside the wallet with RAMP. And of course, you can store, send, and swap your crypto assets, manage your NFTs, and connect to other wallets and DeFi apps.
So whether you're new to crypto or you're a seasoned pro, it's time to ditch those risky extensions and it's time to switch to the Brave wallet. Download Brave at brave.com slash bankless and click the wallet icon to get started. The Layer 2 era is upon us. Ethereum's Layer 2 ecosystem is growing every day and we need Layer 2 bridges to be fast and efficient in order to live a Layer 2 life. A cross is the fastest, cheapest, and most secure cross-chain bridge. With Across, you don't have to worry about high fees or long wait times. Assets are bridged and available for use almost instantaneously.
Across's bridges are powered by UMA's optimistic oracle to securely transfer tokens between Layer 2s and Ethereum. Across's critical ecosystem infrastructure and Across V2 has just launched. Their new version focuses on higher capital efficiency, Layer 2 to Layer 2 transfers, and a brand new chain with Polygon, all while prioritizing high security and low fees. You can be a part of Across's story by joining their Discord and using Across for all of your Layer 2 transferring needs. So go to Across.to to quickly and securely bridge your assets between Ethereum, Optimism, Polygon, Arbitrum, or Boba networks.
Okay, welcome back, y'all. We're back in action. So, okay, we just had a really interesting discussion on some of the differences in these approaches. And one thing, to your point, David, that came up just before the break is understanding the role of, I think, the, so I take some guilt for creating this term, which can be very confusing, but EVM equivalence is like a wonderful term that we use at Optimism to describe how we kind of try to move towards using Geth as much as possible. And this has been a matter of debate, and there are differences between our two panelists here and what they do.
So I'm really curious to hear from you guys how you think about the developer experience. We talked a lot about the approaches sort of from a proving architectural cost GPU type of a perspective. But there's also the side of developers and what they're going to experience. So I'm curious to hear from you guys, from the panelists, what your different approaches to this developer experience are. What does it really look like for a developer to be implementing on one or the other? And how do you think about that long term is the other question. Are you at a place where you're comfortable? Are you trying to move in a specific direction?
What's the take? So maybe we'll start with Yac. And developer experience, which means we will provide exactly the same execution environment as ECM layer one. So developers can pretty much reuse all the developer tooling around, like including the debugging tooling. If you want to go into the stack and look up some information, you can still use that. And because as far as I know, many gas developers, many even application level developers, they are very familiar with the gas implementation, so that it's easier for them to debug and have some index security analysis. So I think we have some advantage on that because we are using a fork of gas to generate our blocks.
And also because you are compatible with all the developer toolings, So developers are very comfortable with every tool they use on layer one. They don't need even any extra plugins to link to any external compilers. They can just reuse whatever is there. So in the long term, I think it's more secure way because firstly, EVM has to test of time. Like the design philosophy of each opcode, this stack-based virtual machine, its security has to test of time. If we just reuse everything from EVM, it's very easy to audit our code because our execution environment will make sure that the circuit will behave exactly the same as EVM.
If you make a mistake there, then you can make mistakes here. But if it's correct there, then because they behave exactly the same. But I think that's important in the long term, why by reminding this UAM equivalency is important. And also secondly, as I mentioned, like if you are more aligned with this implementation for the further ECM upgrade, like people are doing experiments over gas for EIPs, for different improvements, you can directly use the same code base to improve your layer two design. And also like even sometimes give back. I think that's part of the motivations why Optimism is going into that approach.
So that's why like, you know, our design philosophy for this part. And again, because we are actually standing on top of the giant, because when we appear, the breakthrough already happened. We know the overhead is already affordable. So that's why we directly go into this by the code level compatible approach, instead of building some other virtual machines to make the pooling overhead more manageable. I thought Alex. Makes sense, yeah. Let's hear from you, Alex. Sure. So we are also on the mission to make the developer experience as easy and pleasant for developers as possible. We can have an absolute top.
And it's important to see what is the actual developer experience is like what you expect as a developer from the environment. What you expect is that you don't have to modify your code and you can use the existing tooling. So you take whatever you have written in contracts and frontend and test use, et cetera, and you port it and it just works. Just work like one click, Stripe-like experience where you don't have to do any movements. That is exactly what we're going to bring. We're not going to bring it at the opcode level, but we're going to bring it at all the interfaces. The code does not need to change.
You do not need to do any reaudits. Your Web3 API works out of the box. All the coding conventions work. All the toolings on-chain work. We have the graph or chain link, a lot of other projects already integrating, already running on our testnet, ready to provide this experience. So things that will not work because the opcodes are different are like low-level debuggers. But those tools can just integrate. We can work with them. There are not many of them. You can work and make them be as compatible. And then you use the same. You have your tenderly experience. You have your remix. You have your common line-based debuggers.
And they provide the same output, the same experience to you. You as a developer do not need to do anything. And the surface of changes is really minimal. But what is ultimately important to you as a developer is that your code works smoothly, that everything is fast. So the one way to think about ZK-EVM equivalence versus EVM compatibility is like, what would be the analog of these things in the real world, in the normal computing? Imagine you have some piece of software written for one operating system with specific architecture. I don't know, like a Photoshop running on Windows. Now you want to run this Photoshop on Mac with M1 processor.
You have two options. Either you recompile the code for M1 and it runs super fast and you like the experience, or you run a Windows simulator on your Mac and then you run this Photoshop in the simulator. You can already sense, like if you run just some programs written for the older version of Mac and then you try to run them on M1 without optimizations, you already feel the difference, right? like it's huge but if you run it in in an emulator it's going to be a lot slower so your your developer experience is tightly coupled with your user experience as well that is what matters yeah very very very interesting yeah i i want to take a careful swat here david to be your co-host because i'm very opinion as as the folks like coined the term evm equivalents like i feel like I'm at an interesting position here.
I'll just say I'm very curious to see how it plays out. I definitely very much vibe with many of the things that you said there, Alex. Some of them I became less of a fan of once I had to run a non-EVM equivalent system practice. You guys are also building a different space, right? You've got these ZK requirements. It's a little bit of a different world. So, yeah, it'll be very interesting, David, to see how this plays out. I'm a huge fan of developer experience, and I think that EVM equivalence is the way to go there. But we'll see. Alex, any comments on that? Or not? I'm also, I'm really happy that we have multiple approaches competing.
We have our bet, like based on our analysis, how, like what's going to be the optimal for developers at the end. But it's like, it's really great that we have this race and let the thousand flowers blossom. Yeah. Any comment you want to add before I turn the conversation to something else? Yeah. Yeah. I think it will be just win-win, eventually, all good for Ethereum, different tries and EVM equivalent environment or this compiler-based one. But I think in the long term, if you have extra need for compiler, you have to also upgrade your compiler and both your compiler and your circuit at the same time, which actually adds the overall complexity because those two parts are coupled together and you need to upgrade with each upgrade.
But for the EPM circuits, all the compiler stuff, those can be reused. And those have been tested years of time. So that's why we want to handle this more complex stuff on the circuit side, but we don't need to handle anything besides that. Oh, actually, I want to hear from Alex on that. Yeah, that's a really interesting point. I wanted to add that indeed, what we're building here is the future. And let's imagine, is EVM going to be ossified and be this standard that will be there forever and will not undergo any modifications? Like you mentioned that we have the very first version of PC with like 80, 86 architecture.
Is this thing going to be immutable and never change? That is hardly imaginable, right? So we will have some evolution in my opinion. You feel free to disagree. But with the compiler, one thing that gives you a separate compiler, specifically LLVM-based compiler, gives you is an option to have developer experience beyond just CVM. You can port in any code written in all the modern languages that support LLVM, like Rust, Golang, Python, C++, whatever. You take that, you compile it, even JavaScript. You compile it to LLVM and then you can use it as libraries or we can also define some contract interfaces and you eventually can write smart contracts in those languages.
And I think that is going to be incredibly powerful because it just opens this massive code basis already written in this very expressive languages with generics, with all the cool stuff that is not yet possible in Solidity. And that has stood the test of time for many more years before Solidity was even created. So I find that really, really, really fascinating. Okay, wait, Alex, I've got to dive into this more, though. So, okay, first of all, totally agree. If the reader has not heard of LLVM, it is one of the modern marvels of computer engineering. Absolutely fascinating. Go check it out. With that being said, there's a key question here that I don't know if I heard an answer to, which I want to dive into, Alex.
which is since you have developed a VM that is the ZKVM that is related to the EVM and maybe has some of the same semantics but is different, how do you deal with upgrades? I totally agree we're going to have upgrades to the L2 VMs. In this, are you basically, like, is implicitly there a commitment to this particular ZKVM that is your current compiler outputs? And is it your goal to maintain that going forward and just build more solid circuits around that? Or do you have the ability to improve that VM in the same capacity? Does that question? That is a great question. Yeah, I think we will have iterations.
So in the initial versions of all the roll-ups, we'll have to work a lot on upgrades and do changes. It will be important to work with the source code and not with bytecode. I don't think we will have an ossified bytecode in any near time. So eventually we'll have a newer version and yes, you will need to redeploy your contracts there. Okay, I see. So you're basically going to enforce the requirement that you have source code accessible so that if you upgrade the underlying zkvm that is not evm, you can recompile and regenerate the bytecode for it. That would not be a hard requirement. So whatever you launch, once we have a stable mainnet, we will guarantee that this mainnet will run for a long time.
And then most likely you will have a like, well, we need to see, I don't know exactly how this process will work. But like, yes, I believe that there will be progress in both the EVM world and ZKVMs. And eventually we'll come, we will converge more and more with the world of generic computing. We'll reuse the tools like LLVM, static analysis, all the debuggers that the traditional systems can bring. And I just think this process should be gradual and smooth. It should not be like a breaking change where you have to stop immediately and you cannot support the previous code. You can always emulate.
It's quite easy for us to add bytecode compatibility in zk-sync. Because now, like imagine we have the LLVM compiler. We can write code in Solidity and Rust, and it compiles to this very, very efficient low-level virtual machine. We can just write a contract that executes native EVM bytecodes. We write it in Solidity, or maybe we just compile our Rust implementation and we put it on ZKVM. That will give you the same overhead or maybe even slightly lower overhead than what scroll or our hair mass are building uh but it's it's a gradual process you don't have to wait for this final step you can already start using porting your contracts to the kissing written in solidity because you recompile that and the moment we have this contract live you can just start porting your your bytecode if you're willing to take the this massive overhead into account if you want full efficiency you just compile natively to GKVM.
Fascinating. Can I add more comments on this? I think there are two points. Firstly, I agree that EVM may not be the end goal in maybe 100 years. We are not always stick to EVM model. But the reason why we firstly go into this EVM equivalent approach is that because we know that the urgency for Ethereum is scaling. It's not for finding some new computational model as an extension, but it's more for migrating all the existing apps securely to layer 2 so that the congested problem can be solved. So that's why we want to provide the EVM frequency environment in the first place, because you have to handle with those problems and then you can think of the further problem of a new VM or any features.
So that's one thing, that's just our starting point and we will also definitely consider more developer-friendly, you know, VM or something like that. And the second thing is that to build this, there are some arguments around like EVM versus VM, but the problem is that I think the conclusion is most likely that either you build a totally new virtual machine or you just reuse this EVM and achieve equivalency. Because if you modify part of that, it's nearly a new VM, but you can't just benefit from a totally new design from this virtual machine. So that's why we are thinking of two approaches.
One is that adding more features to this EVM. For example, we can upgrade according to our community design, like some new pre-compiles specifically to our layer 2 and using the existing EVM structure securely. And secondly, that we are in parallel, we can explore some more efficient ZKVM to open this design space for more developers. So that's something that we are also exploring, but we believe that that's also driven by the developers' needs instead of just reusing the compiler and just reusing the same virtual machine because it's fundamentally different. I think the last point is that reusing the LLVM is very ideal to support all the programming language, but if you dive deeper into the LLVM for very high-level language like Rust, Python, those Turing-complete language with many features, you will find that the LLVM IR in the middle layer is very complicated.
It's even much more complicated than building a ZKey EVM, like adding support for all those opcodes, because they have very complicated types, they have very advanced features. If you want to support all of them, you need to support a very complicated IR layer. It's not just the solidity or anything like that. So I think even if you have this LLVM port, it still takes a very long way to go to support all the features of Rust. But if you only support the semantics of Rust, then I think it's still feel like less useful for developers because they still need to change a lot of code. And so that's, you know, like maybe three points from our perspective.
So we are also exploring, but that's like why we, we went this as our first step. I'll take that challenge. Let's see how fast we can support trust. Yeah, yeah, yeah. Pay for it. Awesome guys. Well, uh, like I said earlier, I really liked this metaphor. I feel like a dog trying to drive a car. So I'm going to zoom out this, uh, conversation and get something. I think the users can understand that, I think, a little bit better. And every single Layer 2 team has their sort of, like, vibe, if you will. Like, it's their culture, it's their branding, and that's often really how users ultimately come to, like, determine whether they feel comfortable with a particular ecosystem or not.
It's like, what are the values or the ethos that each team appears to exude, even though they can't really comprehend some of the very technical words that are being said. So I'd just like to get each of your guys' perspective as to, like, do you guys think about values or culture or vibes when your guys' internal, like, just, like, communication as to how to build something? And maybe you can share that perspective with the broader world. Like, what is the vibe of your particular project? What's the, if you guys have, like, an ethos that you stand on? And, yay, I'll start with you. Sure, sure, sure.
Yeah, that's actually a very important, like, aspect of scroll. And you can check out more, we have posted articles talking about our vision, value, our technical principles, we want to up-code when we are designing our whole architecture. But from the ethos and the vision side, we are more open. We have been building in the open-source way from day one. Like, you know, a totally open-source ZKVM circuit where anyone can run, anyone can just, you know, even PR some code. And most parts of the ZKVM circuits are actually co-built in collaboration with the privacy and scaling exploration team at the ECM Foundation under permissionless license.
So we are actually co-building this together. A lot of credit also comes from this community. And because we have this permissionless license, which means anyone can use this repo and build things on top of that. And also we encourage the broader community to do so because we firmly believe that, you know, building in this open source way leads to more secure and resilient code and help us to foster a broader community of developers and they can check our progress in a very transparent way because, you know, there are some over claims, right? They can just directly fact check our claims of, for example, like whether we have proofs or not.
And in that perspective, we hold ourselves very you know to a very high standard that with all our claims we made for example we actually have live zk proofs in our testnet now can be checked and we are focusing on building and shipping shipping our shipping new features on our testnet and we are not doing endless prs but instead we are you know writing articles explaining what we are building and what our architecture look like and output more educational articles which is beneficial for the whole space. It's not directly, you know, like, fighting against each other, but but more like for educating people why this is important, and what we are building.
And I'm glad that you know, even if we are still in a relatively stealth model, there is still a circle of ease and Ziki researchers who have recognized our work and given us credit, where it's due. And we are actually finally ready to welcome a much broader community. And I'm happy to say that we have received over like 25K signups within two days of our pre-offer testnet announcement. And if you want to be the first batch of users, just sign up at signup.score.io. Beautiful. Thanks, Ye. And Alex, I'll say the same question to you. What's the overall value or vibe of ZK-SYNC? So ZK-SYNC is deeply mission-driven project.
So this mission that I mentioned in the beginning to accelerate the adoption of crypto for self-sovereignty is hugely important. we've written a lot about this we have a team handbook that walks the new team members through the values we are extremely aligned with Ethereum on the approach towards those goals and every technical decision we make is balanced against the principles of freedom resilience inclusivity like from escape hatches to the way we decentralized the prover, to the way we approach decentralization of the sequencer, to the way we approach the standardization of the code bases.
We firmly believe in open source. Everything we do is going to be released under permission of the software license, just like we did for version one. With version one, we made some interesting experience that made us reconsider the approach to complete openness. We were leading the protocol development completely in the open, and then there were people who just forked the code, made modifications that they did not understand, took part, like they forked off some bugs and they also changed things that led to more problems and they tried to front run us with regard to the token. So there are powerful incentives for people to just rush with some unready code and try to publish it.
That's why we're taking a more conservative approach now. So we're opening everything to independent researchers. We actually, next week we will announce some people we opened it with who are highly credible in this space. And then we're going to gradually open it to more and more and more until we have all the audits and all the testimonials from the white hats where we feel comfortable that the code is safe. Then we're going to open source. Beautiful. Thank you, too. Yeah. Cool, boy. Cryptoculture, baby. Okay, Alex, you did just raise something that I really do want to get in before the end of this panel, which is a question for both of you.
Okay. All of the ZK, I mean, realistically, pretty much all of the Layer 2 teams out there right now have upgrade keys, right? There's some set of small number of people that own a multi-sig that can be used to upgrade the system. And that includes upgrading it to something that is malicious and takes all of the money from the system. This is obviously not ideal. I don't want to rehash why that's necessary because I think we all agree that it is and we understand that it needs to happen. But my question is, at what point can we cast those upgrade keys into the fires of Mount Doom? From both of your perspectives, what is the point in time in which, obviously it makes sense that now for you to launch something, you can have some level of trust that it's at some level of productionization.
But it's a big shift to say, okay, we're throwing away our upgrade keys. If someone comes to us with a bug in the future, we cannot solve that bug. So I'm really curious from your guys' perspective, like, what is the timeline and what is the, like, concretely the criteria that you think has to be fulfilled to be able to turn off your upgrade keys? And Alex, we'll start with you again. Sure. This is a huge problem. We're thinking a lot about. I published a tweet where we offered a bounty for the best design solution that can help solve this problem. And for the broader context, the problem here is very different in L2 space compared to L1s.
Because if you have a problem with L1, you can always fork away. The decision to fork is ultimately with the people who run the nodes. So you never depend on the honest majority. And that is the superpower of public blockchains, like truly decentralized blockchains, like Bitcoin and Ethereum. And I can't really think of any other ones that fall in this category. But you don't get this at Layer 2s. Because at Layer 2s, you have all the funds are locked into this one contract on Layer 1 that someone needs to control. someone needs to like this contract must objectively know like who is now like what what code is not canonical like what what shall we execute uh the solution we came up with was we have a team multi-sig that can initiate upgrades and those upgrades are subject to a time lock period of multiple weeks and then all the users who are uh disagreeing with with those upgrades can exit and we have permissionless mechanisms for exit uh like scape hatches like forced block proving, etc.
But if there is a bug and we really need to accelerate, we need to act now and just fix an immediate problem, we must go and reach out to an external number of people who we call a security council. Those are highly prominent people from the Ethereum community, very rich and famous. It's very unlikely that they will all collude to try to steal those funds, and they must approve an immediate upgrade. Now, this is not a perfect world, because we don't want to expose those people to political struggles, to some non-monitor incentives that might force them to do things. Ultimately, what we can do is have multiple layers of protection in our systems that all of the checks must be made before something happens.
So the simple example would be if we just have a second factor and we have a roll-up running, like a ZK roll-up, and then we have a number of validators appointed by the users who have to approve transactions. And then you would have to break both the consensus of these validators or corrupt the stake and find a problem in the zk circuits to try to exploit it. But that could compromise the liveness of the system if the proof of stake is or like this value data set is compromised. So another option would be to have multiple implementations of rollups like maybe if you're zkrollups or maybe optimistic plus zkrollup.
We combine those together and we put them on chain and then we use governance only if they disagree. This is something that Vitalik posted last weekend on Twitter, which is a very interesting idea. But ultimately, we just need to wait for those systems to become mature. Like if something is running for a few years with billions of dollars worth at stake and nothing has happened and those funds were not stolen. And you had honeypots running in the open with much lower barrier, much lower threshold of ability. And those are also safe. And those have millions of dollars stake in them that the attacker could just grab if they found much easier hole to penetrate.
Then I think then we can say, okay, those systems are plausibly secure and we we can rely on them and we can remove the admin key. This is roughly how I think about it. Maybe there are some ways where we could rely on the governance of layer one. Maybe we could declare some roll-ups as really important, systematically important for Ethereum. And we can say if something goes wrong in those systems, then we would just rely on the votes of the general Ethereum community. And we actually don't need to declare them anything special. We just need a governance mechanism that can rely on this external voting power of broader Ethereum.
Maybe something like this. So all the ideas are really appreciated. Yeah. You want to take the same question, just the overall security of Skrull and your guys' thoughts and plans around it? Yeah, yeah, yeah. Sure. I think we do have security plans and security definitely the first priority for Skrull because stakes are locked in smart contract. And for us, we do have security plan. And so there is no antidote for repeated and more throughout auditing. But besides that, we are going to have an in-house security team. And the team will keep an eye on our code all the time and also collaborate with external auditors for safety as well.
And also it's safe for now because all the transactions will be executed using this existing client limitation. we don't even implement a new ZK executor to execute our transaction. So it's very hard for any attacker to attack our system since they can't run this, you know, sequencer themselves, that's the first place. Secondly, that is existing implementation. And also they have no chance to generate fake proof for this fake trace. That's one aspect. And secondly, that as I mentioned, like, you know, there are definitely trade-offs between open source, like very early or very late. scroll is built on an entirely open source foundation, even including the proving stack of Halo 2, which is, you know, like many eyes are on that, including the Zcash.
And for example, like community developer from their part, and even Filecoin, you want to reuse the same like proving stack and even like, you know, sometimes reuse the given code base. So more broadly, we believe that using this community standards will be the most robust way to write security code and secure our whole code base and secure the system of our system. And for the upgrade case, I think we will implement a sufficiently robust system before the sequencer is decentralized, using some time delay, which makes sure that users will have enough time before this smart contract upgrading.
And in the long run, we will progressively add this decentralization and become more permission list like it but it's in a long long run like because you know decentralization is at different levels like first we decentralize prover and then we consider the overall system well gentlemen thank you so much for all of your time i know we've gone a little bit over ben do you feel like you've got all of your questions answered oh my goodness i had all the questions answered they spawn more as they always do david but i feel like a good place to pause as any well i think the the story of the zk evms uh is going we're just at the very very beginning So there will be plenty of ZK EVM content as the story progresses.
So Alex, yay, thank you so much for joining me and also Ben, my technical co-moderator here, for helping us unpack at the very start of this very long story of the ZK EVM. So thank you too. Thank you, David, Ben and yeah. Thanks for hosting us. Thanks, Alex. Of course. And see... Go for it, Alex. I just wanted to say see you guys on Maynard in 87 days. Oh, yeah, absolutely. Well, actually, before I sign off, can we do a speed run through the roadmap for each of you? Alex, mainnet in 87 days. Is there anything else about your guys' roadmap that you want to talk about? We're now completely focused on launching mainnet.
Testnet is up. If you want to be one of the first projects launching on mainnet, we're going to follow the fair launch policy. You should get on our testnet now and start building. And for the next features that are coming, there are some really interesting things. and I can't talk about them yet, but I will just say that layer 3 is a lot closer than many people think. Well, I can see that very slight smile on your face. So that's getting me excited there, Alex. Yay. What about you and Scroll? What's the Scroll team's high-level roadmap? Can you speedrun us through that? Yeah, yeah, yeah, sure.
I think for our release philosophy, we are progressively releasing more functionality to test so we can fix any bugs and any UX difficulties early and often towards a more robust infrastructure test of time. So currently, we are at the stage of pre-alpha testnet. It's running internally right now with real live ZK proofs. And we pre-deploy some applications like swap for user to interact with. They can see their transactions being processed on layer two and then finalized on layer one with a proof through an explorer. And if you want to be the first batch of users, again, like sign up our testnet at signup.
scroll.io. And the next step will be a more permissionless alpha testnet where developers can deploy their smart contract. And anyone can interact with applications on scroll. It doesn't need any signup. You can directly use your mental mask to interact with scroll using any interface you like and you are familiar with. And we are testing our functionalities for now and it will be released soon. And also like in further release, like anyone will be able to run the provers at home to provide a computation power for us. And yeah, so that's roughly our plan. Yeah, will there be a scroll token? Yeah, that's a good question.
So we are focused on building and we are thinking on long-term scale and want to be extremely thoughtful about how to foster a sustainable community of users and developers. And I think we can learn a lot of lessons from Optimism and Polygon, which is the only two layer tools which already launched their tokens. But the country we are still focusing on building the best solution technically. Okay. And then Alex, same question to you. Is there going to be a ZK-SYNC token? There might be a ZK-SYNC token indeed. I had an idea. Awesome. Thank you guys so much for joining me. Risk and disclaimers, of course.
Crypto is risky. ETH is risky. Bitcoin is risky. Layer twos are risky. We didn't get to the conversation of bridges, but bridges are also risky. But they're less risky if you go to a cryptographic bridge rather than a cross-chain bridge. But you can still lose what you put in. We are heading west. We're on the frontier. It's not for everyone. But we are glad you are with us on the Bankless journey. Thanks a lot. Thank you.