Modular March EP 17: Modularity is a Meme with Scroll

Transcript

welcome to modular March I'm handy this is Robbie and we are the rollup modular March is an educational experience about all things Moder [Music] enjoy [Music] [Applause] [Music] welcome back to another episode of

modular march today we have modularity is a meme three dots from TL maharramov a contributor from scroll and a big researcher in the space t you've been doing a lot of technical research and kind of trying to push the boundaries for ethereum scaling so I'm excited to understand your perspective on modularity today and welcome to modular March hello hello thanks for having me yeah I I'm not sure if I would consider myself to be working directly on scaling I mostly just spend time arguing on Twitter with other people about definitions I'm not sure if that counts as a contribution but yeah in a very very optimistic framing I think I do contribute but yeah I don't I don't want

to be considered to be the contributor no no worries um I think you're going to contribute to the uh the current narrative and meta of modularity with this presentation so when you're ready let's Dive Right In perfect yeah so as Andy said my name is to girl I I'm a contributor at scroll and today the title of my talk is modularity is is a meme and so is everything else so you might have heard about modular chains or modularity all Haler King Nick white and you might have also heard

about monolithic chains or as some people call them integrated chains and I present our protagonist today Kyle salami so what makes a chain modular so I'll I'll refer to a Celestia blog to Define what a modular chain is even though I don't completely agree with the definition but let's take it as a starting point for now so uh a modular chain is a chain that that basically has the uh a chain that has the following for functionalities and I'll Define how we Define a module chain based on those functionalities so uh first functionality is

execution and uh execution is a process of transitioning the state through user generated messages so uh let's say user creates a transaction sends it the protocol processes it updates the state so and by state I mean a union of all the accounts of all the users and smart contracts and once the state is updated that's called the state transition uh then there's settlement or the correct definition would be validity but celesa uses settlement and settlement is the process of enforcing proposed state transition because let's say if I propose a state route that is an outcome of a certain State transition it might be the case

that that state transition is incorrect and was invalidly computed and so validity or uh settlement allows us to basically enforce that that state transition was actually uh done correctly then there's consensus or ordering which is the process of reaching Global agreement of all the nodes and the Hest nodes in the network on a specific ordering of transactions which means that if you have like a sequence of transaction a followed by transaction B followed by transaction C once the consensus is reached on that sequence you can no longer reorder it later and say that transaction C came before transaction a and that's important because let's say if you are

using an amm and you want to settle a certain value if later somebody's able to come in and say oh actually I my transaction with the same amm pool setup before yours your transaction can no longer be valid for example or there are a lot of other cases where in which ordering is very important and then the final property is uh or sorry functionality is data availability which is the process of making data accessible to any interested party for pred some for some predetermined amount of time so let's say a month or 10 days or whatever it depends on the protocol and when I say data specifically I mean data that is sufficient to reconstruct the state of the protocol so that can either be

transaction data compress transaction data or state diffs and all of them allow you to reconstruct the state and so celasa defines a modular protocol as a one that in at most enshrines three out of the four affir functionalities so let's say execution uh data availability and ordering and settlement go somewhere else for example or something else and then as opposed to that a monolitic protocol is the one that enshrines all of the affir affir functionalities so makes sense right right well it's not that easy celes already has minimum viable execution so

because Celestia needs to track the balances of the Tia token and the stakes and and the staking process of Tia token it has this minimum viable execution that requires that basically is needed to track those Balance and celest is already considering enshrining zero knowledge proof therefore far into the core protocol which means that they will be able to Val enforce validity and therefore allow settlement on celesa directly and so now celesa has the following functionalities once uh the zero knowledge Pro verifier is adopted it's execution validity ordering and data availability confused

I bet yeah I guess I am confused personally so and I saying I put out a tweet saying um salana isn't ethereum's biggest competitor it's Celestia I'm not sure they're trying to push that narrative themselves because you know mon theorum alignment but um it's it's really interesting that you bring this up well we'll see I have a point about that later so is Celestial model litic has Nick lied to us we'll have to ask him and then so the answer is no and the reason why C is

