Joining us today for this deeply technical conversation is RiscZero CEO Brian Retford and Justin Drake. RiscZero is attempting to create a zkEVM for Ethereum that will require such low compute requirements that validators could be run on smart watches and mobile phones.
Moderated by Justin Drake, we take a look at the implications this tech can have on the future of Ethereum. ----- 🏹 Airdrop Hunter is HERE, join your first HUNT today https://bankless.cc/JoinYourFirstHUNT ------ 📣 SAFE CORE | Smart Wallet Infrastructure https://safe.global/core ------ BANKLESS SPONSOR TOOLS:
🐙KRAKEN | MOST-TRUSTED CRYPTO EXCHANGE https://k.xyz/bankless-pod-q2
🦊METAMASK PORTFOLIO | MANAGE YOUR WEB3 EVERYTHING https://bankless.cc/MetaMask
⚖️ ARBITRUM | SCALING ETHEREUM https://bankless.cc/Arbitrum
🛞MANTLE | MODULAR LAYER 2 NETWORK https://bankless.cc/Mantle
🦄UNISWAP | ON-CHAIN MARKETPLACE https://bankless.cc/uniswap
👾STADER LABS | ETHX LIQUID STAKING https://bankless.cc/Stader
----- TIMESTAMPS 0:00 Intro 7:47 Validator On Your Smartwatch 12:16 Bandwith Requirements 15:00 Implications for mainnet scaling 18:57 Is This Our Multi-Core Moment? 21:35 What is RiscZero? 27:57 Why Build a zkEVM? 32:00 TLDR Summary 35:42 The 3 Steps To Snarks 41:40 Performance Unlocks 43:59 How close are we to all this? 51:54 How Secure is This? 57:34 Licensing this Tech 59:59 RiscZero Business Model? 1:03:53 What’s Next on The Roadmap? 1:06:15 Core Values of RiscZero 1:07:54 How Does Ethereum Look in 5 Years?
---------- Resources:
The Sci-Fi roadmap to Ethereum: https://www.youtube.com/watch?v=6_NXxcGe7Ts
Brian: https://twitter.com/BrianRetford
Justin: https://twitter.com/drakefjustin
------ Not financial or tax advice. See our investment disclosures here: https://www.bankless.com/disclosures
No summary for this episode yet.
Hey, Bankless Nation. I'm very excited about the episode today. David is out, and this episode gets technical at times, so I have ETH researcher Justin Drake, whom I'm sure many of you know. He's co-hosting with me today. Some context as we get into this episode. So we did a previous episode a few weeks ago called The Sci-Fi Roadmap to Ethereum. And in that episode, Justin Drake described the endgame for Ethereum. And he said this, We snarkify everything. In today's episode, we explore exactly what that means and how we do it. How do we snarkify everything? Our guest today is Brian Redford. He is the co-founder of what might be the world's first Type 1 ZK EVM.
And if you don't know what that means, that's fine. Neither did I as we're getting into this episode. And it turns out that building a Type 1 ZK EVM is an important part of delivering what Justin Drake called an enshrined roll-up inside of Ethereum. More on that in just a minute. But before we get in, just want to mention something quick from our friends and sponsors over at Safe. Safe is the multi-sig wallet we recommend for crypto. And you've heard us talk about smart contract wallets many times, how they're going to 10x the crypto wallet experience. We definitely believe that's true. And Safe recently proposed their modular open source Safe core protocol as a standard for the industries that we can all move forward and transition to the smart contract wallet future.
And they want you to check it out. So there's a link for the devs in the show notes. Safe really believes this is an opportunity to create a unified standard to catapult smart contract accounts onto the EVM. The standard itself is unopinionated and vendor agnostic and maintains interoperability and smart contract diversity. So go check it out. And also to check out, SAFE is organizing the first ever conference dedicated to smart contract wallets and account abstraction. That happens the second week of December. There'll be a link in the show notes to go register for that as well. So thanks to say for building into the frontier.
All right, speaking of the frontier, back to Ethereum enshrined rollups. So why are we having this conversation and why now? The compute era scaled with Moore's law, but the blockchain era scales with something differently. It scales with cryptography, specifically cryptographic breakthroughs like ZK Snarks and all of this ZK Snark stuff, the snarkifying of the EVM. It's all happening a lot faster than any of us previously thought. It's happening so fast that a project called Risk Zero just came on our radar last week and they've already produced a working version of the world's first ZK-snarkified Type 1 EVM.
What kinds of things could this unlock in the future? Why is this important? Well, what if we could convert an optimistic rollup to a ZK rollup? What if we could upgrade Ethereum's Layer 1 from a single-threaded EVM model to a multi-threaded EVMs so that compute was virtually limitless and free? What if ETH validators themselves had the ability to run from something as small as a smartwatch. All of these are possible unlocks with this technology. This is crazy cool, deep stuff. Down the crypto rabbit hole we go and it gets technical at times, but it's absolutely worth holding on for the ride.
This is crazy cool stuff and we're going deep down the rabbit hole today. And this gets technical at times, but I think it's absolutely worth it to hold on for the ride because this is key to understanding how blockchains actually work and how they scale. And in so understanding, I think this type of thing can help you avoid bad investments and dead ends. And there are a lot of those out in the space as well. We're going to get right to the episode with Brian and Justin. But before we do, I want to thank the sponsors that made this possible, including our number one recommended crypto exchange for 2023, Kraken.
Go check them out. Kraken Pro has easily become the best crypto trading platform in the industry. The place I use to check the charts and the crypto prices, even when I'm not looking to place a trade. On Kraken Pro, you'll have access to advanced charting tools, real-time market data, and lightning-fast trade execution, all inside their spiffy new modular interface. Kraken's new customizable modular layout lets you tailor your trading experience to suit your needs. Pick and choose your favorite modules and place them anywhere you want in your screen. With Kraken Pro, you have that power. Whether you are a seasoned pro or just starting out, join thousands of traders who trust Kraken Pro for their crypto trading needs.
Visit pro.kraken.com to get started today. Mantle, formerly known as BitDAO, is the first DAO-led Web3 ecosystem, all built on top of Mantle's first core product, the Mantle Network, a brand new high-performance Ethereum Layer 2 built using the OP stack, but uses Eigenlayer's data availability solution instead of the expensive Ethereum Layer 1. Not only does this reduce Mantle Network's gas fees by 80%, but it also reduces gas fee volatility, providing a more stable foundation for Mantle's applications. The Mantle Treasury is one of the biggest DAO-owned treasuries, which is seeding an ecosystem of projects from all around the Web3 space for Mantle.
Mantle already has sub-communities from around Web3 onboarded, like Game7 for Web3 gaming and Bybit for TVL and liquidity and on-ramps. So if you want to build on the Mantle network, Mantle is offering a grants program that provides milestone-based funding to promising projects that help expand, secure, and decentralize Mantle. If you want to get started working with the first DAO-led Layer 2 ecosystem, check out Mantle at Mantle.xyz and follow them on Twitter at 0xMantle. Arbitrum is accelerating the Web3 landscape with a suite of secure Ethereum scaling solutions. Hundreds of projects have already deployed on Arbitrum One with flourishing DeFi and NFT ecosystems.
Arbitrum Nova is quickly becoming a Web3 gaming hub and social dApps like Reddit are also calling Arbitrum home. And now Arbitrum Orbit allows you to use Arbitrum's secure scaling technology to build your own Layer 3, giving you access to interoperable, customizable permissions with dedicated throughput. Whether you are a developer, enterprise or user, Arbitrum Orbit lets you take your project to new heights. All of these technologies leverage the security and decentralization of Ethereum and provide a builder experience that's intuitive, familiar, and fully EVM compatible. Faster transaction speeds and significantly lower gas fees.
So visit arbitrum.io where you can join the community, dive into the developer docs, bridge your assets, and start building your first app with Arbitrum. Experience Web3 development the way it was always meant to be. Secure, fast, cheap, and friction-free. Bankless Nation, I am super excited to introduce you to Brian Redford. He's the co-founder of a ZK EVM project that we're going to find out a bit more about on today's episode called Risk Zero. Brian, welcome to Bankless. Thanks. Glad to be here. Also excited to be joined yet again on Bankless by Justin Drake. He's an Ethereum researcher and repeat Bankless guest.
Justin, how are you doing? I'm doing great. Thanks for having me again. But I guess this time, maybe as a host asking some technical questions. Yeah. How's it feel? The tables have turned. So Justin, I'm going to tap you in as my co-host today. So David is out and we're going to talk about this, the next generation, ZK EVMs. So I think we're talking to Brian about the world's first, maybe ZK EVM. That's a type one ZK EVM. And I'm not even sure the words that I'm saying or what they mean. So we'll absolutely need to define that. But, you know, David's out right now. So Justin, you're going to tap in and help me with this.
I feel like this is a continuation, though, of a conversation that you had with him on ETHCC. And I think bankless listeners may have listened to an episode entitled Ethereum's Sci-Fi Roadmap or the Sci-Fi Roadmap to Ethereum, in which there was this really interesting part. And I love that episode, by the way, where you were describing the ability of us in the future of Ethereum to snarkify the EVM on kind of mainnet, on the base layer. And that sounded really interesting to me. And I think that ties into the conversation that we're about to have. So tee this up for us, if you will, Justin, as a continuation on that conversation.
I know we're talking about sci-fi Ethereum future stuff. But what does it mean to snarkify the EVM? And how does that tie into the conversation we're about to have with Brian today? Right. So big picture, we're actually going to snarkify all of Ethereum. And there's two big components that need to be snarkified. One is the EVM, which is this virtual machine which processes Ethereum transactions. And then the other part is the beacon chain. Now, once we've snarkified these two things, we'll be in a position where compute won't ever be a bottleneck for Ethereum. So it means that, for example, as a validator, you won't have to really have beefy CPUs.
So you'll be able to be a validator on your smartwatch. if you're building bridges between l1s you'll be able to have another l1 verify the state of ethereum without having to redo all the computations themselves it also has implications for like clients for what we call enshrined rollups which are super high security rollups and And when the words type 1 EVM come to mind, type 1 ZKVM, it really kind of gets me excited as a researcher. Because it was kind of a piece of sci-fi engineering that was thought to be, you know, 5 to 10 years into the future. But it looks like, well, there's several teams working on them.
There's, for example, Tyco. And there's risk zero now. and it looks like the engineering will just be ready so much sooner. So we're starting to see the light at the end of the tunnel and that has some big implications in terms of applications for Ethereum, both at layer two, but also what I'm excited about, which is the layer one. So what you just described here, Justin, is kind of the holy grail. And I still want to spend some more time with you right here, just fleshing this out and making sure that we understand this going to the episode because it sets the context for the rest of the conversation with Brian and Risk Zero here.
So the light at the end of the tunnel, or what I just referred to as the Holy Grail, snarkifying all of Ethereum. What this means is we get to use the spooky math, the crypto magic ZK math that you've described so eloquently many times on the Bankless episode. And what we get, the prize that's held out to us is the ability, first of all, you said, to validate, be a validator on something as small as like a smartphone or an Apple Watch. So, okay, is that really what we're talking about? So, of course, one of the end goals and the end goal, the entire purpose of Ethereum is for it to remain decentralized.
And that means, ideally, anybody with a basic consumer level computer can validate transactions on the Ethereum mainnet. And right now the requirements for doing that are somewhat higher than just a smartphone or a smartwatch, but this will decrease the requirements, the hardware profile in order to validate transactions on the Ethereum mainnet and also to stake. Is that what you're saying? That's correct. So anytime you have a human that ends up wanting to interact with Ethereum, they need to interface through a full node. And there's some complications here because running a full node is not something that you can necessarily easily do on your phone.
And it's not something that the average individual will want to do. And it's something that every single validator has to do if they want to become a validator. So there's this barrier to entry. And more often than not today, for the vast majority of users, we end up patching this technical barrier to entry with some level of centralization. So for example, if you're using MetaMask, you're going to be connecting to Infura nodes that are kind of running the full nodes on your behalf. And so there's some amount of trust that you as a user are placing into MetaMask. so once we have a type 1 zkvm once we've snarkified the vm and all of ethereum we're going to be in a position where the user will be able to interact with ethereum with much much much less hardware like a phone or a smartwatch will be able to get best in class access with best in class security best in class latency all with very very little hardware that's does this imply anything for a bandwidth as well?
Will this decrease the bandwidth requirements or will bandwidth kind of become the constraint here now? Right. Great question. So consensus kind of solves two problems. One of them is execution and the other one is data availability. Snarks is kind of this magic technology that removes computation as a bottleneck within the context of consensus. And it turns out we have another magic technology for data availability called data availability sampling. Now, neither of these are really in production right now. But once we have both in production, you won't have to pay the cost of computation and you will have to pay a very, very minimal cost from the bandwidth perspective.
So you won't even need to download the Ethereum blocks. All you have to do is make these small queries for chunks of blocks, And that's going to be enough to guarantee that you're on the canonical Ethereum chain. So data availability sampling as well. That's a core upgrade of what I think people are calling dank sharding as well. Not proto-dank sharding, as I recall, but dank sharding, which could occur later in the future. Exactly right. so we're looking at technologies two, three, maybe four or five years into the future which in a way will transform accessibility of Ethereum for users and in the endgame accessing Ethereum will be just as easy as accessing any other website and you'll have guarantees just like on a website today you have this cap lock sorry, this lock in HTTPS you'll have a similar lock saying you're really connected to the real Ethereum, and you'll have to have done almost no work, and you'll have to download almost no data.
And trust nobody also, unlike the current kind of lock where you actually have to trust the sort of signature verifiers for those signature issues. ZK technology is the thing that makes this all possible. What's very interesting is I know there are people who talk about kind of like compute scaling in blockchains via Moore's law, and that's true. But where we really get the like kind of the massive scalability is more with like cryptography breakthroughs. That is something I've learned as part of like exploring the roadmaps and being in this industry for many years now is these cryptographic breakthroughs are the key sort of step function breakthroughs that allow us to actually scale this technology.
One other quick question for you, Justin, before we get to Brian to kind of describe what he's actually working on, what we're doing here. What does this imply for maybe scalability on Ethereum mainnet? So we talked about lowering the compute requirements to be a validator, which is fantastic. That is a further decentralization unlock. How about transactions per second on the Ethereum layer one mainnet? Does this have any impact on that as well? Fantastic question. So once we've snarkified the EVM, we'll be in a position where we can greatly increase the gas limit and potentially even remove the gas limit for computation specifically.
And the reason is that the gas limit is an anti-denial of service vector, whereby when you receive a block, you want to be able to fully verify that the block is valid on the order of one second. And so if there's too many transactions in that block, then it's going to take more than one second to validate. But the magical thing about snarks is that the verification time of a snark is on the order of one millisecond. And so you can take a block that's kind of arbitrarily large with arbitrarily many transactions and arbitrary much transaction execution and know that the execution is correct within a constant amount of time, which is only one millisecond.
So what does that imply then? So if Ethereum right now supports like 16 transactions per second, and we're scaling that out via rollups. And last time I checked on L2B, we're about, if you count all of the kind of rollups combined in that, we're about 5x, 16 transactions per second, something like that. And that's the entirety of Ethereum right now. We're not handling a Visa level throughput at this point in time, it's safe to say. But what you just said about kind of finality or confirmation times, the millisecond level validation verification here. What does that imply for mainnet throughput, Justin?
Right. So what it means is that there's going to be a partial comeback of the layer one. So I think the spotlight is going to shift to L2s for the next few years. And there's going to be a lot of experimentation, a lot of innovation. And the layer one is really going to be lagging because we're extremely conservative and we're frankly kind of slow for good reasons. But once we are able to catch up from a technological standpoint with the L2s, well, the L1s will also have some of the similar powers that the L2s provide. And so the L1 will, to an extent, be able to scale out. One of the superpowers will mean that we can increase the gas limit.
And there's something that's kind of explicitly put in Vitalik's roadmap diagram. But another thing that we can do, and I think this is something that Vitalik will add in maybe the next iteration of the diagram, is that we can have an opcode within the EVM, which allows you to verify validity proofs, SNARKs, of EVM blocks itself. So kind of the EVM is aware of itself and knows when another EVM block is valid. And what this allows us to do is have multiple instances of the EVM. Because ultimately, you can think of the EVM as being this single threaded CPU or virtual machine. So it can only run on one core just to simplify.
And so there's this inherently sequential computation that's going on, which is a bottleneck for scalability. The EVM will never be able, most likely, to do a million transactions per second, just because we have this inherent bottleneck. And so the way that we scale out once we've reached all the gains by increasing the gas limit is by having multiple instances of the EVM. So this is going to be EVM 0 and then EVM 1, EVM 2. And the cool thing is that once we have this opcode, anyone can programmatically create a new instance of the EVM. Wow. Wow. So this would become kind of Ethereum mainnet, the layer one, kind of our multi-core moment then?
What's kind of the analog? Is it from 486 to Pentium? I don't know what we're doing here. Yeah, I think that's a good analogy. We're going multi-core. So for a very, very long time, we've had these CPUs, which were just one core. And then what we did is we ramped up the frequency of the CPUs. So it was like hundreds of megahertz and then one gigahertz and then 1.5, two. And then we, you know, nowadays we have, I don't know, three gigahertz CPUs and you can't do like 30 gigahertz. And the reason is that the transistors just don't turn on enough fast enough. So there's this sequential bottleneck.
And so the way that you scale is by scaling out vertically, by having multiple cores working in parallel. And this is exactly what we can do once we have this opcode. And the term that I like to use is enshrined rollup. So once we've snarkified the canonical instance of the EVM that we have today, we're going to have one enshrined rollup. And then once we add this opcode, we'll allow anyone to create as many enshrined rollups as they want. Okay. Well, Brian, you've been sitting here waiting very patiently as Justin eloquently described the light at the end of the tunnel, this kind of holy grail.
And I think that you are working on that. Now, you're not working on that within the bounds of sort of the Ethereum foundation and applying that to Ethereum mainnet. But you've got this project called Risk Zero that is actually pursuing the technology that is required to get us to the promised land and everything that Justin just described. So, Brian, I'm wondering if you could tell us, maybe first, I would love to get your reaction to what Justin just said and anything that that maybe triggers in your mind. And then we'll talk about what you're building out at Risk Zero and this platform that you're calling Zeth right now.
But first of all, any reaction to what Justin just said? Yeah, I mean, it's pretty clear that with all of the advances that we're making in cryptography, as you said, that the capabilities of Ethereum are just going to continue to compound and compound and probably much faster than we would have seen or thought of even possible. So I think the future is very bright, given all of the advances that are being made across the entire space. And this is just one key in a very large puzzle. So it's very exciting. Okay. Well, so tell us what you're building then out on the frontier, which again looks a little sci-fi from our perspective, but seems to be at the same time also happening faster than many would have imagined at least many years ago.
So your company is called Risk Zero, and you've got, I believe, this platform called Zeth. And we describe this as a type one ZK EVM. And this goes kind of beyond what I even know I'm describing. So what is Zeth and what is a type 1 ZK EVM? Yeah, so Zeth is an EVM implementation that's actually based on Reth, which is like Geth, an implementation of the EVM. However, it's one that's built using Rust. And a type 1 ZA EVM is simply one that can actually process the full nature of Ethereum in an entire block and prove, effectively snarkify an actual Ethereum block, as opposed to some of the other L2s that you have out there that have made various compromises in order to create a more provable EVM.
Type 1 EVM makes no compromises and sticks to the original Ethereum specification, but still produces this snark that succinctly verifies that the EVM computation was run correctly. So the other ZK EVMs that we've talked about many times before, the ones that Polygon are building, the ones that MatterLab is building, the one that Scroll is building, you differentiate that and you'd say that's not a type one EVM because it's a little bit different in some way. Is that correct? And how is it different exactly? They're all different in different ways. And they often change exactly how things get mergulized, how state's stored, and they generally tend to implement all the opcodes.
I don't know, Justin, do you want to expound upon that? Yeah, so generally speaking, what will happen is that they will want a Solidity developer and Solidity code to be reused. That's kind of one of the main goals. And so they're going to reimplement every single opcode, but under the hood, under the bonnet, they're going to be taking some shortcuts to optimize things. And one of the prime shortcuts is to change the way that the storage is Merkle-ized. So today we have what's called a Patricia Merkle tree, which is using this Ketchak hash function. There's all sorts of technical terms just to say that the way that we handle storage is very much non-SNARK friendly.
And so what these teams have done is they've just taken a completely different approach to authenticate and Merkleize the state. Another possible difference is changing the gas schedule, right? Because the EVM gas was designed from the perspective of CPUs. If a certain operation takes 100 nanoseconds and another one takes 10 nanoseconds, then the first one should be roughly 10 times more expensive from a gas perspective. But the gas schedules don't translate very well to Snarkland. So you could have a very, very cheap instruction on the CPU. For example, doing a hash like Ketchak, that's extremely fast on the CPU.
But if you were to do it in snark land, it's extremely expensive. And so in order to protect themselves from these denial-of-service attacks, where someone can craft a block with lots and lots of catch-ack and basically mount a denial-of-service attack on a specific roll-up, they've adjusted the gas schedule. So it's not exactly compatible with the EVM that we have today on mainnet at layer one. So because of those changes, because of those, you know, I guess optimizations or differences, these type two ZK EVMs are not candidates to become an enshrined roll up, at least in their existing form.
Is that correct? And this, a type one ZK EVM is closer to a candidate to becoming an enshrined roll up. Am I making that connection correctly? yeah that's exactly right um but what i'll say is that oftentimes like these are journeys right they start somewhere and then they incrementally become more and more compliant with the evm i mean this even happened with optimistic rollups right at first they had these small modifications relative to the evm opcodes and then they said no we want to be exactly equivalent with the EVM opcodes. And this journey is going to happen for the ZK EVM rollout implementations, I believe.
And part of the reason is that you get to benefit from a lot of tooling, from a lot of standards, from a lot of network effects. But the trade-off here is that it's much, much harder from a technical standpoint. But what's happening and is kind of magical to see in front of our eyes is that the technology is improving at an extremely fast pace. We kind of have an equivalent of Moore's law for snark improvements. And I don't know what it is, but it's something like, I don't know, improving by 4x every single year. So give it a few more years. Can we make a Drake's law here, please? I want a law.
It's a Moore's law with another Moore's law on top of it. Okay. Right. Yeah. Okay, okay. Um, so this is, uh, about the limit of my technical proficiency here. And I'm, I'm wondering, uh, Justin, if you could sort of, what questions do you have for, for Brian here actually about how this works? So we're talking about this type one ZK EVM. We've, we've fleshed out the rough contours of what this actually is, but I think this has an impact on a lot of things on, on bridges. We talked about enshrined roll-ups, multi-provers, you know, there's the performance conversation, security licensing type of conversation.
Why don't you take some of the technical details here and maybe I'll come back and ask the dumb questions as they arise in my mind. Perfect. Sounds great. But I guess I do have one non-technical question, which is a little bit about context setting, which is that it seems like you guys were in stealth mode for a relatively long amount of time, maybe a year or two. And a few days ago when you made the announcement, Vitalik was messaging me and was like, who are these risk zero people? Are they doing good work? Can they be trusted, et cetera, et cetera. And if Vitalik is not aware of you guys, maybe the listener is also not aware of you guys.
And so I guess my question is, what prompted you in the first place to build a ZKVM? Normally, when you build ZKVM, it's because you're aiming towards a roll-up, but my understanding is that you're not aiming towards a roll-up. So what is the background here? Yeah, I mean, so RISC-0 got started with this idea of building out general-purpose ZK capabilities. So this is the ability to actually prove any computation. So not just the EVM, like an existing game. You could prove Doom. You could prove Linux. People are actually using this to prove execution. of Linux. So ECC, not this past one, but two years ago, or two ECCs ago, I was talking about the fact that, you know, in my mind, the best way to build a CKEVM was to actually just take the code that people have already written, and then run it in this sort of general purpose context, because you don't actually need to then engineer all these hundreds of circuits.
So basically reduces the the amount of capital required to actually run an EVM and produces a world where the proofs that you're creating are very much in line with the clients that created them. So yeah, I would say we've been thinking about doing this for a long time. It's just getting the sort of technical requirement, getting the technical capabilities over the line to the point where we could do this. We really just got there like two months ago. So then as soon as that happened, we're like, okay, Now we have to actually try to make the EVM real, the Type 1 EVM. And it turns out it was fairly straightforward once we got the extra year of engineering done to get the sort of continuations and long-running proof feature to work.
And Brian, this is maybe the flash of lightning that Justin is referring to because Rosira just came across my radar last week as well. And David was like, hey, I'm going to be out. He's at Burning Man, actually. So I'm going to be out next week. Ryan, you should go talk to these people and see what's going on. And this is the tweet. Introducing Zeth, a fully open source type 0 ZK EVM built on the risk 0 ZK EVM and Bonsai. Zeth is a performant, upgradable, and scalable way for developers to ZK prove any Ethereum block, ushering in the next generation of ZK and EVM. So pretty big tweet thread to splash in the world.
And yeah, that's part of the context for this conversation. All plus one, Justin is like, we want to find out what you guys are doing. What's going on here? Yeah, so the type zero thing is definitely a joke. So I might have brought some people the wrong way. But the idea, like it's a type one EVM, but you didn't have to do, you did zero work to make it work. Because we just utilized all the hard work of everyone else in the space to create this platform. It's not entirely true. We had to change some of the ways like the Merkle Patricia she works to make sure it's like more snark friendly or stark friendly.
And then we also had to modify a bit of the database back end. So it's definitely required some brilliant work by some amazing engineers, but like a month and three people to get this over the line. Now, you know, there's tons of room to increase the performance of the system and all kinds of things like that. But we really have gotten to this kind of of base level of now we can actually ZK-proof Ethereum exactly as is. So if I were to summarize, it sounds like you guys started off very much as a technology company, focused squarely on snarks and snarkifying the world. And you have this really interesting approach, which I guess we should dig into, very interesting technical approach.
but in our in our prequel yesterday um one of the things you mentioned was that there was some sort of partnership maybe with another rollout projects maybe the the optimism project and that little piece of nugget was kind of interesting to me because it kind of what created the bridge between the technology company and more so like the the crypto or the ethereum company yeah i mean we've been talking to OP like on and off for a while because this idea that you can take ZK and sort of create fraud proofs as soon as you can ZK prove something you can also ZK prove that something is different than what other people said it is so you have this kind of ability to automatically create a fraud proof if you if you have a ZK provable system so we've been chatting with Optimism for a while they eventually decided they were going to send out this like RFP or mission for people to actually zkify the OP stack.
And us and Mina and a couple other teams all applied. And our solution was very much based on the preliminary work we'd done on Zeth. We realized rather than, you know, taking this very complex fraud-proofing system, which is an amazing work of engineering, but kind of sidestepped it and said, let's just take the OP ref in development libraries and just create a way to zk-proof those, which effectively provides a fraud proof mechanism because now you can prove, well, once it's done, which will be in the near future, you'll be able to prove that an optimism block is, there is not a different, different from what the chain actually agreed on.
So we're going to actually see, I think in the near future through this partnership with optimism, the ability to get, you know, liquidity much faster than seven days or move your assets around and access your money. So yeah. And this gets to sort of what you were saying about the magic of Snarks and being able to, you know, in the distant future, have Ethereum itself be fractally hyperscaled, however you want to put it. Right. So I think what is partially going on is that Optimism as a project, which is, you know, an optimistic rollup, is thinking down the line of upgrading to a ZK rollup. and they submitted this request for proposal where they're saying, okay, anyone in the world, if you can help us snarkify optimism, we're going to give you money.
Now, I had a look at the grant, kind of the request for proposal, and it was 250,000 OP tokens, which at current price is about $375,000. Now, the reason I mentioned this is because if you had asked us two years ago to come up with a prototype, a proof of concept for a type one ZK-AVM with open source code running on the cluster of GPUs, that would have cost millions, if not tens of millions of dollars. And for now, for half of a million dollars, we have this new team coming forward and providing technology. And I think one of the key tools used here is abstraction. There's this massive shortcut that was taken.
And so there's various pieces of the puzzle. And the way that I think about it is that there's three steps. You start with an existing FM client, in this case, Ref. And then there's this new intermediate step, which is risk five, which I guess it would be good for you to describe what exactly is risk five. And then there's kind of this final step towards getting a snark. And it seems like actually that there isn't much work going from the client to risk five, almost no work. And then same thing for going from risk five to the snark. So can you describe these three steps and the work involved in getting from one?
And really quick, RISC-V. What is RISC-V? We know what RISC-0 is. It's a company. Right. So RISC-0's name comes from RISC-5. And RISC-5 is an open source instruction set architecture for actual microprocessors. So people familiar with like the Apple M2 or ARM or x86 or MIPS, you know, these are actually instruction sets. So similar to the EVM, they have opcodes that tend to be, you know, there are opcodes that can actually be reified in hardware in a reasonable manner. So x86 has, you know, hundreds, thousands of them. So it's a complex instruction set architecture. But then you've seen the shift towards ARM and MIPS is very old.
The RISC-V is kind of the spiritual successor to MIPS in a way. So it's a very small set. Well, it has a couple of different dialects. but you can boil it down to about, I think, only 40-something opcodes at its core. So what we've done is created a ZKVM. So it's not an EVM. It's the same idea, except what it does is process these much lower-level instructions. So there's not really precompiles or anything like that. There are escape patches that you can use. So there's this core, very minimal set of computing instructions that RISC-V sort of publishes. And people can actually take Sci-Fi, the company that invented it.
You can just get a spec from them and you can put RISC-V cores into whatever project you're doing. So almost every computer that's shipping now does have some number of RISC-V cores somewhere in the sort of bigger chip. So most chips, anything people think of as a CPU or anything like that is really a system on a chip that probably has 20 different cores in it. So, anyway, by doing all of this, we've taken the ability to ZK-prove something and said we're going to be able to ZK-prove anything you could run on a normal processor. So, the reason that sort of going from RISC-V to ZK-proving a RISC-V was something we surprised the ZK world with at least about a year and a half ago when we released this.
I think, you know, the time Ellie had said that he, Ellie Vincent from Starquare, thought that, you know, general purpose ZKVM was at least five years out. So this is another example of ZK kind of just happening much faster than people would otherwise expect. So by focusing on this minimal set of instructions, we were able to create a very performant ZKVM. and most of the work to translate from anything else into RISC-V has already been done by the RISC-V development community and by the LLVM compiler community. So we're really just leveraging the network effects of open source software to take, as Justin said, a massive shortcut to get to ZK proof of Ethereum.
So basically there's two translation steps or kind of compilation steps that need to happen. and it turns out that the Rust programming language by default today already allows you to compile to various CPUs. So when you have a Rust program, you can compile it to x86, which is a lot of Intel machines run on this. You could compile it to ARM, which is a lot of the new Macs and a lot of phones run on ARM. But you can also compile it to this more arcane, but still kind of popular enough to be supported instruction set, which is called RISC-V. And so there's basically all the work has been done to go from Rust, which is, for example, ref, which is written in Rust, to RISC-V.
And then there's this one-time step that needs to be done to go from RISC-V to a SNOC. And this is the heavy lifting that Brian and his team have done, but it's a one-time thing. And so now we can kind of take any Rust program that we want and kind of reap the benefits of abstraction. So now the normal, the current, I guess, the traditional paradigm for snarkifying things is to work very, very close to the metal, very, very low level, right? You have a program that you want to snarkify and you're going to kind of jump through lots of hoops and kind of work with these polynomials and very low-level programming languages, partly because there isn't much tooling, but also partly because you need the performance of these really low-level optimizations.
But one of the things that's happening is that we're getting more and more powerful abstractions, which means that as a developer, you can work with higher and higher-level programming languages. And Rust is an extremely kind of high-level and friendly programming language. And within the blockchain space specifically, It's extremely popular. And in combination, we're finding all sorts of optimizations, both kind of at the software, the hardware level, to make this palatable. Like maybe we should move to performance, which is that back then, we could have said, yes, you can go ahead and do it, but it will take days to produce a proof for an Ethereum block.
What kind of performance do you guys have? And how did you get there? Yeah, so the performance varies based on which kind of hardware, actual hardware target you're running the ZKVM on. So we support CPUs, we support the M.2 GPU, and we support NVIDIA GPUs as well. So getting to this level of performance has been a multi-stage journey. And honestly, there's a lot of room for us to get even more performance out of it. But one of the early choices, the reason we use this particular subset of this 532-bit instruction set is because it lets us operate in the sort of smaller prime field, which is much more amenable to being accelerated on GPUs.
And specifically, I think interesting to the sort of Ethereum space and blockchain in general, you know, this smaller field means you don't need these massive, crazy ZK-proving rigs anymore. You can actually do ZK-proofs using like a 16-gigabyte desktop GPU. So that actually, so we built a proof system that could run in these really small kind of consumer grade cards. However, then that had some other kind of downsides, like you couldn't run giant programs. So we built this system called Continuations, which is like folding, you've mentioned a bunch. So it's a way to take proof and split it up into a bunch of small proofs and then let a bunch of different parties effectively prove bits of them and roll them back up into one single proof.
So getting to this level of performance, we had to optimize the recursion circuits because taking 1,024 proofs and rolling it down into one proof takes 10 vertical steps of recursion. And then beyond that, we had this ability to actually run the proving computation itself, as I mentioned, on a GPU rather than a CPU. And we see pretty significant gains for that, but we're just really kind of scratching the surface because we haven't. We focused on enabling everything, which is kind of our core thesis. Let's do the general purpose thing, let people actually prove something, and then we can focus on the performance where it matters.
So, yeah, it's been a combination. On that performance, so Justin, kind of like the intros, we're exploring this throughout the possibility that someday we could run an Ethereum, a snarkified Ethereum validator from our smartwatch. It sounds like there are a lot of performance steps necessary to get there. And I'm curious, like, how close are we? So is what you're saying, Brian, that right now we could run what you've developed, which is this ZK Type 1 EVM on a home consumer laptop? This is a pretty beefy laptop. And then how many steps away are we from getting that to like a smartwatch? Well, so proving, I don't think you're going to, when you end up in this sort of enshrined roll-up world, you're not going to have the proving be done on the smartwatch.
The proving was done by these machines off in the cloud or in this decentralized network. And then the verification, because your SNARK or Stark, they're really small, the SNARK especially. And it takes literally fractions of a millisecond. So the computing power to verify the SNARK is there. And then once you have data availability sampling, you really just don't need that much information to actually participate fully in the network. So you can have a very light, light line. So then why does performance matter so much? Oh, performance of the proving system? Yeah. Effectively, it gets down to how quickly you can make these sort of EVM blocks, right?
Like right now, it takes us, if we use 64 of these off-the-shelf machines, it takes about 50 minutes. And I think there's probably an easy 10x there. But if you use even more machines, we can get down to 12 minutes. But realistically, if you want this sort of enshrined roll-up, you need to, what did you say, Justin? Two seconds. If the use case specifically is being a validator, then when a new block comes in, you want to know that it's valid a second later. Basically, the latency, the proof latency, the time it takes to generate the proof should be on the order of one second. And today, we're not there yet.
We're maybe 100 to 1,000x. So let's say 2.5 orders of magnitude away from getting there. And so performance matters for two key reasons. One is this proof latency that we, you know, for some use cases, we don't really need the low latency, but for other use cases, we do need the low latency. And the other reason is just diminishing the size of the prover. So nowadays, if you want to be a prover, more likely than not, you're going to rent out a rig of GPUs on AWS. You know, Brian was talking about 64 GPUs, I believe, on AWS. US. And that's not super friendly to a decentralized proving network of people at home.
And so what we partially want to do as well is kind of shrink all these 64 GPUs into like a small box. And the way to get there, in my opinion, I'd be curious what your opinion is, Brian, is to have snark acceleration. So we went from CPUs to GPUs. And then the end game is to go from GPUs to ASICs. Yeah, I mean, I think I still think even when you get to the ASIC level, you're still going to end up like when you have a huge decentralized network of provers, maybe these ASICs are even in people's phones. You're still going to end up splitting, you know, proving an entire block, probably up over, you know, hundreds or thousands of nodes.
So I think parallelism is critically important no matter what, but the ability, now that we've sort of shrunk the requirements of the prover down to where it is, I think the ability of hardware acceleration to really make a difference is actually there. I was pretty bearish on hardware for the first year of the company's existence because I didn't think I didn't think people were going to be able to do better than NVIDIA. It's really hard to do better than NVIDIA with their sort of GPU performance. But the stuff I've seen coming out of several hardware teams recently is really I think there's going to be.
the ability to get to gigahertz level GPU, sorry, gigahertz level ZK proving through ASICs in the five-year timeframe, let's say. Three to five years. Yeah. Okay, so if I were to try and summarize, where does this performance come from, which is, just to recap, it's like a 10-minute, roughly speaking, 10 minutes to one hour proof latency. It comes from three different types of tricks. One is on the proof system itself, where you move to this different type of so-called finite field, which is 32 bits as opposed to something larger. You've leveraged the GPUs, which, as you said, NVIDIA does a great job with their GPUs, which are used for AI, but can also be used for SNARKs, which are also extremely compute-intensive.
and then there's this final really beautiful trick which is basically recursion where you take a big chunk of computation you cut it up into much smaller chunks and then you do the proving for each small chunk in parallel and then you kind of reassemble all the pieces of the puzzle and all of that can be parallelized and distributed very well said are you a metamask user? well you're listening to bankless so of course you are the wallet you know and love just got a whole lot better metamask portfolio is the ultimate one-stop shop for all of your crypto needs. It gives you a holistic view of your crypto portfolio across multiple chains and multiple addresses all at once.
You can easily view and manage all your coins, tokens, and NFTs in one convenient place just by connecting your wallet. Metamask Portfolio goes beyond just viewing your portfolio, though. Inside the portfolio, you can do all the incredible money verbs that make DeFi so powerful. You can buy, swap, bridge, and stake your crypto assets with ease. It's like having a powerful battle station for all your DeFi moves. right at your fingertips. So if you're looking to do more in Web3 your way, MetaMask Portfolio is the answer. I already know that you have a MetaMask wallet, so go check out your MetaMask Portfolio.
Learn more at metamask.io slash portfolio. Introducing ETHX from Stater. ETHX is a liquid staking token designed to maximize rewards, all while securing Ethereum. With Stater, you can run an Ethereum node with just four ETH, which is 85% lower capital and 35% higher returns versus just solo staking. Stater has a multi-pool architecture with both permissionless and permission node operators to enable decentralization and scalability. Stater has extensive experience in building liquid staking solutions on six proof-of-stake blockchains and is trusted by over 70,000 stakers. Stater has partnered with over 40 leading protocols on these chains to bring DeFi utility to their liquid staking tokens.
Stater is actively building integrations and partnerships across Ethereum to bring the same great DeFi utility to the ETHX token. While smart contract bugs are always a risk in DeFi, the ETHX smart contract has received three independent audits and has a million dollar bug bounty with Immunify. Go to staterlabs.com slash ETH slash stake to access the stater staking protocol today. You know Uniswap. It's the world's largest decentralized exchange with over 1.4 trillion dollars in trading volume. You know this because we talk about it endlessly on bank lists. It's Uniswap. But Uniswap is becoming so much more.
Uniswap Labs just released the Uniswap mobile wallet for iOS. The newest, easiest way to trade tokens on the go. With the Uniswap wallet you can easily create or import a new wallet buy crypto on any available exchange with your debit card with extremely low fiat on-ramp fees and you can seamlessly swap on mainnet polygon arbitram and optimism on the uniswap mobile wallet you can store and display your beautiful nfts and you can also explore web3 with the in-app search features market leaderboards and price charts or use wallet connect to connect to any web3 application so you can now go directly to d5 with the uniswap mobile safe simple custody from the most trusted team in d5 download the and Swap Wallet today on iOS.
There is a link in the show notes. Now, I guess the next big topic in my mind as an Ethereum researcher and thinking of type 1 ZKVMs is security, right? We have traditionally a lot of complexity going on here. And, you know, the likelihood for bugs is very, very high. And I have this saying, you know, which is maybe, I guess, a little arrogant, but I believe that every single ZKVM has multiple critical vulnerabilities. today. And so we need to be prepared as a community to either have mitigations to these bugs, and there's a lot of very good ideas. And we also, unfortunately, need to be prepared to roll-ups getting hacked.
So just like we've had a bunch of fairly large roll-up hacks, sorry, bridge hacks on the order of hundreds of millions of dollars, maybe close to a billion dollars uh we could have multi-billion dollar hacks uh in the in the zk roll-up space and so i'm curious how do you think of security and how do you think of removing every single bug from the system yeah so obviously a huge topic um so me and my co-founders actually know each other we met 23 years ago in the seattle like infosec scene so we were all like hackers back in the day so we have a pretty deep set of sort of experience and knowledge in this space.
And that's part of the reason we chose RISC-V also. It actually has like, there's a full formal specification for it. You actually can prove that certain systems, formally prove that certain systems implement RISC-V. We haven't gotten to that level of sort of formal verification with what we're doing yet, but you can imagine getting to the place where you have very strong guarantees guarantees that the ZK system itself is proving risk five and only risk five and that and that the sort of conjectured amount of security number of bits of security is actually you know is actually what we think it is so there's a lot of work on the mathematical side to sort of prove that the crypto system itself is like the proving system is actually doing what supposed to.
Separately, you then need to audit, as you mentioned, the actual ZK circuits. And I think that's an area where this approach really shines is that because the RISC-V instruction set itself is small, it means there's much less surface area to audit. Although we do have these sort of acceleration circuits that one can add on to the system, it still doesn't increase the sort of audit surface of the ZK part to the same degree that, you know, doing a ZK EVM from scratch would. Now, you're also, I think as you pointed out in the pre-call, by doing this, you are potentially onboarding a few more security considerations.
For instance, you're trusting the Rust compiler and you're trusting LLVM. Now, these things, and there are often bugs in LLVM. I think we just found one the other day. So compilers, especially for new architectures, aren't perfect. But this is one of the reasons, again, why we chose an existing architecture. I don't think ARM or something older, more mature would have really fit in a ZK circuit. But by choosing an existing architecture, we get to leverage all of the billions of dollars of investment that's gone into the security of this existing ecosystem. Gotcha. So if I were to summarize this kind of this final step where we go from RISC-V to a SNARK, which is actually fairly digestible because RISC-V is relatively simple.
Actually, this reminds me of Cairo from Stockware. They have an even more kind of reduced instruction set, which is super simple. And what they've been able to do is apply some of formal verification tools to prove that things are working properly there. And the hope is that this one-time investment, we can really drill down with powerful tools like formal verification and prove that it's correct. And then we kind of have the rest of the can of worms, which is kind of this fairly complex compiler to go from Rust to RISC-V. And it's possible that there's bugs, generally speaking, in the Rust compiler.
But it's also possible that there's bugs specific to compiling to RISC-V because RISC-V is one of the more niche instruction sets that you can compile to. but what might happen is that we're going to start building these roll-ups you know which are securing billions and billions of dollars and then lindy starts to kick in and you know we might have bug bounty programs and it's kind of interesting where in a way the blockchain space might make a huge contribution to compiler security it's going to be way more eyes we recently had this bug right in the Viper compiler and that caused a bunch of bugs.
And it would be great if we could apply similar tools like formal verification to compilers like Rust compilers, which today sounds very grandiose, but maybe the blockchain use case is so security critical that we're going to try and move forward partially in that direction. Yeah, I mean, people have done this for C and if you're going to do formal verification for C, then Rust is probably also within the bounds of what's possible. But these efforts take decades or a really long time. But blockchain accelerates everything to an obscene degree. ZK would still be like a niche academic pursuit, I think, if it weren't for blockchain needing it so badly.
Okay, great. So I guess the final kind of semi-technical topic that I have is around licensing. So if we are going to be using a piece of code at layer one, really for it to be kind of palatable, socially palatable, I guess, the licensing needs to be good. And I guess the kind of favorite types of licenses that we have might be Apache 2.0 and the MIT license. Can you discuss what have you open sourced and under which licenses? Yeah, so the sort of core RISC-0 ZKVM. So the RISC-V proving engine, that's licensed under the Apache 2 license right now, always has been. And then ZEV itself will probably be Apache 2 slash MIT licensed.
We might also end up dual licensing everything because that's kind of the standard in the Rust community. And OP is a fan of MIT. So that's for the system that produces and takes the EVM program and chunks it up into a bunch of little proofs and then proves all of those. The parts we haven't yet open sourced or released is the part that actually takes all those proofs and recurses them down into a single proof. And then also this thing that converts the Stark that we use into a Stark. So there are two kind of aspects of this that we haven't launched. And effectively, we're waiting for these things to get through security audits.
With the current system as is, you can't really, the proof's much too large to put on chain. So it's kind of hard to get wrecked because you can't actually use stuff on chain as readily. So right now, if people want to use the system, we have to get an API key from us. But that's definitely not the direction we're headed. We're very much committed to fully open sourcing the entire system. But we want to make sure we have high confidence that people are not going to get wrecked soon because of the ZK system. Okay, understood. So you've open sourced several key components on the very attractive license, Apache 2.
0. And you're thinking of dual licensing it maybe with MIT so you can choose which license you want when you start using the code. and like part of the prover is already open source but maybe some of the final things involving the recursion and kind of the wrapping it into a tiny tiny proof so that it can be consumed on chain that's not yet open source right yeah exactly so brian um risk risk zero seems to have come out of nowhere and uh you know it's it's super incredible how fast all this is coming to bear here. And like open source working, it sounds like first to kind of snarkify our favorite L2s out there, like working with Optimism and others.
So I imagine that's going to be a bulk of the work at first. What are you guys planning to do here? Like what's the business model for risk zero? It almost sounds like what you're producing is a public good. And here, Justin and I and the rest of the bankless community are kind of cheering you on. But I'm sure you have investors. I'm sure you have VCs here that have put some money in and they're going to expect some kind of return. Yet you're not building a layer to yourself as of yet, it sounds like. Or maybe you will. So, yeah, tell us what Risk Zeros is put on earth to do. What are you planning to do in this space?
Yeah, in this space, we're really focused on the spawn sides. ZK application development platform. So there's something we've been working on for a while because you can use ZK for all kinds of things. I don't know how you've talked to like many of the ZK co-processing teams, but you can use Bonsai effectively the ZK co-processor, which lets you run a bunch of complex logic off-chain and then just attest to it on-chain. So we, like at Denver, I talked about like a L1 club effectively running an order book on Ethereum directly at Uniswap. You can achieve roughly Uniswap level pricing by doing all of the order book matching off-chain.
So you have your orders, the orders get placed on-chain, and then Bonsai sort of just reads those orders, does all the matching in ZK just on one machine, any random corner of the internet or AWS, wherever you want it to be, and then says, okay, here's proof that these are the orders that got matched at this price. So Bonsai is kind of a platform for ZK snarkifying apps, maybe, let's call it. Apps and rollups, anything really. So we expect right now it's a centralized SaaS offering and we think there's long-term value in sort of providing an enterprise sort of open core model there. But we will definitely be building a decentralized network around that as well.
Exactly what that looks like, who knows. It's going to be very focused on the sort of core accounting for proving tasks. So kind of like a proof marketplace, but we expect that it will add interesting features for application developers over time. Because there's this ability with continuations to do sort of ZK Docker. You can prove something up to a certain point, you can suspend the thing, and then you can just keep going on later. So you can kind of imagine having a ready-to-go EVM image where people can just resume it and they have full access to the Ethereum state. Is this like a sort of an AWS for ZK proofs kind of thing?
Or is this like a marketplace here and you're looking to try to make it as decentralized as possible? That could be a future here? Definitely. I mean, this is like when we got into... I mean, Jeremy, our chief scientist, is just always into AI and ZK and all of these things. But when we started really thinking about what we're going to do with it, the thing that really got me excited was the potential of this technology to kind of let people who are building infrastructure and applications not need to rely on, you know, Facebook, Amazon, Microsoft, Google for everything. So this idea that we could actually fully decentralize the sort of infrastructure that goes into many of the applications we use has always been really appealing part of what this technology is capable of.
So I think Bonsai is going to be a platform that helps people do that. So Brian, what do you think happens next in kind of the roadmap? So all of this seems to be happening faster than we all thought it would, which is so incredibly exciting. The level of investment in the space and the level of talent in brains now being focused on crypto is just absolutely astounding. We almost ended the episode with one of the last parts, which I think is, of course, the public good that is Ethereum mainnet. That will upgrade to a fully snarkified, enshrined ZK EVM, probably last. We're going to want this fully proved out in all sorts of ways across crypto before we get to that stage.
So I'm wondering, what do you think will happen in the interim over the next six months, over the next one to two years? How do you think the tech that you're building will start to impact the crypto landscape? Will we just see ZK snarkified layer two? Should we expect to see this technology applied mainly in rollups? Are there apps that you see this being applied or will it take a few years? Yeah. All of the above. We're definitely working with, you know, L2s, L3s, rollout frameworks, however you want to think about all of that space. And also, you know, we're working with people on DeFi projects and eventually gaming is going to be a big part of this.
The way I see this playing out is, you know, just like friend.tech kind of surprised everybody with how much better the crypto onboarding experience has become. And sure, there's still a lot of room to go. So I think the headway that people have been making in making crypto applications easier for people to use is going to then also increase demand for the capabilities of these systems to be able to do more and more interesting things. So I think we'll see ZK playing a critical part in all of this by enabling people to do whatever computations they want off-chain and readily attest to them on-chain.
So sort of ZK co-processing architecture is going to be a huge mark for applications built and yeah, for Web3 applications. Well, this has been great. Justin, do you have any other questions for Brian or should we start to close this out here? I think I have one final question, which is around, you know, your alignment with Ethereum. Like, I think we had, you know, during the pre-call, it sounded like as an individual, as a person, you were in this space for quite a long time. And, you know, you have a certain set of beliefs. And I'm curious what those are, but also how this translates into the culture of the company.
Yeah, I mean, our sort of core three core values are like integrity, transparency, and agency. an agency. And I think, you know, if those aren't like Ethereum aligned, I'm not really sure what that sort of even means. So coming out of the sort of hacker culture that, you know, the founders came from, it just seems like a very natural sort of fit to the, to the sort of ethos of Ethereum. So I think value wise, yeah, we're really the, the vision of the sort of hyper structure world of the future is very much something we all resonate, like very deeply resonates with all of us. Brian, what first brought you down the crypto rabbit hole?
You know, buying supplies for Burning Man. That's funny, as my co-host is literally at Burning Man right now. Fantastic. No, but it's been a crazy journey. And so it's really fun to get more and more into the space. Yeah, well, very good. And maybe my last question is kind of the high level to Justin. So this idea of hyperscaling Ethereum using kind of like fractal crypto proofs, ZK proofs on top of ZK proofs. I mean, has this always been part of the plan or is this just happenstance? And I guess when you think of the term hyperscaling, how do you envision Ethereum looking five years from now?
Is all of this stuff just kind of working? and what's the total transactions per second? I don't know. What's the sci-fi Ethereum with this tech applied? How does that look, Justin? Right. So, I mean, if you want to think in terms of end games and fundamentals, you go back to these fundamental resources, computation, that's just not going to be a problem of consensus. And the way that I think about it is that consensus is this very flexible tool that can solve all sorts of problems. And then cryptography, what it does, it gives you a few superpowers that allows you to reduce the scope of consensus and basically have more and more crypto and less and less economics, if you will.
And historically, actually, one of the big breakthroughs for consensus was simple message authentication and signatures. that kind of changed the model where you had these messages that could be intercepted and modified, but that didn't really matter because they were kind of signed and authenticated. And so the model was, what can you do with consensus given signatures? And now we kind of have this new tool, which is much more powerful from a cryptographic standpoint, which is what can you do with consensus, with snocks? And it turns out that the things that it needs to solve our data availability and finality.
And it turns out that data availability is something that we can solve with data-based sampling, as I mentioned. And then there's this other thing, finality, which I only discovered recently, you can also solve with cryptography, with these really, really sophisticated pieces of cryptography called one-shot signatures, which actually marry quantum mechanics and cryptography. And so then you can ask ourselves, okay, what is consensus useful if cryptography solves all these things? Well, it turns out that the last thing that's still not solved is this concept of liveness. How do you make sure that the chain just keeps on going, even if validators just don't show up?
For example, if there's World War III and 90% of the population has gone. and this is kind of cool because we're reducing and reducing and reducing the scope of consensus and we're kind of hardening the rest with pure cryptography and physics and mathematics it's a very long journey to get the one-shot signatures because we need these quantum computers but in the meantime we're going to enjoy the spoils of of snarks which are extremely significant Well, it seems like we have entered the snark era for sure. And there's going to be a lot of that applied to crypto in the future. So Brian, Justin, thank you so much for guiding us on the tour today.
It's been much appreciated. Thank you. Thank you. Bankless Nation, risks and disclaimers. Got to let you know, of course, none of this has been financial advice. I don't even think we talked price in this whole episode, so obviously not. Crypto is risky, so are compilers, so are new layer twos. You could lose what you put in, but we are headed west. This is the frontier. It's not for everyone, but we're glad you're with us on the Bankless journey. Thanks a lot. you