Ethereum Merge

Transcript

[Music] Foundation um and I'm going to walk you through ethereum transition to proof of State um yeah so um I'll kind of start just talking about like what is frequency how comparison proof of work and why do we even need those things in blockchains um and I need to stand here um oh is this right now let's try the other one okay yeah specifically how do we get to the

current mistake design uh like the many configurations that we went through to get there um and then I'll walk through how we actually combine this group of stage chain that exists down ethereum with the current chain that runs through the park and runs all of the applications um walk you through kind of this entire process for like an engineering perspective like all the work we did to um what's left to do to finish the whole thing um then a couple misconceptions and uh hopefully you'll have some time for questions at the end I'm okay so I guess first like it's like kind of the very Basics like looking at like what's proof of work and what's proof of stake and like why do we need these things on a blockchain um and they basically give us like two

properties that are really important the first is how to become a consensus on what's the latest Block in blockchain um and basically because uh the latest thought kind of preference is called the previous box of history that tells us like what's the canonical history of watching um and this is like both of the organ mistake if you only do this um and basically the way you do this is you look at the history of the blocks you find some Metric by which to wait step history and you pick kind of the heaviest weight between the two and then prove it works uh we used something on ethereum called ghost um which basically just looks like how much mining power it is between behind a certain chain and the one with the most mining power gets to be the canonical

one and improve State we simply use what we call attestations which is more like economic weights so how much of the steak has actually voted for this chain um and again the strongest one becomes canonical so that's like the first thing you get from either of the systems but the second thing that's really important and that often gets kind of understood resistance and because civil resistance basically tells us like how do we figure out who gets the rights to create a new block on the budget um and this is really a hard problem to do on a progressionless blockchain because creating identities I think I remember Bitcoin is basically free so there's no way to like track a specific person any of the discriminate within different people so we need things like

paperwork and Google search um and generally kind of the way we we discriminate between actors and systems is we just force them to like spend some resources and kind of weight their participation based on how much resources they spend so in group of words again this is like electricity and hardware and then proof mistake it's the capital where the state they should put up and like did you like expand on this a bit more like why we need to do that and why you thought like another thing we can do um you know the the kind of basic thing you could imagine is just like well anyone can propose a block to block chicken and then the challenge is you just Spam the whole network right it could be millions or billions of lots coming in at the same time and and computers just can't like process that

and discriminate between them um and then the other thing is you know if if you wanted to you could just select the list of participants who have like the right to produce a book and kind of keep a whiteness of them um but because we want to avoid kind of relying on untrusted they're partying block James um we don't have that because otherwise if you're trusting somebody to put together a CIS you're probably trusting them to manageable chain and so ideally we don't want the requirements um and then the last thing that we want is we want the chain to be able to accommodate many different participants who want to come in and produce a lot so you don't want to have like a restriction I'm like okay can we have 10 miners 20 100 um so ideally like that number should be like independent we can tune parameters

in the chain to kind of reach an equilibrium but we don't want to set like a really hard clap um and so basically for all these reasons you need something like proof of work or previously why do we use proof of work and why didn't we start the proof of work and like what are the things that that gives us um you can basically think of proof of work as like an option for the rights to produce the launch so all the miners on the network are competing to build a block um which becomes part of like the canonical blockchain history um and when we do that successfully the protocol issues them in tokens uh and which is ether in the third States and also gets them the right to transaction

piece for that month um and because of the way people work Works um there's these monitors are basically doing these cryptographic problems that are kind of hard to get a solution for but it's easy to verify so even though it's really hard to find a new valid block on ethereum once a miner finds one anyone on the networks can kind of trivially verify that it's found so you don't need like a large Central third party to verify that the miners are being honest you can very cheaply have every note on the network do it all the time um and then what's what's neat about this as well is that anyone who can start a reminder on ethereum right there's no like barrier to entry the starting you might have um but obviously it doesn't guarantee that you'll be like a pop-up in mind but if you want to

start trying to mine you can do so today and you don't have to ask anybody inspiration foreign ERS to do basically is to try and find a solution to a cryptography problem where the answer to that uh the output that function is kind of bounded within a pretty specified domain and when people like when the mainstream talks about like mining there's like this image that like these computers are solving like really hard problems and that's actually false it's more like resolving a dumb problem but like giving you trillions of times until they find a solution that

matches the constraints of the protocol so it's a bit more like winning the lottery than like trying to find a new prime number or something like that um and again because it's really hard to find us um you know you only get a limited number of potential Solutions and anyone can verify your tribility and I'll kind of walk through it before after um and the way that we scale this this process is basically if more people want to mine on ethereum we just make kind of the the constraints the problem harder so we just like make the lottery harder to win and then similarly if less people are Mighty on the network then we can just take that easy all right so this video kind of shows like for people who are familiar like how actually works

um I'm sorry I did this talk at the Seattle Fusion so just an example but basically you see at the top is like some data that's being put in as an input and then every time you add like a a new case data um you get like an output function like the hasher of that data and what what happens with miners is they take this list of transactions that you can put in a bot and they're literally add random numbers to it at the end and you're looking for a solution that has a certain number of zeros at this time and as you can see here like um you know I'm trying and I'm not really getting anything with leading zeros at the start um but you can imagine this process repeating like billions or trillions of times and you know they can try and gain

more you have to have like 20 series at this time and then if if that's too easy then we put it to 21 22 and so on and so that's the way basically we modulate how hard it is I don't know you know if this is like this hard complicated process like why do minors do it and more importantly like why did they do it honestly um so like we said earlier you know when they find a solution they get the right to new tokens on the network so this is like what pays for them um and it's true about a Bitcoin in ethereum they also get transaction fees associated with this that ideally you would want that even if the transaction becomes zero you know they still have to incentive to my new blocks because otherwise

um they just won't do it and and the the reason why though basically mind the right the right blocks and not do something like say nip themselves a million ether is that because it's trivially easy to verify the output of their sufficient anybody can like verify a lot that remind them and said like okay this actually follows all the protocol rules and it is valid so if they did something like you know men themselves an arbitrary amount of ether or like um just change the output of the transaction everybody would see this and that means that nobody would like consider this to be a Ballot Box so everybody would just kind of build on the previous one and this is basically the mechanism in proof of our HDX minus audience um and then like we just said yeah if it

becomes too easy you just add more zeros to the start of the problem and if it becomes too hard you can just reduce that and kind of tune the difficulty together and so do you have that kind of this basis like why we use proof of work today and both across the fear and other chains and you know what's what's the what's like a comparison with the purpose stage um so in frequency instead of having this be like a sort of natural logory where like people are just doing these problems and might come up with a Solutions we just literally Shuffle the validators in the protocol so we have a set number of people who've put up a set amount of stake in a protocol and we actually run a lottery where we get this to choose the ordering of the people who produces the next books

um and then you can think of like the safety that you have on the network as I give out the lottery tickets you would have in the song similarly to how in mining the amount of like mining passwords we have is like the amount of lottery tickets and and unlike after the work though there's no like hard output to verify by everyone else um so what we do instead is we get all the other validators on the network to verify as much and to also put up their collateral when they verify it to say okay I'm actually like putting my money on this and saying that this is valid so that if they do this and they are dishonest and you can penalize them by taking away their Capital so this is the

part of like it's a bit different than proof of work um and instead of having this this concept where like the difficulty goes up as more people go I find people trying to find the networks improve the statement please do is we simply lower the rewards so we can just have like a certain amount of rewards that we issue and you know Target some amount of validators that we want if we have less than that we reduce that rewards that incentivize people and as we have more than that they can just slowly uh slowly take your different rewards off I guess uh knobs that you can use to kind of tune the system towards honest Behavior

so in purple volts you basically have to rely on my people's opportunity costs it's like they're gonna mind on the main chain because it's a profitable thing to do and everybody will also see if they might on the wrong chain but if they don't mind on the right chain you can't like do anything to them you can't like build to their riding farm and shut off their miners like there's no there's no like action so in group of work and we can ignore people who do the right thing similar to the perfect steak at sort of improve of stage you can still reward the people who do the right thing like we're doing different work so if you produce the correct block you put on the correct box you get some issuance um and that's that's incentive but we can also do the opposite we can we can