still modular is because as I said before I would need to expand on the definition of modularity as long as the vast majority of the execution is outsourced so what I mean by vast majority is like most of the user generated transactions are outsourced modular protocol can retain some capability to do minimum viable execution for example in Celesta that would be to track the balances of e sorry of Tia and then the staking and everything else related to Tia in ethereum that would be that plus facilitating communication between different LTS Etc and so but as you can see the lines are blurring and let's go step further

and blur them even more so what if we modularize ordering into ordering proposal and ordering consensus by proposal I mean block construction and by consensus I mean what I defined before as ordering reaching an agreement on a certain number on a certain sequence of transactions and in for example in ethereum most of the validators already do that they Outsource block construction to some specialized Builders and then they just propose the block reach the consensus meaning that the block construction the ordering itself is done by other entities and then uh the full nodes in the network the validators actually just reach agreement on the work that was done by external

parties which are Builders which means that you essentially modularize ordering into two parts uh the building and the agreement on the sequence that was built and so L of validators can do that and what what if they do that what now is salana modular all of a sudden has Kyle lied to us I don't know I mean again same question as before the lines keep blurring and the answer is no even though I'm not really sure if the answer should be no but but for now let's assume that it's no it's a no and by the way uh Kyle hasn't lied to us but only on this specific clim usually he

does lie so do modular protocols better scale better than modic protocols well yes and no so a lot of people think of it this way because you Outsource certain uh certain properties and certain functionalities to other networks or third parties you might think that actually the core becomes lightweight but if you think about it from the overall construction it's not that simple and so like for example one benefit of modularity is then you can make uh the core protocol so let's say in this case theorem for

example very accessible in terms of the hardware requirements that you need to run the full node which means that a lot of people can verify the chain themselves without relying on infer or any other RPC provider or like all the broken light clients that currently have but then we also introduce additional overheads both in the protocol and the application Level so for example on the protocol level you would have to run two mols you would have to have dedicated Searchers for l2s etc etc and on the application layer for example if Unis swop wants to support all the major l2s and assume that there's a world where there are five or 10 l2s that are equally as popular as one another and Unis swop or any other

application would like to support all of them so now they have to have this additional overhead of making sure that they're they're up to dat and every is fine on every single protocol and keeping track of the security updates etc etc so there's some to a certain degree significant overhead that is introduced and so from one perspective yes you make it more scalable from the perspective of you keep the core very light but and then Outsource a lot of heavy work to third party protocols without losing a lot of trust assumptions that you have within the core protocol but then on uh the downside of it is that you introduce additional overheads on a few different

layers and so I I think the Future Would it looks more like modular chains will it will just enshrine more features and modic chains will modelize more features as I said before and so the paths are somewhat converging and at the end of the day with sufficient abstractions the two will be indistinguishable to the majority of users which means that from the perspective of a user who doesn't care about full noes Etc they most of the problems can be solved on the you Slayer and then everything else is kind of hidden behind and the only people who would really care about it are devs and very technical users I don't think I I would expect my friends

or my parents to care about that stuff yeah that's that's it to my short presentation that was so much fun I think I think one thing to consider is that the the definition and tol since you're a definitions guy like I figured frame it in this way like the definition of Monolithic is so strong and the definition of modular is so loose that the modular guys are in a position where if anything is modularized whether it's it's just some something as as niche as uh ordering and like proposer and Builder separation for instance in in uh ordering of salana transactions all of a sudden you called the entire salana thing modular because that modular

definition is so is so broad that anything modular in the entire stack now makes that chain that entire chain modular so like yeah it's just something worth pointing out I think yeah I agree I I think I think monolithic is more of a binary concept you are either monolithic or non monolithic it's just the question of where you set that line of when you become modular or you when you still monolithic whereas modular is a scale basically you can be completely modular and separate every single aspect of the protocol into different components and different protocols or just have one thing separated like for example in

