One Ethereum: Same Block, Every Chain (Part I)

Transcript

[music] [music] Hi, it's a pleasure to be here today. Perfect. So, Ido and I have merged our talks to one giant talk. So, this is going to be a 40inut presentation with three live demos because if you don't do live demos, where's the fun? um we will try to convince you of one thing that Ethereum can grow without growing apart that Ethereum can become um the economic substrate for the economy. So we will

actually start off with um a demo that we couldn't have shown you this way even a few short weeks ago. So it over to you. Hello everyone. Um today I I have the feeling that I only have one job. Um this job is try to make your brain explode with all the thing that you can make and achieve with easy. Um, I know that maybe that is too much, but you know, um, when you have this feeling of something that clicks on your brain, when you start to discover new

ways to do things, to put all the pieces together, um, like something even bigger, it's like something so amazing. That is how make me feel so excited. And today I want to share that assignment with you and make you be part of it. So I going to bet hard on that and that is why we are going to start with a live demo. So you can understand what we are talking here today. So when you start to figure out about fragmentation probably the first thing that is going to come to your mind is liquidity because this has been a big issue for a long time and the natural

thing to think is okay maybe with atomic composibility can I have a token on L2 go to L1 make a swap go back and get the the final on my address and The answer is yes. And that's mainly what we are going to do now. So mainly the user is going to sign a transaction sending to um go settlement contract and with that it's going to be bridged to Ethereum. We are going to perform a swap. We are going to glitch that token back, resive it and get it on the wallet uh in the wallet of the user.

So let's try to make it happen. So for that we have created this uh small UI in in this UI you can see that I own uh 0.004 004 rapid uh e and here I have the list of tokens available on the one. So as you can see here uh some of that has been bridged before but I can bridge a new token that even doesn't exist on Ethereum right now on sorry on my on my L2 on the rollup X. So let's pick I don't know one with some liquidity maybe this one. Right.

So the thing that I'm going to do now is uh to ask for a quote. So this is mainly how how much tokens I'm going to get on on mile two. I can pick the the slippage. Um I can see the price impact but it's mainly to sign a traditional order for of an intent. And as you can see here uh I'm going to use rollex on mainet. Um I'm going to buy a token uh the receivers the sell amount buy amount traditional order right so at the moment that I have signed this I going to have a solver trying to fulfill my request

and make everything that happen uh on just one atomic transaction. So this is the thing that we are going to see here that mainly we can see here uh the transaction and as you can you just saw this has been settled atomically in just one transaction. The feeling of this is instant. It's like something that has been atomically done and you can have this perception of being something magical like the having just one big chain. At the end it's just having one Ethereum. But let's take a

look to the transaction because that is probably [snorts] the important part. So we have here the rollex delto and this is the transaction and also we have here the ethereum main transaction. Right. First thing to notice here or one of the most important thing is the time stamp. As you can see the time stamp of this transaction on Ethereum has exactly the same uh transaction the same time stamp as the L2. Right. Yeah. Correct. That's great. So that means that everything is happening atomically or everything succeeds or everything fails. And here we can see what you what we have just

done. We have got the rapidities. We have move it to uh L2 universal V2 root. We have bridged to L1. We have minted back the tokens on L2. But also we have bought the thing that we have bridged from L1. And we can see the the other side of the equation where we get the token in Ethereum. We um swap it and we send back to the L2. And that is mainly the magic or one of the most powerful things that you can do with uh easy is that you can use directly liquidity on Ethereum without having any liquidity on your chain. And

this is really really powerful. >> Cool. Fantastic. Can we go back to the presentation? >> Yeah, sure. >> Fantastic. Very quick show of hands. How how many of you understood what Idu just did? Oh, perfect. Such a good crowd. Um there's um a Q&A um uh QR code here. Um we'll go through all the questions after this talk. So kind of if you have questions submit them here for sure we'll have plenty of time for questions.

So what Ado just did is he made a transaction on a rollup that actually traded on mainet liquidity within the same block. So kind of let me remind you how we got here. So Ethereum scaled and then it split. So I don't know how many of you were here in 2019 2020 when we had the fee craze um where an average transaction set you back tens of dollars um in response to which we actually scaled Ethereum by deploying layer 2. So if you look at this this is um money uh in D5 protocols on uh various networks.