give people a penalty so if it's your turn to produce a lot and you're offline or you have above you produce the wrong plot we can simply give you a small penalty pronounced and similarly if you vote on the block that's wrong or invalid or whatever you can also get impelled and and then there's like one bad thing you can do for the state that you can't really do in proof of work and this is basically like commits to two different histories because in proof of work it's always easy to say like this amount of hash rate was um was was done this history and to like discriminate in the past um whereas include mistake you can imagine somebody because they're just voting with their Capital they could just say Okay code for both history a and history B at the same time and like

I I kind of saw the network we really don't want that to happen so if somebody does that and we basically have like a harsher penalty that we impose on them and anybody can kind of detect that by observing the network because you can say that this this actor are going in for history a and history B at the same time and so whoever get the text up is small rewarded and then the person who voted uh on those conflicted histories they'll get a large penalty and then they get included for the holidays um so we have like this actually really that's like we can kind of maintain the canonical chain uh by by generalizing the partners in a protocol so that was a lot I'm kind of sum it up here um you know so at the Riverside yeah the best Capital uh in the hardware and

electricity the more Capital that they invest into this stuff the higher your share of the hash rate and that's like the likelihood that they have to create a block proof is safe you just log in actual capital from ether and then you also have this risk of loss if you perform badly and the amount of capital that you knock in is having for your liking the producing your block as well we just make the difficulty higher or lower depending on how many people are mining so that we always get blocks coming in at the same time and improve it safe because lots are easy to create uh we actually set a fixed time for them but then we raise or lower the amounts that we pay about letters to create those um depending on how many of them show up because it's the mind on the office

chain is that otherwise people will just reject their blocks and because it's orphaning them where people will just mine on the on the previous blog and kind of think that block aside um this also happens in people say but then you additionally get penalties if you do this or if you attest to block it that's like that okay and so you know like assuming all I understand it's like well okay these systems get you the same property like why would you switch from one to the other are there like any benefits from the state um so there's a few um one that is very neat is this idea of finality so in proof of work you never know whether our blog is actually final so there could always be like a case

where somebody comes in and mines a larger chain going back in time and has just like a larger amount of hash rate and kind of creates a whole different history um and over time you know as as there's more and more flexibility you get kind of the higher probability that this is impossible but you never quite get 100 and if it and there's no like binary way to detect it so it makes it very hard to like have to have like settlements on those chains because um yeah you're always having this tail risk that oh maybe somebody's gonna like rewrite the history improve mistake basically if everything works well every every um 12 minutes we have a lot that we consider final um and for some reason to undo this

history it's like a very clear boundary where they need to be there needs to be more than two sort of the capital of the chain building and they need to be willing to burn at least a third of that capital and then we can observe all of that as it's happening on chain so the concept that like you have finality that it is a binary property and that's if it's not happening you can visualize it on chain gives you just like this extra level of like guarantees around settlements on the gym the other thing that's that's neat is that because we can both reward and punish as elevators we don't need the rewards to be as high as they have to be into the work um because we can we can basically Target them very specifically and Target punishments very specifically so you can think of it as like a cheaper security

system uh that gives you kind of the same level of security um and so in the theorem's case basically we can reduce the amount of new Easter that we we create a secular protocol by about uh about 10x um an improvement of type rather Improvement um another thing that's neat as well is that if you hear about like centralization and like concentration the powers in this ecosystem um proof of work is is a bit worse on that prompt because it's like a very high fixed cost business where like if you're running one minor in your apartment um you're gonna pay much more per amount of like hash rate than if you're setting up a factory to run you know dozens thousands tens of thousands of miners so you get a pretty good economies of

scales and different work improve to say you kind of don't get that right like if you will make more money if you have a larger stake but the kind of percentage that you make remains basically the same which is every new product um and then the last one which is obviously huge as well is that proof of work is like this competition to like expand Real World Resources to show that you've like put energy into creating this shame and prove the state you simply ask for like Financial Resources instead and so that means we don't have any environmental impact they're like generated luck um and and that's obviously a big difference side to try and address those

um the first one is just like proof of stake is more complex than your work in terms of like protocol implementation um you know we saw earlier people work like this this little video where I could just look at input data and output data to check if it matches um there's obviously more complexity to that but like it is much simpler to do that than to like count all the votes of everybody and give them rewards give them penalties um so this is like an extra degree of complexity the way we would purchase on it here inside is we decided to launch a proof of stake chain uh and make 2020 separate from the actual proof of word blockchain because we wanted to like have this be live with tens of billions of dollars on it and make sure that it works uh before we were using it to

secure the actual Network for people to spend more um and all the applications are running um so that was that was kind of putting it there the other one is basically this concept called weak subjectivity so in um you can look at like a chain history and know that it's been valid no matter what so you can imagine like you shut off your internet and like somebody sends you two versions of like ethereum um offline you're able to resolve which one is actually the real version of ethereum without asking anyone um and through this sake um there's these attacks where like because somebody is like can be a violator and then they can stop being one then they can like sell their keys that they use to somebody else and if somebody bought enough of those they could like recreate a fake chain so

there's no way to like discriminate between a chain that was actually created on the real people section um and one that was created offline after using the same Keys um it's like a very kind of complex attack that executes but basically you know the mitigation is we accept this on ethereum and you need to ask you know every couple months somebody live on the network about the current state of the mirrors and that's like the assumption that we make um okay um yeah actually I might look there that's good um so the reason I think you make this assumption is well when we think about like the history of the blockchain mostly by the contentious part of history is like very close to the

president so like if I ask you know everybody here what's like the latest ethereum block you might actually get some different answers because there's different mods that come in at the same time that are competing if I ask people like what's the latest life of like an hour ago people would probably agree um if I ask that people what's the latest Block in three months like it's pretty much guaranteed people would agree to this because there's so much you know social consensus that it's run around that lot there's so much economic activity that gets settled based on that so you can imagine you know you send some money to an exchange three months ago The Exchange took your money you converted into tiat you bought it out he bought a car there's you know that log is basically considered final um and so this is another reason why

like ethereum is sharing just okay with it straight off because the idea that like once every few months you need to check the chase the state of the check and see kind of reasonable to practice and the other thing that's a bit inconvenient is um like we said earlier we actually shot from the validators in the protocol State and we want to give validators the heads up that they're producing the blocks so that they can kind of get online sync the latest information and get their blog ready so that means that dollars tend to be not like at I think it's like 12 minutes 30 on that order um and because dollar layers do stuff on the internet so they can pick their IP address and then if they can read us and which is not really something that happened in proof of in proof of work

um or at least it can happen but it's it's a bit it's like less information package um so there's two things you can do about that one is like a fix and protocol what we call the secret single link leader election uh as being worked on um but it's not going to be a fixed in the short term in in the short term basically you can have just some better devops setups where you're not exposing kind of the same IP for your blog Builder and for what's connected to the rest of the network um so it's a bit of like a higher technical overhead to avoid Networks a lot of like proof of States chains have the sweetness and it gets it doesn't go all um but usually there's this concept like

only a very large empathy is going to be validated on the Chain um one of the reasons why Tucson Elementary is this is something we wanted to like avoid it so like um basically the the there's no kind of requirement inherent in group of State because like you need a larger calculator size uh so the theories is like 32b um but basically it's it's not a it's a parameter that can be changed it's not like at the fundamental property of approvalization um so yeah you can do like a relatively small validator on ethereum and not be a first class participants in the internet oh hopefully that makes sense um so now I'll I'll think more like here

inside how we actually got to like referring to the same design yeah the first thing that I came down is that you know anyone who's been following ethereum kind of has heard that like your mistake is coming soon for probably the past seven years um and like all this stuff that like way longer than anybody expected um so hopefully this kind of gets context as to like what were people doing during that time um and and why it was worthwhile um so like the reason originally that like people thought proof of state was was really bad is um this idea of like the nothing yet safe problem like and validators to like votes for bad loss or conflicting histories and like nothing would happen to them um and that was thought to be like a