ethereum you only ex separate the majority of the execution and then everything else is still ensin but you're still modular so I and that's the reason why I think a lot of the definitions that we currently have are more more of memes rather than actual definitions because it's like so difficult to Define what is a monolithic chain or what is a modular chain does that make ethereum modular uh by the definition of like separating most of the execution off to rollups and I would say so I would say that ethereum by my personal definition again celesy people will definely disagree with that ethereum is to a

certain degree modular is it sufficiently modular enough where you can actually consider it modular I don't know will we ever get to a point where no apps are running on ethereum and everybody just uses l2s maybe I'm not sure there might be certain use cases that will require l1s for example and that will disqualify ethereum but in general I think I think you can make the definition loose enough where ethereum becomes modular yeah could you go back to the slide where you um showed the definition of the three of four um Parts I think it was of the beginning um because this was a this was an a a definition that I'm not I haven't

heard before but I'm not sure yeah okay so modular protocols at most enshrine three of the four functionalities and that's that's what makes uh project or a blockchain modular is this your definition or is this from the Celestia docs so it doesn't directly say that but based on all the documentation that they have they separate the scale they have this table where they have the four functionalities and then they show that ethereum has these functionalities ens Shrine and these functionalities are not and shin etc etc and based on that I basically derived the definition but I would say if you ask the majority of people and like

present those functionalities I think the majority of people who work in this space will agree that if you can at most enshrine three out of four functionalities to be considered modular and I I think I think like where we got to was like What if you have three and a half out of four are you still modular yeah exactly that's what I'm saying so even Celestia has minimum viable execution even though they like to say that they Out Source execution there's still some execution being done by Celestia and so once they introduce the zero knowledge proof is it actually modular that would be funny if like the pioneer of the term stops being modular and becomes a monolithic chain so let's

talk about that is is is Celestia more of a potential competitor to ethereum than salana if they implement this this ZK uh this ZK verifier and you could you explain like what Celestia's current like vision is when it comes to ZK like how are they going to incorporate ZK verifiers into their stack so and there have been discussions about that for quite a while at least I've been hearing about them in private cirles about like if you can enshrine the pro the verifier directly into the protocol so essentially you would have a let's let's use ethereum terms and up code that would verify a snark for

example let's call it verify snark or whatever and then that will allow you to basically have trust minimized Bridges because right now there's no way you can have a trust minimized two-way bridge on it on Celestia you can go from celesa to a roll up in a trust minimized way but you cannot come back so you need some form of a verifier to do that what is trust minimized mean in this context so trust minimize again there's no concrete definition as with everything else it's another meme but I personally Define trust minimize as a protocol that doesn't require an honest majority assumption so basically which uses a one out of n or a weaker assumption so that would be

either fra proofs which require a one out of n where n is unbounded or zero knowledge proofs which don't require honesty assumptions at all it just make like math correctness ass mathematical correctness assumptions got it okay so like unconditional potentially in in terms of honest actors on the system yeah yeah basically the weakest possible assumption you can have in terms of honesty and and that's possible uh in a one directional Bridge from Celestia to some rollup but it's not possible to go from a rollup back to Celestia in that uh in that very like weak assumption uh where there's so many dishonest actors uh it's not possible to go from a rollup

back to Celestia and that trust minimize way no you you you can't so so what you can do for example in Celestia so you can have a trust minimized bridge between two different rollups on Celestia but you canot go back and forth from Celestia itself so for example if you're using a TIA token for example and you want to Bud it to a roll up and back to celesti a trust minimize way there's no way to do it currently unless there's ZK and that's the that's the um that that's why they might enshrine the the ZK verifier into the protocol

yeah okay and my is this fundamentally different from like the light clients that are verifying the data availability via data availability sampling is is that what you're talking about enshrining into the protocol or is that a different form of verification that happens on the system so I'm not sure if the live clients would do the verification of the of the proofs because currently they don't do verification of execution as far as I know they only verify that dat availability and the header correctness so I would assume that at least the full noes would be doing that I'm not sure if they would add that to a light client or not yeah so is something then and I'm going to keep coming back to this