So you can see there's $46 billion on Ethereum mainet and then um there are if you tally this up does this work? Yeah, if you tally these up you get around $9 billion on all the other rollups on top of Ethereum. Um it looks even more skewed towards Ethereum if you look at um assets that are not deployed in DeFi. Um if you look at um account balances and stable coins and idle assets and so on, you end up with 140 billion on Ethereum mainet and um around 10 billion and on all the other L2s combined. And

that's actually overounting the L2s because a lot of those are actually bridge balances where the actual token sits in a bridge contract on L1. But interestingly, seven in eight transactions actually happen on a rollup. Okay, so almost all the money kind of one in $6 D5 is on a rollup. Five and $65 is on Ethereum mainet, but seven and eight transactions happen on a rollup. So the users moved, the money stayed.

what Edwood just showed you and kind of if you look at these circuits again um these circuits are connected by bridges. Okay, so between each of these there's a bridge and the bridge comes with weight times and wrap tokens and every one of those bridges is a target. Okay, we've seen so many billions lost in bridge hacks since 2020. It's crazy. It's absolutely crazy. So what ID just did is he tore down one of those walls between the rollup and Ethereum mainet. He created a transaction um from a smart contract on roller hacks that called

into a smart contract on mainnet gave a return and used the return in this very same block. So same block, one transaction, zero wait time. So in the same block ID, can you explain to us how it's done? >> Yeah, for sure. So yeah, mainly um I don't want to give you this impression of something that magically happen. Uh I know that sometimes you have this feeling of instant but for making this happen, we need to do a couple of things. So the first concept that I would like to explain in here as a high level thing is how we can make that happen. So for

making that happen we we use a contract what what we call it proxy. This is not a an upgradeable proxy. It's a different thing. So mainly this is a high level explanation about how this works. So mainly your contract makes a call to the proxy. This proxy is the representation of a contract on a destination network. So this proxy needs to behave as the destination contract was on the same chain and for making that happen the thing that we do is that we forward this call to the EC manager where we have what we call it entries mainly the entry is what is expected to happen on L1 if that happened on L2 it's like we were

doing a kind of virtual call so when you make this forward call to the it manager if we found a valid entry. After being verified, two things happen. First thing, we move [sighs] the rollup to the nest um state route and also we return the result to the original contract that called this and um and this is really really powerful as you have saw. And now I need to introduce another concept um the composer. The composer is the component in in our architecture that allow us to make this happen on real time. So mainly how this works is that the user send the transaction to

the composer. We pick that transaction and then we start the execution of the original network an EVM traditional EBM. At the moment that we detect that it's calling a proxy we go to the destination network we continue the execution. we go back with the result and we back and forth all these calls. So at the end of the day at the at the end of this process we end up with what we call it entries that is the result of this simulation. And the cool thing is that we can do really really crazy things with this in the sense that we can do nested calls, revert returns, re-entrant calls. We can do whatever we want and

this is just an example of L1 and L2. This can happen between L1, L2, L2, L2 and go back. So at the end of the day the thing that we are doing is just assuming this state on both chains. What will happen if both transaction execute at the same time and with that we create the execution entries that is the result of this simulation. So if we sum out a little uh we can probably understand better how this works. So the user send a transaction to the composer and the composer perform this simulation on real time and we get the state root changes on the

destination network according to these calls. Um the most important thing uh is the proof system. This at the end is one of the enable enablers of this technology. So after this simulation we end up with a valic L2 block and a transaction on the one. So the thing that we need to do now is to verify that this execution has been correctly done from the protocol perspective. EC allow you to pick different types of proof system. For instance, you can have an ECCA running on a TE. You can have and that is the goal of of easy um LCK proof for instance running by disk that verify

that this compos uh this composition has been done in the right way. We support not just one proof system, we support multiple proof system and the idea is that rollups can combine this to minimize that assumptions. So you can combine two CK proof system with one ECA just to be protected against soundness bucks for instance. So at the moment that you have performed this uh validation you get uh the composite gets this signature of generalist proof and then is when we create a bundle. Um so the thing is to make this system work we need to work closely uh on that sense to builders because the idea is that okay we have