fundamental flaw in terms of stage um so in 2014 uh colleague published his blog post um basically implemented in the concept of slashing which we didn't talk about earlier where like if you have a validator who would test the two different histories the conflict uh you can you can verify that in the protocol and you can have other values in the protocol so it was like one of the breakthroughs that I kind of glad that they're thinking like oh for a second might actually be like worthwhile and something we can use um so from there tons of research has happened and in 2017 uh the pipe the paper was like the final mistake algorithm I was published uh on archive um and by then we had something which like had most of the properties around African state that you have they like it

created blogs and finalized um and in the large part this is still what like Powers the vegan chain to make um so not like a year after that uh a bit less actually we had this first proposal to try out proof of stake in parallel to proof of work on the ethereum network so because this was still kind of new we were thinking well what if we just like keep it to work but then half proof of State come in come from time to time and maybe over time can like deprecate a group of work and just move 100 Proof say uh but this way improved mistake has the shoes it won't they won't be left alone um and some people started getting really excited about that um but in parallel to this there are some people that were trying to figure out how we actually scale the theory so

proof of stake does not actually give you extra scale on the network you need other ways to do that um and so there were both these research groups that were working on like um obviously separate problems um and in December 2018 they kind of all got together and they realized that like a lot of the common infrastructure that you need to do proof of stake was similar to the common infrastructure that you need to do scaling and so they decided to basically scrap all of this previous work that have been done in this like hybrid model and try to design something from scratch like what would be like the perfect thing you know both scale ethereum um and the different percentage so this is what I can you know 2018 everybody thought it was coming and then like it didn't it was because they basically

just like started over with a new ideas um so I got here in 2018 came up with this new uh model um and so it's about a year after that they had a final design for the proof of stake chain how it would work everybody got together um prototype this over the summer and and kind of got it working in a very like hacky way and that the government is like prototype we have actually launching it with people's money and so I basically took another year um so in December of 2020 uh we had everything ready and the previous take chain went live like I mentioned earlier because we wanted to be sure that it wouldn't affect the application on ethereum we just launched us as like a

separate chain running in parallel to the proof of workbook um and so we launched it in 2020 and then by May of this year there were um I think at the time 30 billion dollars on it um it had been running for like six months uh working as expected so at that time started feeling talkative like okay how can we actually make the system take over uh the entire chain and we started privileging that and this is what we call it the merch um so and when thinking about this it's again I'll share some context of like how we got to this idea of just like merging the two chains together which might seem obvious but was not the design at the start

well at the beginning In Summer 2018 when it decided to like strap everything and come up with like a new roadmap um the idea was that we would have this group of stake chain it would start doing nothing except perfect safe like it doesn't matter but then we could slowly add more functionality to it and we would get people to like migrate them um and the idea is like how it would get people to migrate because not was never really like fleshed out we never got that far and that was like the main kind of designers like let's just start from scratch a whole new system it'll be scalable from the start and people can migrate from one to the other um and when people talk about like phase zero phase one phase two this is kind of what they were refer to um and and the end goal the reason for

doing that is basically that like um that would give us like much more sale on ethereum and some applications that run cheaper we could just do more things um but as that was happening as we were like working on the beacon chain and getting that up um there was this concept of Roll-Ups that that started to gain traction um and you can have a whole like talk on Rolex saw I'll try to keep it brief but like the idea of Roll-Ups is they're basically uh separate ethereum chain that runs in parallel to the main chain and keeps a lot of the security properties from the Magneto itself so it effectively gives you like scale on the network um with almost no extra security or trust assumptions um and whereas like this phase zero phase one phase two world map was very

much in like the research phase rollouts actually started to like shift code and and get used um so there's this idea that we came up with was like very complex and then on the other hand we had people just like actually writing code books I think that was working um so there's a shift to like what if instead of having all these like different ethereum uh chains that run in parallel that the magnets by the protocol that people need to migrate to we just let people build these Roll-Ups on ethereum um they can kind of take care of this problem um we get to keep working on these other things uh like the mistake um and that would be the way to limit scale um and so the first version of this was was basically this inside of a roll-up Century quote map but people were so

tied to the idea of like moving over to the new system so they were they were saying well maybe we'll have just like one new ethereum and other or less apply after that and you just need to migrate once but it'll be like a simpler migration and migrating to all these different chains to the same file um and then the last kind of change we did to that is like well you know we have a change today and it works uh that runs on the application you know can we just keep that and instead of moving all of the applications from that to somewhere else simply change the consensus algorithm on that chain and this is actually something that the software does already so if you run a note on ethereum like if you run get or Aragon or racing the other line um it runs proof of work on The Ether

maintenance but it runs a bunch of other consensus algorithms um test Nets or project networks so there's already this concept in the client that like you can have and plug a mobile consensus algorithm that gives you like the latest the latest head of the chain and then you do all the other stuff what it is um so this this last kind of simplification we had to do about that was just saying well let's not like move all the applications to a new chain let's just have the new chain stop listening different performance consensus and instead listen to your mistake um and go through this transition and this is basically what we're doing now and then again just like the previous idea you can get all the scamming through Roblox and I have some pictures of this um if people have in this issue a long time

some of these might be familiar um but like on the left side here this is one of those like the original kind of vision for the space zero phase two and so the idea was that like the proof of State chain would be um basically doing it with the red and the yellow chair building there uh doing the staking providing random numbers to shuffle people uh in the sticking chain and then we would have all this data storage on ethereum and then we would have all these separate like virtual machines that run in parallel and then do all the computation and then what we're going for today is pretty similar basically so we have this first row which is proof of state which actually runs uh the beacon chain so you can think of this as being like the orange

at the yellow and the red one combined um this execution layer this is all the software that exists today on ethereum that actually runs transactions for users um and then we still have this concept of data that we're working on for scaling and then all of these like virtual machines that are actually scaling the computations of the network um they're all the rollouts or today or two's and you can see they're all different colors because there can be different flavors of them whereas on the inner side of the crap all have to be the same um so if you think like away nothing else from this graph it's just like it looks pretty similar um and we kind of converge on this architecture that gives us the same amount of scaling but just as like much lower in protocol complexity and that's kind of why we went with this

to give you an idea and then how we get from like the current state to the merge um if you're not familiar with like how it Theory works at all uh apologies in advance um they'll be the Q a at the end um so today when you run the note on ethereum um there's basically two networks we said right like there's a group of work Network there's the future State networks they each have a bunch of nodes running out of them they're quite independent what we want to do with the merge is we want to combine those two things together so that means that active emerge you basically need to run one of each and then be talking to each other and that kind of creates the network uh as a whole um and so the beacon chain or that we call this the previous stick chain is

called the beacon chain um we also accomplish the consensus layer and this is what we used to call each two so um all those things you can treat us like roughness Anonymous um so that still runs it basically gets it does all the perfect State functionality it gets the latest head from the chain um but then what it can't do is it can't evaluate the user transactions when it gets a lot of transactions in them it doesn't have the capacity to say like okay this address actually have the funds to pay for this transaction um so what it does is it sends this to it without L and the execution engine or the execution layer and what to solve each one um which actually runs the computation that happened in the ethereum virtual machine um and this is basically the same

software that runs the ethereum group before checking it just stops running the proof of work stuff and does everything else that it captivating I'm sorry you know it processes lots and maintains the transaction calls and it sinks and what also keeps doing out and but it's like you know we just introduced this like thin communication communicate layer in the middle of them called what we call the engine API but aside from that everything kind of stays the same for people using the software so like both layers maintain a different set of apis so if if you were kind of plugged into one and kind of querying for data you don't have to do anything the data will just keep coming the API calls don't change or anything like that and similarly both maintain their set of peers so when a transition happens it's not like you need to like disconnect

