Ethereum 2.0 [Danny Ryan]

Download MP3
What is Eth 2 and what is The Merge?
  • Eth 2
    • Beacon chain went live in Dec 2020
    • 4.5m eth locked 
    • Each validator 32 eth
    • Validator job: randomness generation, finality, validator level transactions (attestations, deposits, onboarding)
  • The Merge
    • Eth1 has an application layer and a thin consensus layer (PoW)
    • Post merge - beacon chain will drive applications going forward
    • Eth2 keeps everything about Eth1 clients and swaps out the consensus
  • Why not fork?
    • difficulty bomb
    • applications atop Eth are much more substantial now

[00:00:00] swyx: This week, we're diving into Ethereum and other cryptocurrencies. Don't worry, this isn't about to become a cryptocurrency podcasts, but I still think it's a pretty interesting topic. And there's a lot of interesting research that is not just price hype, but actually serious innovation in terms of distributed systems and crypto economics.  

[00:00:19] And I've been storing up a bunch of podcasts related to that, that I figured I would get through it now in one block.  

[00:00:25] So today I wanted to feature this conversation on the epicenter podcast with Denny Ryan, Danny is from the foundation and works on Eve too. And he explains what these two is what the merge is going to be like as well as what the incentives are for the community to stick together rather than have hard fork like they did last time with Eth classic.  

[00:00:43] Danny Ryan: Eth2 is a series of major consensus upgrades for Ethereum aimed to make the protocol more secure, more sustainable, and more scalable. And at the core of that is the move from proof of work consensus to a proof of stake consensus. 

[00:01:00] So instead of securing the network with mining hardware and energy consumption, securing the network with the tokens itself the ether. And so at the core of that is the bootstrapping and the creation of this new consensus mechanism. And what as you mentioned, is live today is what we call phase zero. 

[00:01:18] And that went live in December of 2020. And that was really the bootstrapping of this new proof of stake consensus mechanism. That is called the beacon chain. So in December tons of Ethereum community members and different institutions put a bunch of ether as capital and collateral into what we call the deposit contract and kickstarted this new consensus mechanism called the beacon chain. 

[00:01:42] The beacon chain exists in parallel to the current theater network. So in parallel to the proof of work network, which is still securing all of the assets and applications and contracts and accounts today. So we have on the one hand and the proof of work network chugging along and on the other hand, this new consensus mechanism called the beacon chain existing in parallel to this building and securing it. 

[00:02:07] I think today there's something like 4.5 million ether locked and secured in this chain. I don't know what that's worth today. It depends on the minute and the hour. This thing exists, this thing finalizes itself, this thing builds itself. But ultimately what it does is it just builds and secures itself. 

[00:02:26] And this is by design. This is an iterative path to get rid of the proof of work and to move Ethereum to this new consensus mechanism, obviously it, there may not as used by tons of people secure as tons of value. And there's a lot at stake in this operation. But what we've done is built it in parallel vetted it in production dozens, tons of tests live. 

[00:02:49] And now what we're working on is actually the deprecation of the proof of work consensus mechanism in favor for the slide proof of stake consensus mechanism. So that's where we're at today. There is a proof of stake, consensus mechanism, bootstrapped live securing tons of value, but really just securing itself in isolate. 

[00:03:07] Martin Köppelmann: Then let's deep dive into what it exactly does. So, right now it comes to consensus on what? 

[00:03:13] Danny Ryan: It comes to consensus on itself and it's by itself. What I mean is the proof of stake, consensus mechanism and all of the little gadgets and things in it. So it has a validator set. Each validator is worth approximately 32 eith. 

[00:03:26] So there's something like 140,000 validator entities in this consensus. Each one of them has like its own little state. It has its balance. It has duties. It has like a job at any given time. It has randomness generation. It has information about finalities. So which portions of the chain are finalized and will never be reverted. 

[00:03:47] And it has a lot of just various accounting between finality and kind of the head of the chain. So there's a number of operations related to the functionality of this chain. And those operations are what we call validator level transactions. So system level trends. And really what it does is there's a core operation called attestations where validators are constantly signaling what they see as the head of the chain and what they see as their local state of the world. 

[00:04:14] And they use these messages to come to consensus with each other and ultimately drive this core like system layer of the chain. There's some other operations related to validate or activity like deposits, onboarding, new validators exits leaving the validator set, and a couple of other things. 

[00:04:30] So really it's like this, it's a proof of stake system and there's a lot of different accounting, different little operations going on and it builds and it comes to consensus on itself. So 

The Merge

[00:04:39] Friederike Ernst: maybe let's talk about the merge for a little bit. There would be the merge and the merge with merge each one into the beacon chain. So how exactly does it happen? When is it going to happen? I imagine either one in east who have separate states, how is that handled? How do you make them congruent? 

[00:04:55] Danny Ryan: So let's think about what Eth1 is. Eth1 is, and this is a construction for each. One's a lot of things, and there's a lot of different ways to think about it. 

[00:05:04] But for the purposes of the merge, we can think about it in two layers, we have this application layer or this execution layer where all of the users hang out. It's where all the applications are. It's where the user layer state is. It's where transactions are being processed. Right. It's really like what I, as an end user care about, I care about, you know, my unit swap trades and that kind of stuff. 

[00:05:27] And then you have this thin purple work consensus module that's driving. It's really like providing the services, providing the quality the it's riding the service to this execution layer. It's the cradle for blocks. It's providing guarantees about reorgs and different things like that. 