generated uh a system transaction what we call it post and verified batch and then we add the user transaction after it. Why in this in this way mainly because we first load all the entries and then that means that all the execution transaction from user can be succeed. So that is why we are I mean currently we don't need anything extra from builders. This works as it is but we are closing we we are working closely with them in order to make this as most efficient as possible.

So the point is this when you have this bundle we submit it to Ethereum and if the uh transession goes as we expected we trigger that execution result on the L2 meaning that we transitioning from the one state route to the next one. If this assession doesn't work as we expected we roll back both so nothing moves there. And yeah that's mainly the magic. This is kind of a one-on-one. Obviously, this is more complex than this. We have really good documentation.

Um, and we are happy to explain that we have videos. So, feel free to ask any question. And now I need to make or something like a big announcement. But the issue is that I have already spoiled it to you. So, we have um deployed the first experimental mainet devet running easy. the first EC roll app connected to Ethereum that is able to atomically compose uh with Ethereum and as you have saw this powerful of this is is amazing the the thing is and I think it's important I need to make a disclaimer uh this is experimental is a demnet please take it easy um we have done this for

for a reason the thing is when you need to do these kind of atomic things you want to you use liquidity, you need to work with builder. There is no test net that can help you to do that and being able to do that in mainet has helped us to understand the system to start to create this cool samples that we are going to show today. So is the perfect environment for us but also for builders to start to create new application that even doesn't exist today. So that is why we have uh opened this to anyone. So you can play with it and yeah just please take into account that maybe we need to rest it at some point. We will try to

let people know but yeah take it easy. Um so as I mentioned before we have quite well documentation just to make easy to understand how this works and we have all this and uh at build.e.io. audio. >> Yes. Super cool. Fantastic. So, we've actually seen this before and it was quite a long time ago. 1983, the day that various networks became the internet. On January 1st, 1983, every ARPANET host switched to the then very new protocol TCPIP.

Okay. It allowed TCP IP was built as a gateway to kind of connect different networks. A very thin standard, very much like the easy, it's not a new stack. It's very thin standard. Um, back in 1983, satellite, radio, wire networks could connect as they were. So, they didn't change themselves. It just gave them a way to talk to other networks that were unlike them. And just like Ethereum, no one runs the whole network. No one runs the entire internet. Each network sets its own rules and communicates um

with the other networks via this standard. So it's permissioned at the edges but it is very neutral at the cool. That's super important to remember here. Okay. And we have the same on Ethereum now. So you can have liquidity and function calls across different chains in the same block on mainet today with roller hex. So to join a network must have fulfill exactly two rules and you implicitly saw them in IDU's presentation but let me make them very explicit here. So the first one is to prove its state in real

time. Okay, in block time kind of on Ethereum now is always 12 seconds long. That's because that's how long it takes to build a block. We don't have continuous um time. So we don't actually need to do it um in machine time. We if as long as we can do it within the block time, we're good. And the second rule is you have to be able to follow Ethereum if Ethereum reooks, right? Because in this architecture, what you actually end up with is a transaction that spans two blocks. Okay? One on Ethereum and one on rollup X. So if Ethereum kind of drops this part of the transaction, um the rollup needs to drop this part of the

transaction as well, right? So you can't have a dangling transaction that needs to be that needs to be insured. But that is the whole spec. Okay, that's all there is to this. I'm making this sound much easier than it actually is under the hood, but those are the only requirements we place on joining rollups. What is not required and I'll make this super explicit. You don't have to be an EVM chain. You can use whichever state transition function you like. You don't have to be public. You can be a private network. So you can have a private network synchronously composed with Ethereum. You don't have to be

permissionless. You can be a permissioned network. You don't have to have a particular prover. You don't have to. There's no new token in this. And most importantly, this works for Ethereum as Ethereum is today. Nonem private and permission networks can join on exactly the same terms here without asking anyone. And this kind of really falls back to this crops nature of Ethereum. So this [snorts] this censorship resistance kind of you can partake in this without asking anyone.