from the network and reconnect it's like you're still maintain the same password um so there's really like a minimal amount of change and and the way we do this is like buying those two bits of software and introducing the communication and this is kind of what like in ethereum Block more or less looks like after the merch um so on the outer layer I what we have the consensus consensus that you get this is all the stuff that we can check already does um so if you start from the top instead of block numbers they use slot numbers and you can change but it's just because you know where are we at what's like the previous Vlog um towards the current state of things um then on on the side you have at the

stations which are all the results on The Beacon chain so basically Google it for what uh during this block uh all the deposits so 400 people coming in and Outlook with the access for the people leaving so you can think of this as like metadata in a way for like the consensus of ethereum so this is what that you can change us today it just does this but there's no transactions in it and so after the merge um we include it's like the parts of the proof of work blocks that contain all the transactional data and we call this an execution payroll but this basically has most importantly the list of all the transactions in the block but also some information uh that is required to execute those transactions like with information about the previous blog what the current base speed is and things like that

um and what's thinking this is because we're just like taking bits from both sides basically nothing changes from like inside the chain so if you're a smart contract like from your perspective almost nothing changes during the merge um there's three small changes uh so the first is block times in terms of work are kind of a target with a lot of variants so we try to get 13 seconds but we get like a wide range which averages the depth whereas Improvement State they come every multiple of 12 seconds um somebody might be out learning something might like miss their miss their turn um that usually happens less than one percent of the time but you just get like this much more predictable Cadence where you know every 12 seconds something should be happening um there's a bunch of stuff in the block we just set the zero because it doesn't

matter anymore so like a proof of work difficulty um yeah all the proof of our stuff just gets set to zero um but there's one thing that we actually can't set to zero and this is um the difficulty of the current block improve of work we basically keep track of how difficult each block is to mine um and because there's variants on like the hash rate this creates like a bad sort of pseudor Randomness um that you shouldn't be used for Randomness and contracts that people do um and I could emerge this is not an effectively if you got zero um so we didn't want to like go from like bad Randomness to absolutely no Randomness because things would break um so we simply use the same random value that we use to shuffle people on

the previous six side and we expose that um so that smart contracts Don't Break um this is really the only change that happens from the perspective of a smart contract at the transition and okay hopefully it makes sense um I'll walk through how to get from one to the other um and I have pictures to go through this um but the first thing that's like a bit different about this transition is if the guy if you're familiar with ethereum or just blockchains in general you know that upgrades tend to happen on the block number so we'll say like I block one million there's an upgrade happening um for this transition we actually can't do that there's some weird uh attack Edge spaces with proof of work where if you use the block number and you don't

trust that miners are going to be honest after which they have no incentive to um it could break so instead what we do is we use uh the amount of difficulty on the Chain so like we were just saying every block kind of keeps track of how hard it was to create that blocks but every rock also keeps track of how hard it was to create the sum of all the blocks in its chain um and this number is basically really hard to take we call it difficulty um so if if you want to fake this you basically need the mine and extend kind of electricity and Hardware costs on a different chain so we consider it to be like a pretty pretty reliable indicator and so instead of the block number we set up like a total difficulty value and we use that to trigger the transition

and we call this the terminal total difficulty or ttb for short um and so what you do is we set this audio and then we basically have clients on both the the station the perfect work chain kind of wait around and wait for this value to be exceeded as soon as there's a block that exceeds this value we consider that to be like a candidate's final proof of work notes um and none of the children about blocks are like considered valid anymore so if you're familiar with the word this means you could have different blocks that like show up at the same time so you could have a set of like a handful of different candidates um push the fruit of steak chain can choose from but none of those candidate final blocks can then have another

children depending to them that's considered Health um so we basically have this last book for wordwatch The validator Who scheduled this to produce the next block on the beacon chain once they've seen that block then they say okay well it's my turn to now include transactions and it just starts including transactions in the blocks so this is like the entire transition basically it happens from like one run to the next when Nevada there sees that it's their third development transactions they start doing it but there's no downtime no like migration or anything like that um and like we were talking at the very beginning and for the sake we have this concept of finality favorites like basically uh incredibly costly to reorder history beyond that so what we want to see for the transition to be complete is this first watch created by

a validator to be finalized because then we know that basically uh you know the network is safe and it's not going to go back and find me on this and we consider this complete so like in the in the like basically normal case um there's like a 13 second gap between this last week of work and first group of State plot and then there's about 12 minutes between the first group of state law it'll kind of time for 35 minutes and then everything is open oh okay I do have a reference um so what this looks like basically you can imagine is we have again these two chains that are running in parallel if you go all the way to the left and the top you have a proof of work chain it has blocks which has all the transactions in them on the bottom you

have the beacon chain from the state chain it has lots a bunch of metadata about the mistake no transaction with them the second bot on the top if you think of being like the last group of work blocks so the ones that exceeds TTD um while that's happening you know the lead engine is just checking it wrong that's nothing but then the product that's produced after that starts including transaction and that brought the reference back the final proof of workload but you can see that the the last button responded um basically does not have any reference packages of work anymore at this point you like entirely kind of depending on to fix it um and that's it this is like the whole transition process thank you I thought last I think yeah second last time I thought kind of want to like how we test

this and make sure that it works uh before we go to uh to the live Network and kind of where we're at in this process and so it's a big back from where we laptop earlier may this year we started getting confidence that like through the state was was Secure at scale could manage funds and it could be used to uh to secure the entire chain um so we had the hackathon where a bunch of the team kind of prototyped what would the post merge system looks like so this first picture we saw like the two nodes talking with each other maintaining their set of peers and apis we were like is this architecture even sound can this even work um so people kind of sent them out prototype and dots and got it to work uh so we had confidence that like we could

adopt this design there were still a bunch of Kinks to figure out but overall that it would be a good architecture so then we spent the summer fixing all the bugs with that um and got everyone together in uh in the fall to prototype the actual transition so this was like the most complex part thinking like can we actually start in the first round proof of work have this proof mistake chain running in parallel get them together and still work on the other side um so we got everyone together for a week got from the back of this working which kind of gave us the confidence that this transition could actually be done um again we got it done pretty quickly which is a pretty bike so it was kind of kind of default fixing bugs and then right before the holidays we launched the first public guest net

um which what was basically you could think of as like a 90 complete spec where we were pretty confident in the entire design we were sure that there would be some edge cases in my thoughts but we wanted to get the community and people actually try it out and see if it worked um so we launched that uh you know we reached out to the infrastructure providers kind of the biggest obligation it's just test it decided to check it I ran a bunch of tests on it found a bunch of edge cases that break um and then in March of this of this year we launched kind of the new version of this uh at the spec would you consider Frozen um to again have a new test net for people to test and have a bit more scale once we had like this this spec Frozen

uh version we started doing this thing which uh we've never done before called Shadow Forks and the idea there is that we wanted to run through the merge on like live ethereum networks um to do a bunch of dress rehearsals of it to make sure that it worked so we would just launch like a small number of nodes that were controlled basically by developers and testing teams and you kind of tell those notes like the merch is actually happening on the network there and then they run through the whole process and you see what breaks um so we we did these every week we're still doing them sometimes more than once per week um and it's been really helpful because like not only do you get the testings in the same condition as maintenance but for a few days after the transactions

can still be replayed from one chain to the other so we get to see like what does the system can the system post merge actually handle the amount of volume and traffic on maintenance um and nvdm kind of testing those things that like you know can you transition the proof of stage shut down your notes beneath the database sync back on scratch all those things that are like kind of implementation details um once you have actual specification so that's kind of like the core of the testing and we've been doing those uh again yeah every week basically uh since since March and then we've gotten to the point where like we're quite happy with like the the quality of the software and really wanted to move like the final steps to getting this to the interior maintenance um and so what we usually do is we have