competitor question but is something like a veil which has like these kzg commitments and has ZK already like baked in from you know theoretically on mainnet that's that's more of a monolithic chain than than like Celestia is pretty ZK I I'm I actually don't know if a veil allows you to verify ZK on chain so I'm not sure where ZK comes in theirs but if they did let's assume that they do for now I would say they are but like I would also say that all of the chains to a certain degree are competing with one another even if they're not right now and they're targeting different things I think long term the paths are converging

it's just a question of how you achieve it do you achieve the modular way like the way ethereum is trying to do it or do you take the salana approach and like put everything into one protocol yeah so people when I when I put this tweet out about Celestia being the biggest competitor people were asking me like oh is it about cheap da I like yes it's about cheap da in the sense that like ethereum is going down this da Focus road map or this data availability Focus road map um but it's really about this validity and this ZK kind of settlement angle where if I'm going to use you know Celestia or other da provider um for for my data availability and then there's also some sort of

consensus baked in using ZK uh verifiers then the question becomes like like I'm a rollup but I'm no longer like an roll up I'm just a roll up on Celestia or roll up on this data availability and consensus layer um and I have my execution on my maybe I use evm still or maybe I use a different virtual machine yeah so I I I think I think people when people see Celestia as an ethereum competitor from the perspective of Da that I I don't see celesti as a direct competitor because no rollup building on a ethereum is going to choose Celestia

over ethereum for da if ethereum had enough capacity the only reason why people are doing it is because ethereum just doesn't have enough capacity and so let's say in a theoretical world where ethereum has un limited capacity the celesti is not necessary necessary for for this particular thing but once celesti integrates ZK I think you can start seeing Celestia as more of a competitor for ethereum in terms of like an L1 that is primarily f a role of the Centric L1 let's let's call it that because now you have as a developer you have a question do I build on top of ethereum or do I build on on top of Celestia

because you can offer the same or mostly the same features celesa will still have a bit of a limited functionality in terms of like you canot have tokens on L1 at least for now etc etc but like other than that you're functionality is essentially identical so now your question becomes do I build on Celestia or do I build on ethereum and now you can see that Celestia all of a sudden becomes a direct comp to etherum yeah and so scroll is pretty ethereum align we haven't talked too much about scroll yet so I'd like to talk a bit about scroll um obviously you are um you know scroll scroll's Vibe SC scroll's brand is you know a type one zkm fully evm compatible uh very

ethereum aligned vibe ethos and everything um so maybe this is a silly question but is scroll modular like is a ZK evm rollup is that a modular is that a modular component of the ethereum stack and um kind of following up with that is like are we going to see a world where general purpose l2s like scroll um and others in the ZK space follow like the the cdk op stack ARB orbit model to then like go even more modular and scale your L2 in a more like specialized and modularized fashion so kind of two questions there maybe they go hand in hand yeah I I actually don't like the ter ethereum Aline they think it doesn't

really Define anything it's like is the most ethereum align person the person who shouts the Lou loudest on Twitter or like how do you define ethereum alignment uh I I I think you if you look from the perspective of use they're always going to be modular because they're Outsource at least some of their core security to the L1 so for example minimum minimum you'll always Outsource some da the da guarantees to the L1 so you can see how uh from the perspective of of an LT you'll always remain modular as long as you don't spin out and become a separate L1 for example the way dydx did

it then you know you're no longer modular but in the context of being an LT you're always going to be modular so question of modularity being a meme is more from the perspective of an L1 and then in terms of uh I I think I think the reason why we're building on ethereum is because one the entire team has been following ethereum's progress and like has been inspired by ethereum in why one way or another E was the first protocol that I ever used and funny know I I got into crypto from through ethereum and I'm probably one of the few people in this industry who almost never