So why now? Very good question. Um so it's to do with zero knowledge proving it just told you um that um uh that we use adustations right now on rollerbacks. That's very much an interim thing, right? So we'll be able to kind of prove this with a zero knowledge proof in real time. and zero knowledge proving just got much much faster. So on Zisk we can now prove 99.9% of blocks in um 10 seconds. So f shorter than the block time with full um gaming GPUs um at.3 cents [snorts] per proof.

So nothing changed on Ethereum. It's just that proving got fast enough. And this becomes even more important now because over the last couple of weeks um it's come top of mind for most of us that Ethereum's cryptography very much has an expiry date. Okay. So every kind of everything relies on um uh on elliptic curve cryptography in Ethereum land. So every account signature, every validator signature, every blob commitment relies on this kind of um technology which is susceptible to um being hacked by a quantum computer. We don't know when this quantum computer

might come, but it might be sooner rather than later. So we need to be prepared here. Why can't Ethereum just add postquantum safe cryptography? Well, every new scheme needs a hard fork because it becomes a pre-ompile. Um, and the standards are still changing on this. Um, then, um, the signatures themselves are just much much bigger than what we have on Ethereum today. Um, so the NIST standard, MLDDSA, is almost 40 times as big as a standard Ethereum signature. and um Ethereum just doesn't have enough throughput. So kind of even by the most optimistic standards of

scaling L1, we can get to um eight megabyte uh per second before it gets really uncomfortable. So as Vitilik said a few weeks ago, it's not a blockchain, it's a cryptographic world computer. You keep computation of the main thread where you c can. So if a rollup runs the new cryptography, Ethereum only needs to check the proof. And this is exactly what an easy rollup can do and one I am proud that I can demo for you today.

>> Thanks. So when uh when I try to explain how easy can Ethereum, I usually try to tackle this uh from three different angles. uh we have saw the first one that is liquidity obviously not fragmented liquidity of Ethereum is a real value for Ethereum and this is the second angle so we can use easy to um move computation from Ethereum to a rollup um so I decided to pick this example of uh Falcon uh postquantum signature but before starting I would like to make a

big big Disclaimer here. Um, easy is not resolved in postquantum. This is not postquantum secure. This is just a cool example about how we can compute something that costs a lot in Ethereum. It also is a lot of cost in terms of uh call data and do that on L2 and use that directly on L1. Um if you're interesting about postquantum computation post postquantum proof system also six pro u uh easy proof system Jordi tomorrow is going to talk about that. So what we are going to do now is mainly what I have just mentioned. This is probably the

most simple case of easy. So I have I going to have a a falcon key on my browser with that I going to sign something. I'm going to send that signature to a contract on mile two. After the verification, this contract is going to call L1 and trigger a payment of um safe that I control on L1. I for me this is the simple example because this is just call return and obviously um that is probably the very basic case for for EC. So let's see this happening on real.

So okay now we have here falcom easy um easy website I have I have my fong key again this is not secure please take it as an example um so mainly I am generating uh public key postquantum public key it's very long I use keak to identify this key and this allows me to identify this key on L2 and in order to identify um this uh falcon key on L1 I use the proxy as an alias. So the thing that I can do um very easily with this is I can make or trigger

a payment on L1 just signing with my local Falcon key and sending an L2 transaction. As you can see here I am calling this uh on mile two and this is what I was want to show. This is a lot a lot of uh amount of data but the good thing is that our rollup is not using cold data on Ethereum is using blocks. So that means that just because of that we are going to pay less right.

And um and the first thing that we can see also here is that this is the transaction that I just executed on mile two 5 million gas but I have paid that at um mile two cost not at one cost. And the second the second thing is that we can see here the settlement happening on L1. As we saw in the first demo, [sighs] we everything is happening atomically.

And here I only paying finally 230k of gas. And this is a way to understand what is the potential of this. This is a comparation of cost. Obviously postquantum sample is not real but you can imagine another new primitives. You can en envision a way to start to adding primitives new primitives to Ethereum without the need of forking Ethereum.