[00:05:42] And what we have is really these two layers. We have the preferred consensus layer providing the application layer to services and to users. And then what we've bootstrapped in production today is the beacon chain, which is a proof of state consensus. And the idea really here is for, at one point in time the proof of work module to be driving that application layer and that the next point in time, post-merger that proof of stake module, that beacon chain to be driving the same execution layer, the same application layer. 

[00:06:16] And so the transactions, essentially the cradle of Ethereum right now is these like proof of work blocks and that proof of work consensus. And post-merger the cradle of Ethereum, the thing, holding it all together. So ultimately the beacon chain and the proof of stake consensus. And you can imagine the, essentially that, that payload for the execution layer is essentially moving locations upon some condition. 

[00:06:41] And so people are running software that knows prior to this time, or prior to this block height, I'm listening to the miners. And after this time I'm listening to the proof of stake. And there's like a number of little details to work through on the actual point of merge and how you maybe handle attacks in this boundary and reorgs on this boundary. 

[00:07:00] But the simple case is essentially you have a chain being built by proof of work at one point in time and that same chain, that same like payload of execution layer that validated that end users care about is then being built by these valves. And the nice thing is conceptually these layers are important from like a mechanism design standpoint, but they actually translate into really nice software reuse. 

[00:07:23] And so we have what we call Eth2 clients, which are these beacon chain clients. They've built a highly sophisticated proof of stake consensus mechanism. And then we have like, what does an Eth1 client? And each one client really is a highly sophisticated execution layer. It's highly sophisticated EVM, transaction processing, you know, mem pool management and all that kind of stuff. 

[00:07:43] Plus this thin proof of work module that like, literally it really hasn't been touched since day zero. It's a relatively simple mechanism from the software perspective and it hasn't been, it hasn't been touched. 

And so what the software for the merge looks like it's really taking an Eth1 client, which is primarily a highly sophisticated execution layer, cutting out that proof of work module, which is, was the driver of that execution layer. And instead of listening to that proof of word module, listening to an Eth2 client, and so the software post-marriage actually looks like you take these two clients, which are highly sophisticated proof of stake consensus mechanisms, and you take an Eth1 client, which is a highly sophisticated execution layer, and you smash them together and you have the proof of stake client driving that execution layer asking questions about the execution layer. So for example, instead of the proof of work module saying, Hey, give me a valuable transaction bundle to include this block. The beacon chain client is instead saying, Hey geth. Hey, nevermind. Hey, open the theorem. My, my local adjunct execution engine, Give me the valuable payload. 

[00:08:45] So there's a state before and there's a state after. Really that state there's a beacon state, which is like the system layer state of this proof of stake consensus mechanism. And then there's the application layer state that exists in these like proof of work blocks today. 

[00:09:01] And really this consensus mechanism is really good at doing that. It's really good at coming to consensus. And so it's really just like slotting in its state transition and in its in its state, it's embedding the execution layer, state of Ethereum into that. And so if you think about it as like a tree of all the things embedded in the beacon chain, outer layer state that is built and finalized, you're essentially having like the application layer of Ethereum is embedded into it as like a sub component of its state. 

[00:09:30] And so that application layer. Right now exists in like the proof of work land. And it's really just taking that application layer state and subsuming it into the beacon state, which when you finalize the outer state route of the beacon state you finalize everything within it. And so you then just if within it is the application layer state that's been consensus on, then you get, you know, these finale properties and the other properties that a proof of stake is giving to itself  

[00:09:56] Friederike Ernst: So you're spooning over the state, but I mean, in principle, the miners can continue with the regional chain, right? So basically this is a natural break point for a fork.  

[00:10:06] Danny Ryan: Yeah. I mean, it's, if anybody wants to run proof of work Ethereum I think blockchain government's got governance ultimately works is that anyone can continue to run it. 

[00:10:15] There's a couple of things that I think might make it not super viable. The theorem community has consistently since Genesis this thing in called the difficulty bomb was intended to ultimately at the beginning to, to allow for a cleaner shift to proof of stake, ultimately like the mining difficulty at these points of the difficulty bomb increases exponentially so that it becomes non-viable to mind that proof of work chain, unless you actually have to. 

[00:10:45] So that might dissuade a proof of work force. But another interesting point is that when in the last contentious theory, mark w which created a theorem classic, there wasn't a lot going on in the application layer. There really was this DAO thing, and then a bunch of like little experiments. 

[00:11:04] Whereas I would posit that if Ethereum forked today and you had a majority community stake in one, and then a minority community stake in the other that the application layer on the minority one is likely going to implode. 

[00:11:20] There's a lot of interdependencies and a lot of value and stuff here. For example, Oracle's may or may not be run on the minority fork. And even if they are, you have systems like Maker, which if they're, if the value of the ether on one side or the other drops significantly, you have like mass liquidation, then dies, integrated all into DeFi and you have rippling  

[00:11:43] Martin Köppelmann: and all the backed assets like UCC tether and yeah. I also think like the the support for proof of stake into your CRM community is so overwhelming that I really don't think there will be any debate or any question. 

[00:11:55] Danny Ryan: Yeah. It definitely, from a community perspective 99.99% are just like, let's do this. We've been wanting to do this for years. Can we just do this? Come on. Whereas you could theoretically run a proof of work fork, but I think that it will quickly become a wasteland.
Ethereum 2.0 [Danny Ryan]
Broadcast by