used Bitcoin I think I touched Bitcoin twice in my life and even then it was because somebody had to pay me in Bitcoin and so uh and we wanted to help ethereum scale and it was always like our core ideology that we think that evm is the best way to go about things purely because of the of Network effects that it has like I always like to bring up this examples for example if you if you are an a programmer from a traditional background we've never heard about blockchains before you hear about smart contracts for the first time and you think they're cool if you Google programming smart contracts the first thousand 2,000 results were are all going to be

solidity or evm and so it while you have svm and you have move which both are are great VMS and in certain cases they're even better than evm the Gap in terms of like the resources that are out there is massive and there's also a question of even if you ignore the resources Parts how many people can audit uh salana rust code for example and how many people can audit a solidity code that is written for ethereum like again the Gap is enormous there and that's why we think that the best way to reach Mass adoption is to work on

scaling evm rather than moving and trying to reinvent the whe which I again I'm not I'm not saying that from the perspective of I don't want anybody else to do other things I think what's svm and move VM achieved and also CYO VM achieve is very important and like we've learned a lot from all of them but at the same time we just don't think it's the right approach for us gotta um you brought up a good point uh that I'm going to double click on because I saw this tweet from Chia Wang today you may have seen it I'm just gonna read it he he tweets that he sees no reason why leading l2s wouldn't eventually become

l1s quite funny compared you with your convergence thesis at the end of your talk or at the end of your slides why l2s wouldn't eventually become l1s they'd be valued by the market at an order of magnitude High and they realized what i' realized by being in the trenches that D Builders are pragmatic and couldn't care less about ethereum alignment um soone just gonna stop there and maybe just like your initial thoughts I don't think the reason why Builders build on l2s is because of alignment it's more because it's the easiest way to tap into secure liquidity and I know a lot of people are going to say that rups are still multix but eventually they won't be multisig based

and so they're going to have this trust minimized bridge that you cannot have any other way with ethereum and ethereum at least for the foreseeable future is going to be a liquidity Hub you you can see like salana making strides etc etc but in terms of how much money is on chain it's not even it's not even comparable to how much money it is on ethereum and also again you want to access the community and the tooling and everything else that comes with that vast liquidity and so I think for a lot of people for a lot of devs building choosing to build on top of an L2 versus to build on an L1 it's more of a numbers game in terms of like do we want to maximize the amount of liquidity that we

would like to access and so the best way to do that is to build on an L2 yeah okay so then let's put it this way let's say instead of going to an L1 you're users of ZK rollups and and and I know ZK magic is going to take care of these problems over time but users of ZK Roll-Ups currently pay a bit higher gas fees than on optimistic rollups obviously like pre-confirmation and then full confirmations anding times are still a little bit are are slower than like basically these like Fast pre- confirmations on optimistic rollups but to solve this you're given a proposition okay Scrolls dkbm can continue to use ethereum for da and use blobs and have

higher transaction fees or scroll can use Celestia for da and and give that their users a much better experience uh and much cheaper fees like what goes through your mind when you're presented with this like type of trade-off question about you know ethereum alignment or user experience or or you know decentralization kind of like like like how would you think about this I I think the reason why we didn't choose to build on an Alda solution is primarily because we want to minimize third party dependencies as much as possible and that's one of the reasons why I'm for example against using shared sequencers for rollups because it just

creates third party dependencies that the your protocol is to a certain degree dependent on so for example what happens if celasa disappears tomorrow or or any other da layer that we're using now okay like long term there's not going to be a drastic effect but short term you would basically have to have to Hal and re-engineer your entire base to work with ethereum or any other da layer and so I just don't see a reason why we would want to introduce that risk to the protocol I think this for certain use cases that's fine I think if you're building a game or something that doesn't really have value in a sense that monetary value it still has value

but it's it's it it's not as quantifiable as let's say like having usdt tokens or your eth locked in in a bridge and I think for those applications absolutely fine to use third party dependencies because even if something goes wrong you don't have hundreds of millions or potentially billions of dollars at risk of user funds whereas if you're building a general purpose roll up I think your primary focus is should be to maximize security and minimize dependencies even if the costs are not equivalent we take this risk but I think over time the the difference is going to