And that is really really powerful. Um, but we can go beyond that. Obviously, I I did the silly thing. I got a signature. I I took um a smart contract. I verify a signature. I can be I I could try to be even more um more hard on that like having my own prempiler mail too. But there is something that is even even better. That is something that um Freddic just mentioned before. So what about if I can have a nonvm state exchange who is only only purpose is to verify signatures.

Sometimes you you don't need the signature, you don't need anything, you don't need to pay for data, you only need to prove that this has happened. And that is one of the most powerful things that [snorts] EC allows you is to being able to use this directly without the need of all AVM. You can understand this as the key store concept that I think Vitalik introduced some time ago. So you can have a network with keys that is able to operate with any chain connected to the same network. But this is just an example. We can start to think uh about hundreds of different use cases, different dabs, DAP chains. This

is so powerful and especially what is more powerful here is not creating because we can create that right now, right? But being able to compose all of them together is what gives this more uh a more powerful solution at the end of the day. >> Okay. >> So what IDO just did is add new cryptography. Okay. It this is not the only difference that kind of you can add here. So this works for public EBM rollups. It works for non EBM chains. It works for private networks and it works for permission zone. So, so, so a central bank network, a free trade zone and so on. Um, we've seen this movie before. So, kind of in the 80s and 90s,

people went online via America online and Prodigy and Compusf and they had their own walled gardens. Okay? So, you had your email there, you had your forums, you had your chat box bots, you had your news. Um, and people were generally they did their things there and then the open internet came out and all of a sudden everyone could create content out in the open. Everything was just one click away. Um, I should say AOL had 30 million users. Kind of talk of a blockchain having 30 million users.

E so kind of um but there was kind of within a couple of years there was so much content outside of the world gardens that people started to leave. So what AOL and Prodigy and the others did is they bolted on kind of um some sort of D into the open internet and that's actually what they became in the end. They kind of they became they became kind of dialup uh rampons uh on ramps to the to to the to the internet. Um what happened at the same time is internets. So internets have the same idea. So kind of it's a gated system but it runs on the same protocol. TCP IP. So you can have your um company owned network that still

connects to the internet wherever needed. And we still see those. Okay. Um and that's exactly what the EEZ does. It extends Ethereum without changing it. So there's no new stack. Any network that proves its state within a block can join. All existing L2s can join this. It's not a new stack. And this really makes the Ethereum an economic operating system. So if you look at how today's economy works, you have a bank, you have an exchange, you have a clearing house, a payment network, a registry, a custodian, and they all kind of have their own books.

Okay? When they want to talk to each other, they send messages and then they settle and reconcile a day or more later. Okay? In this new world, this is a paradigm shift for how economy works. Okay? So the bank, the exchange, the clearing house, the payment network and so on, they can still have their own network with their own rules permissioned if they want. Okay. But ultimately state is settled on Ethereum that makes them able to compose with one another in real time. So instead of reconciling you can actually compose instead of doing this in days you can do this in a single

block and instead of intermediaries that you use to send the messages you just have proofs. So um let me give you one last de demo from Edu um on how this kind of translates to treasury management. So yeah I have mentioned that usually I try to tackle three angles and this is the third one. So one of the thing that we have lost due to this fragmentation is user experience. So it's like we have uh moved this problem to users they need to go crazy to do stuff in different network and we have forgot them for a

long time. So this is um typical case. You have a safe on one network. You have another safe on another network. You want to rotate keys. You need to trigger a big amount of um transactions in all of them. And this is like [snorts] the most painful thing that a user uh needs to handle today. So EC also helps to improve the user experience because we can coordinate things um through this um protocol. So for this example I have decided to create uh what I call it a mirror safe on L2. So mainly the idea is that every time that I want to make a

transaction on my L2, uh I'm not going to um check the owners of that L2 safe. I going to call a smart contract that makes an atomic call to Ethereum, read the real owners of that safe and give me back if that is a valid signature. And this can happen in just one transaction. But we can even go a little bit beyond of that and we can start to think about one payment from two safe balances. We can have to we can start to think about a common treasury.