these test networks um which are used basically by all of the application developers the staging environments and so even though the replacement works we really try about break them because a lot of people kind of depend on them to run run their applications um so we we ran through the first two of them um found some minor issues fixed them and then we're just running through kind of the biggest the amount um there's actually a test map for proof of work Belgium State called Trader so we're merging the two together um and this is like the most used Testament by both developers and validators um we have kind of the first part of the upgrade happen uh earlier this week and then next week we're expecting the whole transition to happen um and this is basically like the last step that we want to test before my neck

it's like can't everyone actually run the software you know are there likes the last minute Kinks or stuff to work out but assuming that this goes well then Next Step would be to actually deploy this obvious theorem maintenance um so after like over a year now of testing we're in a spot group people are quite comfortable with that okay so yeah that's basically the process um and the last thing I have is just a couple of misconceptions uh before we do q a um one big one is this idea where I'm like who's taking over in transaction fees are helping with scaling I just shut this already with um free mistake doesn't give you like more throughput directly on the network it helps kind of set the infrastructure to do it it helps make it a lot cheaper but it in and of itself is not like a

scaling solution it really just shifts the consensus mechanism um and then another misconception is that um the validators who've like signed up to be validators right now it's been like a one-way process um so they can't actually stop doing that um or they can stop at the capital is to lock they can't like unlock their Capital um and we won't because it's like a pretty complicated upgrade we want it to keep it as simple as possible and one of the features basically that's not part of it is the ability to withdraw your capital for the state chain um this is basically going to come in the next upgrade to this uh just to keep things separate um and then this last one is kind of around just through the second General it's like this this content that people think that because we're selecting

people to produce blocks they can just do whatever and like you know have like free Reign Over what goes into a block um but this is not true just like in proof of work when they produce a block it still gets verified by everybody on the network so they can't like produce a block that doesn't follow the protocol rules because then it'll get orphaned it'll get canalized for doing that um and similarly people also think sometimes that because you move at stake now it costs money to run a note like you need to put these 32 ether um this is only true if you want this right to produce a block but if anyone can run nodes for free on the network and when they run a note on the network you are validating that every single block is still correct so you can think

of say like a cryptocurrency exchange when they get your deposit in they still they run a node to make sure that that transaction is valid but they don't need to pay money or to be a validated like anyone can do that that's one of the other big misconceptions that's it um yeah thanks so much traditionally I'm happy to take some questions and if you want the slides there's a bunch of links to them uh you can give them uh on the thing thanks okay sure yeah okay so if you have a question just raise your hand and I'll repeat it online yes I'll repeat it uh okay all right thank

you for coming a reminder that there is the Inception of the ideas in Canada and nfts erc721 Vancouver so awesome keep it up my question is around sort of maybe like socioeconomic shifts within the algorithms so we're going from work where there's industrial equipment and energy that goes into validation and now we're moving into um capital and um and and so I wonder when we think about like exchanges holding people's uh in light of things like Celsius and

Voyager where we'll finance and coinbase have an outsized control of ethereum coins and so will they have more Cloud over the validators that um to to make things a bit lopsized are we training the environmental concerns for socioeconomic yeah yeah um so to repeat the question is like in short like improve of work you have like these distinct backers that invest like in the hardware and that's how you can create a chain improve mistake you have actors who just have the coins and the it and then that's what secures the chain so you have people like exchanges

they have a bunch of points they can secure the chain you know other issues with that um I think that the core thing you want there is really kind of coming back to this idea that's like you don't need to be allowed there to run a node like this idea that um you want to have independent people on the network running nodes and verifying that like the solid vendors are following the protocols um that's really important the fact that the protocol itself um can kind of detect and penalize some of like the expenses I think is also valuable and this is something again that a lot of mistake chains don't have so a lot of free mistake chains don't have this concept of slashing um and that makes it like yeah that makes it a bit trickier because it's like these exchanges could actually affect what an Argent Upstate kind of

the the liveness of the chain on ethereum if they did that uh which you know you can assume they can anybody else can penalize them um once that happens they're basically going to get a financial penalty um and they'll be from the valid intercept and one thing I'm going to touch on that's that's kind of neat about ethereums of innovation too is the penalty scale with the percentage of the state that misbehaves um so this is nice in two ways so if you're just running your validator at your home and your internet goes down and assume your internet is uncoordinated with like say coinbase or Finance um your penalty will be quite small It's usually the same as the online like you will lose as much enough item for a period as you would have but made by getting online for that period so if

your internet goes off for a day nobody else is offline you lose a day's work but then the next day you kind of make it nice but if you're a large exchange the penalty actually squares scales per drive so if you're like a third of the stage and you go offline or you just behave you get a much harsher penalty on and that kind of acts as another check against that we're like these large kind of entities defecting are much more harmful to the protocol so we can penalize them more harshly um and then like but like yes obviously they could do it it's just a protocol to protect it they would be ejected to the valid intercept um and and that's um yeah but I don't think yeah I don't think you're trading out that much okay it's kind of following up on that in

terms of decentralization right now the top three validators which are only around 54 um what is being done around that especially because three four and five or exchanges coinbase so I had to track um yeah right yeah so so yeah so the question is like how do you deal with centralization of others um sure you know proof of work is not great in math regards either like proof of work is quite centralized as well um and you probably get like single digit entities that control like if not majority like close to majority of the hashbriggs um the things I guess that the change is like one ethereum has wanted to like have this relatively low stake for this reason like anyone can run a note with

32 rupees um and that is like still not the majority of the state but it's something that even though it's a minority we think is very important because enough because it gives you like pretty uncoordinated actors and um yeah I mean the other thing is as well is just like even if you have a large percentage of the state you can't change your protocols right like at first you get my client conflicting histories or you can um or you can kind of pause the chain if you pause if you stop the chain from finalizing again you get a penalty that grows with how much of this they can control so the protocol is like Bueno kind of recover from this like yes these entities could cause you know they could like destabilize the protocol but

they couldn't like fatally scar it if that makes sense even if it's a 51 attack so the thing you know so the the thing um the bad thing in previous state that you can do is if you if you have two-thirds of the stake um you can finalize an invalid block right because like we were saying earlier like once two-thirds have voted the block is considered finalized um the thing that's neat though is that unlike proof of work in proof of State you can actually uh the way that like the penalties and votes were is they're all proportional to how many people voted on each slide so if you have imagine like fine exchange they collude they finalize the block that prints them like a million piece or whatnot so what's going to happen is the sub the

minority chain will reject that um you would expect people to like see that on chain and see that this is bad and so we'll just gradually kind of remove their stake from the from the validator set until we've destroyed so much of their Capital that this minority two-thirds of the chain is now effectively at this time already third of the chains are effectively two-thirds of what's left and can then finalize on the other side so they could do that you know it would be detectable on chain they would burn a third of their Capital to do it um and the chain could kind of self-heal towards the the right thing so again it's it's not um it's not great we don't want it to happen but like the protocol is designed in a way to be like somewhat

resilient so I mean anytime you just work on chain you know the whole state which is like all the contracts and all the balances gets on both Forks um and then things get tricky when your

parts of the stage refer to things that's not like punching right like it's easy like when Bitcoin Force it's easy because you know you just have Bitcoins on bitcoin so like you get your coins on both forks and that's it the ethereum is stricter because you have things you know what are their nfts um even whether they're like you know price oracles they refer to things that happen outside the chain and then every one of those projects basically needs to decide what did they do right like how do they handle this and most of the times these projects will just follow the main chain and and kind of settle on that so that means that I can practice you know if a project for example like does not consider the other Fork at all then you know that there's no like updates to it so

whatever like whatever intervention is required for it to work just like stops happening and then D5 this is something like posting Oracle updates um you know for an NFP you can imagine I I would like take pumps for example and like the community will converge and they'll say this is like the real Punk um but like every project can kind of decide after right before yeah and the more pointers that off-chain stuff you have as part of your project uh the more kind of intervention is needed to like figure out what's gonna happen yeah they're in classic right yeah it doesn't happen it was nothing it was basically a theorem it's like Bitcoin you know module wouldn't be contract but like yeah it was this it's important yeah um in the back questions what is about the finality