become negligible obviously 4844 is not going to be the solution to that but it's the first step towards getting us to a point where we can say that oh yeah you might pay a bit less for cesa but it's a difference of like0 .01 cents versus let's say 0.005 cents if if I was to play a devil's advocate here it's that the third party dependencies are what make a chain modular and Outsourcing that is what potentially increases scale so when you think about about the convergence of modular and

monolithic what what do they converge to because when when you first said that my my initial imp was that they would converge to this to the point of Maximum scalability but there's tradeoffs and you're like you're saying the point of Maximum scalability might come with third party dependencies because you're Outsourcing functionality to third parties and as a result you lose some security benefits so if you could kind of like consolidate like this convergence Point how would you how would you uh Define like this this convergence this like the point that converge to I I I think different Protocols are going to make different tradeoffs and

Outsource different things it all depends on your risk profile and how you see things because for example I bet if you bring in 10 other people who work on rollups or other modular protocols we all will disagree on what we think is sufficiently secure versus too risky and so I I think I think from the perspective of ethereum I think long term you would see this convergence in a sense that you would have the L1 primarily doing da plus enforcing validity plus uh ensuring that you can facilitate communication between different l2s and l2s taking the brunt

of the execution and so I think I think that's how it's going to play out long term I think again for certain use cases you would still use external Das and that's absolutely fine for certain use cases but in general if we're talking purely from the perspective of general purpose rollups I think it's inevitable that they're going to try and minimize as as many like it minimize the number of dependencies as much as possible when when it comes to uh like trust minimized Bridges um and minimizing dependencies on third parties you also mentioned like minimizing dependencies on something like a shared sequencer that may come with

interoperability benefits but may reduce uh like security um what what's the current Bridge landscape for l2s and general purpose rollups like what is the bridge setup that that scroll uses and is is that trust minimized I I don't think aside again the classic except for few version one I don't I I don't think you can say that any rollup has a trust minimized Bridge purely because we still have a multi that can upgrade the bridge and while I I I I personally consider that safe from my perspective but that's

because I work at at this team so I know like this the security precautions and everything I don't think you you can classify it as a trust minimizer a lot of people will not see it as like sufficiently secure to park millions or potentially billions dollars and we're taking steps to get there and I think all the other teams are also working on it there are certain things that you can do in order to to basically push the uh to minimize the trust assumptions as much as possible so for example we introduced uh two Factor authentication that's what Justin Drake call it is good which is a multi-prover basically it's

an sgx prover that runs in parallel with r z knowledge Pro zero knowledge Prov and basically the we we only process withdrawals if both of them agree on the same state and so if one of them attach to to a different state than the other we pause the bridge and then we let the security Council in this Cas currently we ourselves but long term is going to be the security Council it's going to take care of that and so this is the first step towards what I predict would be the way where you can remove a multisig I think removing a multi and introducing like delayed upgrade ability we require

taking three steps one is uh having multie two is what I call having what I call is multi verifiers which is basically uh you instead of having one instance of the bridge running on ethereum you implement two different versions one in let's say solidity and one in Viper and then you only process the withdrawals if both of them agree on the same state rights and basically that eliminates accidental bugs inside the smart contract Because unless there's a scenario in which both of the compilers have the same bug which resulted in the same uh invalid State transition it's highly unlikely that

you'll ever get a bug that resulted from an implementation that will cause the Pro up to fail and then the third step because having a multi-prover and a multi verifier eliminates the implementation of bugs but it doesn't really solve the problem of what if the specification of the protocol is invalid what if you made a bug when making the formal specification and that's where formal verification comes in again that doesn't fully guarantee that everything is going to work out without any issues but you it's a way to minimize the probability that you actually have a actually have a vulnerability inside the protocol

specifications and basically if you combine all those three I think that's sufficient for us to remove the multisig and basically have delayed upgrades that either take like a few weeks or a few months to enact because basically the the the probability of us get getting finding a bug that will result in funds being drained would be zero in this case that or not zero but like negligible yeah yeah that just to hone in on that one part about multi verifier uh that that piece that like you know we were talking about Celestia enshrining the ZK verifier into