So another thing that we can do with this is user wants to pay $100 in one chain but it only have 40 USC on one side 60 on the other side. So with this the thing that we can do is just we can have a common policy even we can um have allowance that is applied to both sides something that today you cannot do and you can speed that payment. So atomically you can ask uh to the L1 to send 40 UCC and ask to the L2 safe to pay the rest and that is how we can improve uh user experience. So let's see this in action.

Um so yeah mainly I have um a shared treasury where I have a budget of 150 USDC and I have uh different amounts on on uh my safes. Uh the first thing is we as we just mentioned we are sharing owners. So the L2 safe is reading on real time what are the owners on on Ethereum and this applies [snorts] for every transaction is not just uh for every block and you don't need to synchronize anything. So I don't want to do it just to speed up a little this but if I had an owner here I can sign something on L2 directly after

this transaction. But another cool thing as I just mentioned is that I can trigger a payment from um from my L2. I can pick an amount of I don't know $1, pick a recipient and I going to make the payment on Ethereum. And I can do this. I can just pick exactly the percentage uh of the amount that I want to use from each um safe. But I can even make this [snorts] uh even more complex. I can make a swap before send it. I can do a lot of things that it was or impossible also hard for users to do it. That makes no sense. But now we go in this direction of just one Ethereum and with

that uh we can allow this kind of application that it was impossible before. So I only need to sign a typical safe transaction and submit it to the chain. So now we need to wait for the settlement on Ethereum as we as uh explaining on other slides. Now everything is going to settle atomically at the same time or is not to happen. Um another thing that we have explained it before is that obviously for that we use the coordination with builders. So the idea is that we submit the bundle and we add the user transaction with the idea um of making uh happen everything

atomically and is it just happen one signature and a payment from both chains going to the same uh network and that's how one Ethereum looks like. Oh, can you go to the >> No, >> perfect. So, [clears throat] what does this mean kind of? It means Ethereum effectively becomes an economic operating system. So, you can have all different kinds of um chains built on this. You can have institutional zones with um their own rules and Ethereum's liquidity. You can have app chains for

instance that have a say transition function that is given by their central order book matching engine. um but that still compose with all liquidity in Ethereum land. You can settle payments where the money already is. You can have data feeds where you can put loads of data um on a much cheaper chain and you only pay the gas of L1 when you actually use the data point on L1. So for builders and I expect this that's most of you in the room. No more kind of deploying your smart contracts on 10 different chains. You deploy it once and it is automatically

accessible from everywhere within the Ethereum economic zone. So that allows Ethereum to become an economic operating system with separate institutions, one shared state that all settle together. So, and because this is um the question that I most often get from the technically minded people in the audience is why do we actually need this? Okay. Um how how big do I have three more minutes? Yeah. Okay.

>> H >> if you can going to write it up so we have a few time for answering a few questions. >> Okay. Perfect. Um I I'll tell you uh very quickly that um kind of the the um throughput is the um the real bottleneck. Okay. So the bandwidth so compute and state you can solve but the bandwidth is the real problem. I'm happy to kind of do the maths with you um on a napkin. Um it's very simple. So kind of you um very optimistically assume that Ethereum could in principle two do two gigas a second. That's 8 megabits per second. That's enough for 300,000 um payments per second. And you can see that kind of payments generally fit

under this. But if you look at other transactions of value, they very much don't. Okay. So if you want a chain that can only do payments, you can do it on L1. If you want um a chain that covers the entire econ economy, even with all of the things that I'm not even mentioning here, kind of like reputation, votes, identity checks, um at um auctions and so on, there's no way you can do it on a single chain from a physics point of view. So you actually your only fallback option is having one chain um that kind of unites everything into one coherent system.

Cool. Fantastic. So, how do you how do you get involved? So, you can look at rollerbacks. Um, it is out today. The DevNet is live. It's public. Um, as um IDU said, it is a devet. So, don't spend unlimited amounts of money. If you want to use this in production, Nosis chain is going to be the first chain who will be fully compatible in Q1. Um, it will be fantastic for applications um that require being able to do things at a low cost but still want to tap into mainet liquidity. If you any of that sounds interesting to you, there's tons of QR codes here that you can scan. Um, you