like I didn't fully understand and the other one was there was a Twitter it's great if I had my hair boy and like who yeah she's like a poster let me set a Bitcoin wow you were just saying like it's just like a good characterization to where ethereum now is going to be just like an excellent I don't know what people call it an execution or like an execution Shea was like all about how you were now used to like double choose because that's what that's actually yeah first what is finality so the finality is like a very simple definition is like a block Beyond which you can't reorg

um the more complex definition is a block Beyond which if you were to reorg you would have to burn a third of the capital at stake on the network um and so it may be like in between you can think of this as like if your threat model is not like nation-state attacks you're probably safe trusting that one or you know maybe a more concrete way to put it is like imagine you're sending like a million dollars on ethereum and there's like 50 billion dollars staking you you know that's like to to revert your transaction somebody would have to burn like 13 billion dollars right but if you're sending 20 billion dollars on ethereum that might be like a concern you might think like oh like okay I might want like you know this might not be safe enough

um so for like all the depends and purposes like we consider that not to be final there are some edge cases and similarly to proof of orange um so the proof of work basically when you send some a transaction you consider it find out if your transaction is like many more times than bigger than the block reward you'll probably want to wait until like the sum of those block rewards ends up being like bigger than your transaction to feel safe um and this is what you mean by like probabilistic finality it's like interior board there's never a point where you can say oh the chain can't really be right beyond that it's always like it kind of gets engaged whereas in perfect sake we're able to make it clearer for like you know call it 99.99 of the cases they would have to burn a third of their

um and so they would have to own two-thirds of the state so if there's 50 billion they'd have to own either like 30-ish billion dollars and they would have to be willing to earn a third of or half of what they own a third of this one so like and and this and and so if you're if you're thinking like on those terms then you know if you're sending more than say 15 billion dollars you might want to like you know use something else or think about it differently but I think yeah for most transactions this is the Savannah consideration um and then your second question about like l2s so like we have this uh somewhere we have this chart yeah okay so like if we move on the institution the L2 you know like is this bad for ethereum

um and again we've got the whole whole meet up on l2s but what l2s do is they basically run all the computations on like a separate ethereum chain but then they close back all the data from those computations or proofs of their chain and this is why we need some data storage on ethereum ethereum and when it goes that back they basically pay gas fees just like any application uh to to to store that data so you can almost think of it as like going like a beat to C model like a b to D but right now it's like all the end users are like paying for like their own little storage on ethereum whereas like with l2s it's like you have like these companies that pay for like batch storage because they

don't post just your transactions data you know they take you know tons of transaction you put it together to compress it um and then they close that back um so I you know like I'm not like an economist like I can't tell you what the application is but it's like it's not true to like moving the execution to L2 means that like there's no more like value accrual or there's no more like demand for theorem block space like l2s very much need like if they're in Block space and they need to kind of in a B2B way um yeah us on the validator selection yeah developments before their blog comes sometimes yeah sometimes agree and I

understand it that they can't attack the protocol because their their blocks they provide them have to improved but that time window does give them the ability to do and you need attacks yeah is there any plan to build under protections why do you defeat why do you need the need yeah yeah okay um so the question is like yes the Learners even if their children Advance they can't really messes with the protocol itself we can talk about that they can mess with applications on the protocol and like the most you know the the most uh notable example is like if they know they're going to produce block a and another Block B with before block a and like there was like a price change

before that they can be like the first still like exploit the price changing my thoughts so like what do you do about that and this is like a whole research area around Med um the short answer is like um we have this this research area called Closer Builder separation where we want to make it such that validators duties becomes only to like almost broadcast the blog at that time but it's not up to them until like actually decide the context of the box and this is actually what happens today in practice with like flashbots um where you have a separate network of like people that are like all competing against each other to find like what's the most profitable block you can build right now and then they kind of bid you

know they say okay I can make like what do you do with that block I'll bid like 0.98 ether uh give that to the validator and I'll keep that at point zero two and somebody might say well you know what I found the same as you all did 0.99 and and you kind of get these really competitive options so it already kind of happens they're you know there's some medications you can do in applications one thing that we we're kind of uneasy with is the fact that it happens outside of the protocol through flashcards so and flashlights team is great you know uh but we just don't like the idea that it's like an extra protocol team so we just want to bring you a lot of like that market structure in your protocol um it's pretty complicated we could do a note about that but it is

um just separate out yeah they're more like building the best lock to separate that elephant the world with proposing down to the network and doing it in a way such that the person who builds the boss chat like harm the network and that the person who broadcast that much chance like take all the money away from the person who respect our typical events yeah if you're interested in that lots of possible out there good awesome and then have you guys thought my perspective ly yeah great question uh so first part is like do we how does the scale change

with like if there are two in this transition and two like can we scale another way in these Roll-Ups um so short answers like the scale basically doesn't change with ethereum two double it changes by like 10 but like that's not what people like think about when they think about scale um the department of player choose is I think you can keep making better ao2s um there's some people that talk about like enshrining some of that in front of call so like you know you could imagine having like some very minimal version of a layer too that's just like part of the protocol to get like higher maybe you get like higher security with that with like less features so that's definitely being considered um I do think like what's neat about like their twos is that it's almost like Central planning versus markets when we

design the protocol right it's like a smallish group of people uh and you know think like 100 200 people but still like kind of small who like have to come up with this and like we have like one development Pipeline and it has to go out um whereas like layer juice is like you see like you know there's what it was 10 maybe 20 like big layer two companies now that are all getting funded and it's like very competitive market to come up with the best idea um so I personally like really like to see that dynamic because it's like all these people are like competing to find what's the cheapest way to scale with like the best user experience and like you know there's a massive Market opportunity to win that um so some of that Tech might make it into the protocol it's definitely like not like a

guarantee um and and I think that the trade out that like we get is just like maybe some like especially in the me in the short term there's like some like trust assumptions that are extra but at the same time in the short term we wouldn't have shift this in the protocol so it's like we kind of have these like imperfect irrits today but like we don't have anything else on the protocol so it's probably not fair that they're there um in terms of just like scaling an amount of data over the amount of my transactions the biggest bottleneck in the protocol is how much of that layer to data can restore um which right now is not a lot and like a lot of ethereum upgrades after after this transitions are focused on like how do we just create more space to store data for these there too and this is

basically how we get another you know 100 000 X of scale um and there's maybe some things we can do to scale that layer one by another like 10x um but again you know yeah those will take like a couple years as well so you were saying that the duties of proposing a lot and validating our cyber but I remember your interview with costume that um that that would still exist um it needs one it's relatively easy to get preferential uh this is actually ordering minor but a similar things that support yeah so so the way yeah the way me view works right now on ethereum

mostly right like call it 80 of the MDD Market is there's this like project called flash plots and you can think of that as a Marketplace that connects miners to people building profitable products and sets up an option so that every block you know all we call those Searchers the people who like search for the best Lots every every Vlog all these Searchers they kind of make a bid and then the minor picks from those bids and they won't trust flash plus they're not like from from them and like mess with their stuff um and there's other ways you can do anything you know you can pay a minor directly but like honestly that doesn't like scale and this is why even flashback is like a net positive compared to the alternative because now

like you can kind of submit a block in question spots you don't need to be like you need to ask anyone right like you you still think the trust logs and this is the part you'd like to eventually move away from and flat spots is doing really good work but like reduce the amount of things you need to trust them for but like anybody can can enter this market and that's like hell because if you the alternative is like you need to know a minor and like have a business relationship with them and that's like very hard to do at scale um and so after the merge this actually stays the same so flashboss has been doing like where do you need to work around um allowing your product to scale because the thing um on proof of work there's only like maybe 10 less than 20

mining pools basically on ethereum so they only have to like route this marketplaces like many blocks to about 20 places but after the merge we actually have like 400 000 validators on ethereum um so they need to they need to like scale up their systems such that like it's you know it's able to send the bot to the right person at the right um and so yes Meb will still happen um I don't think there's like a there's no like Silver Bullet for that like the best thing you can do is like you know have a system that's at least like open for anyone to participating scale up to like as many validators as possible and over time like ideally reduce the trust assumptions move more than stuff in a protocol but that's you know the order of like three to five years not like six