their protocol which would then give them only like a single verifier that the entire protocol uses so yeah at the at the time there's actually a lawn mower going outside which is I didn't ask the question but I the general ZK question I had is like why like is there any value in verifier redundancy and having multiple verifiers running on the protocol to to help like verify the verif the verifications yes but it depends on the specifics so for example in Celesta because they're in shining ZK you can make an argument that like if something is wrong with the ZK then essentially you can just uh in with the verifier you can just like

stop the chain and roll back because the entire chain becomes invalid you can't really do it on ethereum right now because it's the verifiers are not in shined so every chain H every rollup has a different verifier implementation Etc and the reason why I think it would be difficult for ethereum to actually implement the verifier is primarily because one there's a diverse set of verifiers and two there's diverse set of of uh programs that we're approving on those verifiers and so essentially how do you even converge that into one big program and one big verifier that that you you accept as a general purpose verifier to work with

everyone to work with all the rups it's a good question I don't know I I don't know I I I I don't think anybody knows and I think I think that's difficulty so etherum can choose to enshrine for example one verifier for a specific zvm or something like that but they cannot ver and shine every single verifier because that that will mean that when now people complain that upgrades to take too long like half a year or a year that mean that upgrades take five years or like something ridiculous so I don't I don't think I don't think any of us would want that to happen yeah

um I guess I just have one more question which is on like the bridge side of things like is the reason that scroll has like a quadrillion eth in its like block Explorer because it has this multisig set up no it has nothing to do with with with the multi it's just the way the L2 was designed and the way the way we designed the the L1 to L2 messaging we kind of had to do it because you you can either do it through a mint and burn or just basically uh do do it in a few other ways and we basically made a decision that this was the most straightforward and the most secure way of doing things but I know

it's it looks scary when people go to that smart corn check and see I know I think it was like five trillion e or something like that it's like more it's more eth than like is in the circulating Supply so it's just funny it's a funny number to see so the reason why it's this large is because we just like protected ourselves in case everyone goes insane and let's let's say says oh yeah we'll just multiply all the e in in circulation by 1,000 or something ridiculous like that or say like we're gonna Mint one children e every year via blocker rewards so the reason why we made it this high is so that there's no chance that

the supply will ever exceed that much is is it not an upgradeable contract where you can me like more on that contract if the eth supply system suddenly changes technically we could but that would result in US basically making uh changes that might lead to some compatibility issues ETC so we would like to minimize the amount of changes we make as much as possible but but but yeah I I I think again I I I think eventually it's it's a ux problem because unless you look at that smart contract you'll never know that that's yeah that actually is a thing and so I I

think we'll just eventually work with the block Explorer is to ensure that they don't display that number because doesn't really matter I guess just there in the back end and so that eth that that large amount of eth is just locked in that smart contract until and then when someone Bridges to scroll that smart contract releases some of that eth yeah yeah okay so you can either do that or mint every time you you you and basically burn a mint or like not burn a mint you would lock on ethereum side and then mint on scroll side but but yeah but there are certain things that basically would have made the

implementation a bit more difficult and so the decision made was made to just do this okay I know someone made a tweet I think it was D from e made a tweet that vitalic bridged all his eth to scroll and people actually took it seriously thinking that vitalic had that that much eth in his wallet and people were like oh yeah congrats viic is supporting you guys like no I wish that's we have on chain yeah def llama would have another thing coming yeah I I don't want to make their life even more difficult it's so

difficult asses with the number of chains and with the number of protocols that they have to support yeah yeah definitely well T thank you for for coming on to maju March and sharing a very interesting refreshing presentation and conversation um it's been a pleasure to have you and um really excited to uh continue to see Scrolls growth and also the interesting topics that we touched on today and just keep close tabs on the evolution of this convergence of these different architectures kind of uh converging into a similar point so again thank you man thanks for having me