can also ambush us at the conference. We're here to talk to you and come visit us at the EEZ booth. Try our very cool demos. There's one more on privacy from the Bermuda team that I unfortunately didn't get to get to show you because of time. Um, and if you complete the challenge, you get this very cool Beethoven pin that says code to composibility. Cool. >> All right. Great. Please and applause, Frederick and Eduardo. That was massive. I mean and I personally love the parallelism with TCP IP to understand the magnitude of this shift.

So congratulation. We have uh several questions uh from the public. I mean quite a an engaged and expert audience I would say. So uh I think the main topic here is finality right? So we have just few five minutes to to answer those questions. So let's try to answer maybe the first two questions in once if you if we are available. I don't know if you Frederick or Eduardo. >> Yeah, I'm happy to take it. Do you want that? Okay, I'll take it. >> Yeah, sure. >> Okay, >> so we can go with the first one, right?

While the transaction is waiting for layer one to finalize, what happens to alert to transaction? Do they queue up? >> Yes, it's a very good question. So kind of in principle, you have to be able to reook with Ethereum if Ethereum reoke. So as you say, Ethereum finality is two epochs. So that's 12 1/2 minutes or so. So that in principle is how far back Ethereum can reorg. In practice, Ethereum reorgs almost never. So kind of there's five to seven oneb block reorgs a day. We haven't seen a deeper reorg in many many years. And there are active um uh there are active um desires to kind of actually have much faster finality than this with with a single slot finality or at least a couple of slots.

In principle, you have to be able to reorg back um to the last point Ethereum was final. Your your um rollup cannot finalize before Ethereum. That's the hard truth here. But there's no way to actually have synchronous composibility if you try to sidestep this issue. >> Yeah. So what the second So the first question is answered. Now let's go with the second one. Still on the same topic. Uh it's more about the timing, right? So say a finale takes around 40 minutes. So it's safe or correct to say that the transaction wasn't finalized.

>> I mean this is this is technically correct albeit not practically correct. Okay. And if you look at how long it takes for instance to kind of deposit things in centralized exchanges, you also see that the risk underwriting is on your side here. >> Great. Very sharp. Uh let's move on with the third third most botted uh question. So more about security and simulation. So how can wallets and user simulate this transaction before executing in a safer way? Is that possible?

>> Yeah, absolutely. So kind of it's actually simulated by the composer um kind of the devs who actually build on this they have this they will have this built into the dev tooling. So it's already part of the remix stack for instance. Um it's um before the transaction is put on mainet it's simulated by the composer and only things that will actually make it through are included. >> Great. Right. Hopefully um let's move next. So still in the uh safety angle. So [snorts] if these sorry uh is this sandwich attack and from running safe?

>> So >> and if so how can you please explain? >> Yeah. So kind of this has the exact same caveats as any other transaction that you kind of submit on mainet. This is subject to where it is in the block and obviously the block builders need to order this such that it can execute but it is not by default um safe from front running as is no other transaction that is submitted this way. >> All right great. So now we move on the interoperability part of it which is the core. So they are asking about uh if one [snorts] moment this solution work when an optimistic roll up uh based layer 2

is interoperable with zkb base roll up is that >> so I assume that most optimistic rollups will actually switch to a zk stack soon. So this only works for rollups that can um proof their state within the block time. Um so those are the two rules right kind of like you have to be able to reook with Ethereum you have to be able to prove your um your state within the block time. So optimistic rollups don't do this but if you look for instance at the optimism stack it's built such that kind of you could prove it optimistically if you had a prover.

So kind of uh I I assume this is just going to be um the gold standard in the future. >> Great. And then maybe last question uh more on the infra side. Who runs the composers? >> The composer is just an overlay, right? Kind of the composer just has to understand what is the state of both chains. Okay. And has to work out whether the transaction actually fits together on both sides. Okay. So the running the composer's permission is right now we run the composer but any of you could run the composer if you wanted to.

Great. So thank you again Friedri Eduardo. That was a great session. I'm sorry we could not answer all the the questions, but if you want to maybe engage later, you can definitely engage, right? With >> We're here. We're here. Come to the easy booth or find us outside. We're super happy to kind of nerd out about this. [music]