months so you have this entities the slash years that find ings I was wondering how discussion and the thing I do know so the slashers they're not like a different entity it's like if you run a validator you can run another piece of software that's like a slashing detection and I'm pretty sure a lot of different by default I don't know how it gets like yeah not a French Run um that's a good question yeah you know and they don't happen like that frequently and the penalty to getting one is not cute like you don't get all

of it so you get something that you want to incentivize people to actually run the software but it's not like millions of dollars or something um but there might be ways to crack products uh way in the back I guess uh my question is realistically when we'll stay withdrawals if you know so yeah yeah so the question is like when can validators withdraw after this transition I I wish I could tell you that you know I I can't I'm historically like you should stop every like six to 12 months you know so that's like so people people often say nine months but it's not because like there's a nine month timeline is like they do the average of

six to twelve is this simpler so it's it's way simpler than the merge right like nothing to do like yeah yeah the merge is like 10x as complicated the thing though is that every time we upgrade to ethereum it's it's like a complex process like there's a bunch of people in the audit after I dying to do at the same time so we don't want to shift just one feature so we'll probably have like three or four things that come in at the same time as withdrawals um and I don't think that delays it particularly it's like you know maybe it's like the difference between like six and eight months or something like that but it's not a difference between like six and eighteen months um so yeah the the upgrade as a whole will be much simpler than The Virtuous yeah um no very good question so like okay so

once we turn on the Jaws you know what if everybody leaves yeah we're not good um so we so we have this problem on both ends of the queue right what if we turn we have to merge after the urge people get transaction fees what if everybody wants to join in order everybody wants to leave after draws so what we do is actually throttle at both sides and there's a bunch of reasons for that but like in short it's like the more people want to come at the same time or the more people want to leave at the same um there's just like a limit and I think right now it's like three or four blocks and blocks for like 12 seconds it might be fine but it's like you know single digits every 12 seconds so if everybody wants to leave it's like we just run

through the queue um and iterate through them but it keeps the protocol stable yeah basically don't change right so if

you're a user basically or if you're a smart contract or an application like nothing changes you know and one way to like make this concrete imagine you're sending a transaction right before the merge the outcome of your transaction doesn't matter or like you don't even know if it gets included in like the last group of work or the first paper statement um so that's that's quite neat um intercession providers they need to do a bunch of stuff you know they need to like the biggest thing that they need to do is that if they were running just one side of this they need to like run the other side and get it to talk to each other and there's like a little token that you need to send so that they don't have to talk into the right one um so there's like some some weren't

there validators need to do this too so if you're writing your validator you're running a node there's like a bit more technical work than like a usual upgrade that usually you only like download the same software new version like it works out of the box here you need to like pass a couple things um and this is why we've had like all these test meds uh since basically December of last year is like we've we've reached out to like you know infrastructures like phones like even swaps and for uh Lido uh exchanges and what happened we were like you know does this work like yeah do you have issues with this and like you know they had to tell us extra um so I think by the you know by the time it happens like end users basically have nothing that they need to do

um infrastructure providers should be very well aware this is why we you know we have these test Nets as well like where a lot of applications are already running um so it's kind of going to happen to them on like four steps to run through the motions before it happens on the main Network um and their hope is that's like yeah when it happens on maintenance um end users basically have anything to do so it seems like the applications no no nothing yes exactly exactly yes and this is why by the way like this thing takes a long time it would be like way easier from the protocol side and who are just like you know figure it out but like this like this idea that like it's like an instant transition nothing changes this is you know probably I

don't know a third or more like engineering work is like making it work like instantly yeah thank you I think it's still not enough because think about right media computers do the same things it looks like a resource of waste I think yeah so let me think I will move to the truth okay elevated power two times yeah we're still in computers after doing different mistakes and I couldn't eat it

even less um it's not gonna be not all computers are created equal like in Google work you literally need on the order of like a small country's energy the power um because we because basically ethereum is worth like some amount of money and like every 12 seconds there's like a new block that comes in that gives people that amount of money people will invest massive amounts into like building new computers you know Finding like the cheapest electricity in the world to like get that money um and so you know the order you can think of is like small country right and I'm not an expert those numbers but yeah um when you're running ethereum node you can usually run one like backwards right like not like your smartphone maybe like

a good smartphone but like you know not like a low end smartphone to think like you know mid-range MacBook you can run an ethereum mode bye so the difference is like imagine we have for 400 000 liters you can run probably like a thousand validators on like a single computer um so that means like if you know we're talking about like coinbase has a bunch of validators if they have like ten thousand violators they don't actually need like 10 000 more Hardware you know I don't know what the limit is but it's like on the order like you can run a couple thousand on a single machine so I mean you probably like can run all of like the actual like block processing stuff on like single digit thousand number of like MacBook Pros and there's

other like infrastructure possible networks but if you just compare like mining machines which take like you know small countries worth of energy and like you know a couple thousand MacBooks it's like obviously yes we could go beyond that but it's still like a pretty pretty massive production and it's like at some point it's just like this is like a computer it's like there's a number of like operations that the computer needs to do that at some point you can't like reduce more um and and I think once we do reduce it the thing we probably can do and is um lower the amount that you need to stake so the reason why we require 32 ether to stake is just because of like the amount of computation and stuff you need to send over the network but like if you were able to like optimize all that

stuff um then we could kind of reduce the amount then like just allow more people to participate are like people to put less capital and participate um yeah so I you know I think there's just like a constraint on like run an operation by a computer but yeah you go from like a small country to like a room full of MacBooks can you speak up there there's a mechanism to accept the box that they create some kind of penalty to to prevent the old buyers uh from continuing to operate on the old chain yeah the difficult amount I have yeah how was that so work yeah so like in 20s yeah yeah so how yeah uh I think I have this

before so in 2014 when this paper came out they were quite optimistic that we could work was like afterward state was like almost ready um so we added the second exhibit ethereum which makes it actually makes mining exponentially harder over time um and you can think of it it's like a very flat exponential curve that that has like a really steep growth um so like for most of the time gets it's like it rounds to zero but when it goes off it really goes off and we call this a difficulty bomb and the idea was like that would be how we would transition from one chain to the other it would just make it like exponentially harder to use the different work chain and then uh people would kind of have to move because otherwise they're like Frozen on the paperwork um and we didn't have I think when you

first scheduled this for like 2016 to write the papers out two years from now we should after the state uh it didn't happen so we've been like pushing back the secondism over and over and over um many times I think we've pushed it back five times and I think today so the actual transition does not depend at all on this right like we kind of realized that it's not the most elegant uh mechanism to transition so this is still on ethereum it does eventually make the change unminable but like the merge timing is congregated from that but you can imagine though so what that means also is that if you want to start um if you just take the software that like exists and makes no changes to it at some point it's going to stop so that

means that if you work ethereum you actually need to produce like software and value that you get people to download and use um for the change to continue and you need to be like able to make that change in the in the software but it's like literally a one might change you know you could just delete a few lines hard engineering challenge to remove yeah but but I think the department list is really valuable is like it forces anyone who wants to maintain a fork to put out software that people want to download whereas like if you don't have that like Bitcoin doesn't have that so when somebody affords Bitcoin um anybody kind of by default like stays on like their Earth yeah stays on like that version of the software they don't have to do anything

um and their history kind of moves from one to the other um so this just again forces at the higher bar there yeah that was Bitcoin classic uh in regards to uh the word I was wondering like let's say I create an application where I have uh my players saying that data um which uh protocol do you think provides the highest third foot like as far as like storage file coins and um sorry I don't know enough about that I I mostly prepared to remember as well um I worked with the salon a lot more

and more familiar with that with youth 2.0 is it going to be what is it going to operate very similar or Solana or nuts uh no it's a short answer yeah yeah it doesn't make any change how to make it possible yeah yeah how many people have access to the total team number it's not chosen yet so like I guess chosen under what they're called this is like my day job I I run those calls and like you know you can watch the live stream you might be lower foreign so you could just like watch that

um and then when all the software versions are ready then I usually write a blog posts and I say hey things are on the software versions and that's usually when people pay attention but like there's no there's no like private like oftentimes I don't even know the number was going to start hearing a feature for the for the merge code like so what we want we want this you can map like these difficulty numbers to time right like so the security bit is we kind of know when we want if when we're ready to do the merge no no no no no it's like months before dude there's like some the security considerations right on the order of the weeks um but like so we can say you know imagine the reversion tomorrow right like right August 10 you could be like okay we're we're ready today

um we need a week to put on the software that's August 17 and we want the merch to happen like three weeks after that because and one of the reasons you just want everyone to have time to upgrade before the upgrade happens because otherwise it's like yeah well it doesn't crash it's just not a nice future experience um but that's it so yeah I decided in secret it's all public uh you can you can try to call them and see it so is it going to be on time for September or I mean we're yeah we're looking good like I I we don't have the time yet um I think that people want it like we have this last test net if if everything goes well then we'll probably figure out when it happens uh right after that what are your gut feeling of there's another

delay making happening uh it's hard it's like predicting that on the notes like you know if I think things look well um I think the software we have today um you know if proof of work was banned tomorrow the ethereum networks could like work with that and even that's the thing yeah that's where campus lessons like ethereum is like made to work in pretty adversarial conditions like we were talking about all like these exchanges attacks and whatnot and like the chain can self-heal from all that so like the some sort of at work tomorrow but the question is like how smooth do you want it to be right like and and like and also if you think about like ethereum doesn't have to just upgrade this you know we need to ship scaling we need to solve all this energy things and it's just longer than six

bucks if the chain is like in chaos so like if we can catch an issue on a test map and fix it before and say it hits us two weeks to fix it but if we did we probably want to fix it um assuming it was listing that there's a team meeting to work more smooth or hard enough there's like 10 teams working on this so it's yeah I have a question I actually comment you know this is way back in 2012 and the question is this you put up certainly theory in this mistake how does the network of double Panic

look well that is aerial section is produced by The Beneficial workers who may not have the best Israel yeah it's a question yeah yeah the question is like how can you know basically who puts the stake we can't um and this is like this is not like a proof of State problem or like even a blockchain problems like a private key problem like the access to like or ownership of coins on a blockchain is like you don't you don't ever actually have authorship right like if you think about it but you have you have a private key that gives you the right to sign a transaction that does something with those coins but like you and I would share market teeth and like you could

move the coins I can move the coins um the protocol cannot tell like and it can't tell you know you're not going to have a private key because like we're friends but you can steal my private keys with the clients or I could steal yours and the protocol cannot discriminate between that was speaking that Bitcoin in an adversarial way which really belonged to its uh yeah it's kind of similar to like what this guy's talking about like coinbase attacks the chain so basically you know

the protocol doesn't care that coinbase stole the coin as a coinbase bought them that it's important about the protocol should be able to deal with that and this is what like we were down across call center time uh foreign imagine for example coinbase takes their users funds they attack ethereum you know they'll get sued we have mechanisms in the real world to like deal with digital primes and put like the ethereum protocol does not adjudicate that like it's just technologically impossible hey God that's exactly as much information to be honest memories so the protocol itself can can heal from

the attack from The Exchange and that's how the protocol cares about like it keeps chucking it off the protocol camp like Sue coinbase and no storage that's what your birthday you can take in case yes and that's kind of the person yeah yes yes yeah yeah exactly so the network stuff here the one point where you need humans to recognize is this point where it's more than two-thirds of the stake attacking and they finalize something bad you need the humans outside the protocol to say well wait actually the main chain the one or two thirds of the

stake is the wrong one we want to keep final we want to keep following that one um and this is like the only point but they're not they're not even like looking they get a choice between two options right you don't get like a more granular level than that and you know it doesn't have to be two-thirds it could be like 80 20 whatever but they could the community would then need to look at like the minority chain they could objectively prove that a protocol rule was broken on the majority chain um because the two chains are disagreeing um but then you get like the humans to like select the smaller so the protocol it's not self-healing in that like it gives you the choice but you still kind

of need to imagine another Direction so in that situation basically no so what would happen is the economic minority would would uh vote for the minority chain it would see the majority Chinese as invalid it would punish it up to the point where this what was the economic minority then becomes a two-third majority and then it would be able to kind of get back on track um yeah and and then by then it's like you would have destroyed half of the capital at least of the economics majority which would now be an economic minority because of their capitalist is important and whatnot like it's not

you're not like blindly following the chain all the non like all the non-validating nodes also check the protocol levels so it will take maybe just a couple more questions I think I think well you'll be safe yeah obviously in Europe but yeah uh yeah YouTube you have your hands up um uh you're on the column for now okay uh yeah sure uh two questions the main thing I would uh mostly not

affected energy boost is the software that that like manages most of that I would recommend looking at that but like mostly unchanged yeah um and it's sorry was the second question um yeah they can still happen but basically we have this finality points so we can kind of Gap them in practice they have them way they're like much shorter than the finality thresholds like so you'll still get like you know probably like one to three block New Yorks those are still like expected um it's just you can't get like a you know very unlikely to get like 100 um which is still unlikely today but you get like a better uh delimiter there goes down as more people want to Stage

right so like um the fact that happens it means that at some point you have to have an opportunity cost your Capital as well right so you know say you you're earning four percent um a bunch of people come in now you're earning two percent um you can leave it there that's fine but it's like you might be able to earn three percent Elsewhere on my capital and move out so it's like sure you can stay there forever and that's not necessarily a bad thing as long as you're not blocking other people from coming in and as long as you're not creating like a unfair you know playing field um and and I think careers sake is not perfect but it does have a quest before it came out of your car it's like you know for example if you're rich you might be able to tolerate the two

percent return more than like somebody who like needs a better like the outperformer so you know you might have some advantages there but you don't you don't earn like a larger share of returns because you have the market share of the stake which is true of work so you kind of go from like you know very asymmetric rewards to like you know more or less symmetric but not perfect still yeah I'll try to do that quit and clear um anyways I can't find the slide okay so we subjected the idea is like if I give you if you're offline you're not on the internet I get you two potential

histories right um and I you you need to tell which one is the right one and proof of work you can just look at the math and know and right you can like look at my block 100 know that like it points to block 99 you know that's like all the map checks out blah blah um and you know not only that the blocks are valid but you can you can ballpark how much energy was spent to produce those products right like so you can know this is not only a valid chain but like it's a valid X expensive to to forge chain um and so this is like a a nice property in Cooper State because there's no cost to create a block right because it's like random Lottery you can imagine that we have a state chain from

um and then all the people who were validating they've moved on I go and I ask them can I get your old private key and they all agree or I steal them I don't have to give it to me but like I take everybody's private key I created an alternative history right where I like have all these blogs and the same validators and because I have the private keys I can sign different blocks then I I give those to you you're not able to tell which one was the real one so and this is like this concept that we subject to it means that to tell between those two you would need to get back online on the internet ask you know the network for like the latest blog and you can confirm this many places right you don't you don't get one source for

um but you need to get back online ask the network and and it doesn't even have to be the network right you can imagine you run a note you get a box you go on either scan you get a block you on coinbase you get a block you ask your friend and like those four options when you have that information then you can look back as those two chains and make out the right one but it's like that extra constraint that we have is just no way around it and the benefit is we don't need have all this computational resource yeah I'm sorry last one and then yeah I think we're already at the oh with Bridges right um yeah so there's a lot of bridges on it there have to go to other places and

they tend to get hacked have issues uh because the merch changes nothing for applications like the good part is like there's no transition but it doesn't improve security there unfortunately um so there shouldn't be more effects but like there will be necessary um yeah I think we're already Beyond but uh yeah thank you so much