Containers - cloud computing for blockchains

Transcript

foreign thanks everyone for coming to this particular talk okay great that you're able to see things um I know that there are quite a lot of things happening on ECC so glad that that you're able to to visit this talk I would like to make it somewhat useful to you and I would like to talk a little bit about container Solutions and general l2s and the direction that ethereum is going at the moment some concerns around it and you know maybe you will be able to get some insights about the developments so

for everyone obviously raise the hands the ones who heard anything about l2s so everybody do you actually know what an L2 is any ideas and just shout out thank you okay okay nobody knows what L2 is right but like just put it in simple right um is that this is a solution that is meant to help up with the scalability problem of ethereum blockchain right and the idea behind it is that you know for already multiple years ethereum blockchain is fully clocked right the blocks are fully uh they're fully utilized right and we need a little bit more space so the idea was that okay

let's let's deposit some funds in the contract that is kinda like a bridge right execute some transactions over these funds over this value outside of the chain and then from time to time settle these uh these transactions on on the Chain um updating literally the balances in between in between the accounts that are working on this solution and this is what is uh what is called a roll up right now there are multiple problems that are there at the moment with this solution right and these problems are around ordering these transactions and settlement of this batch transactions now ordering is

performed on a single machine at the moment people are usually referring to it as sequencer and settlement is happening using another machine or sometimes it's the same machine that is usually referred to as a validator right so and these things are centralized at the moment right this is one of the problems and this is you know some people are talking about the decentralization of sequencers right now the idea behind this this approach was why we took a centralized approach and the idea behind that was that well let's let's put one let's take one step at a time right it is a complicated problem how to solve the decentralization of sequencers so let's

let's have some kind of solution right now and then evolve from there now if we will take a look at at what L2 bit is saying to us and in general we will take a look inside of the applications or these different Frameworks for l2s what we're going to see is that many of the sequencers are actually kind of many of the solutions are actually not yet addressing the problems of the decentralization of the infrastructure right and the the way how they are addressing this in in the cases when these issues are addressed is these approaches they take quite a lot of time right what happens in case a

sequencer failed or is censoring the transactions well for some solutions there is a way how you are able to push your transaction on ethereum layer one however in order for this transaction to get executed it takes a week or something like that and that's the answer at the moment right in some cases it actually takes even much longer time right and the question is is it actually okay to wait a week for the execution of your transaction and well from my personal opinion it's not quite okay just because of a simple setup you can take a look at these two graphs that are available here so Luna

crashed from 19 to almost zero in less than a week usdc most recently depacked and repacked in three days right so it is also very important to have practicality in the question of the settlement and the question of the security right because what l2s are claiming is that they are as secure as as layer one blockchain and you are able to do everything that you are able to do on the L1 blockchain right but the practicality of the solution actually says that well actually no you are not able to do this this problem is is splitting is introducing as split inside of the ethereum ecosystem at the moment Frankly Speaking I would

not say that arbitrum optimism wherever Roll Up is there is a part of the ethereum ecosystem just because of this simple issue liquidity in in order for it to be moved it requires at least hours or like some some substantial time even in the in the good scenario but in case we're getting some catastrophic events like these it is going to be much worse so and besides that there is also an additional problem right so these are the existing Solutions and an existing problem right but besides that there is an additional problem

and this problem is the synchronous execution of the evm and the idea behind the synchronous execution this idea has been heavily utilized in the existing applications that are running on evm right so what am I talking about here so imagine a simple uni swap right there is a some kind of pool of two tokens they are available there there are some quantities in of these tokens in the pool based on this quantities uni swap gives you an opportunity to exchange one token to another and the price of the exchange is determined by the quantities of the stock in Center pool once a user executes a trade then the quantities now

are different the price is a little bit different and now the next user can come in and here is the pitfall right two users are not able to execute transactions in parallel well just because the prices are going to be different you you you might be double spending some things absolutely the same way user is not able to send funds to two people because in case I have only one ether and I'm sending to Alice and Bob this one ether these transactions must be done sequentially because the first transaction will be executed and the second must be dropped or must be failed so so these things are fundamental limitations right and if

we're talking about users and maybe that's not a big problem because there are tons of people who are transacting and then sent in ether one to another that's why Canada you they are they are asking for the data about the amounts of ether from different accounts but from but in case we're talking about uni Swap and core D5 Primitives while they are not a lot of them and you know every like 20 percent of transactions on ethereum are the unit swap transactions and just the way how or the transactions that are touch in uniswap right and the way how we just constructed all of these things it's just fundamentally impossible to parallelize fundamentally impossible to scale

and uh and and the only thing that we are able to do with this is just bear right this absolute l2s at the moment are not solvent this problem we're going to hit the ball with any L2 absolutely the same way how we're hitting the wall with ethereum so so I'm claiming that no single L2 is a solution to um to a problem right however the solution is many l2s right in case one L2 is limited what you can do is well you just launch many l2s but then the question is how you can interoperate in

between the cell tools and at the moment again they are separated you know the transaction execution and settlement time is pretty pretty slow and and that's the problem right so I'm proposing you to imagine a Wonderland when things are designed a little bit differently and and just see the benefit of the ability when we are coming from a standpoint of the yeah we need to solve the problem of launching many EVMS and then we need to solve the problem of the decentralization of the infrastructure and also kind of given a give an opportunity to for this Altus to interoperate with each other so here we go here is the design that potentially solves this right so imagine a truly

scalable L1 solution which is uh which is asynchronous solution it has something some kind of different properties smart contracts in between this solution in between inside of the solution are calling each other in an asynchronous Manner and because of this they can be executed in parallel right obviously it cannot be evm based right because evm is synchronous right then imagine on top of this solution a smart contract that implements evm that's a pretty complicated thing you know a dream and a dream but it is absolutely possible to put an evm inside of a smart contract so when the user is sending transaction to this evm well the transaction every single transaction is

settled on this L1 but just because it can be parallelized because of the asynchronicity well it can withstand the load so this will be a validator of this solution right and or like a container right now if we are able to see also if we are able to introduce inside of this evm inside of this container an ability to call other smart contracts and others containers well then this will be an interoperability layer right or or an L3 or a universal bridge in between distance the cool thing about it is that well it is not a bridge which means that it's not going to be hacked and SEC because

it's just the cross-contract calling on this layer one solution um and it will give an opportunity for Builders to build very complicated actually cross-chain applications so in case there is a swap that is happening then the liquidity is split in between different containers or different l2s in the same transaction and then small swaps are executed on every of the l2s and then the liquidity is gather back back together this is all possible with this setup the thing is that it's not quite a Wonderland this thing exists already for for some time so the truly scalable L1 is is a near protocol uh it is sharded it can be it can work in parallel

the client that I that I missed the second point the like client of this protocol is working on on ethereum it is called one of it's one of the pieces of the Rainbow Bridge right so so data availability and state transition correctness can be done through the slide client then there is a contract on top of it and this is this is the project that I'm working for and this this is called Aurora right there is an evm that is implemented as a smart contract on top of it and you're able to take it Fork it launch it and here you go this is your own L2 solution that is there and we also developed a thing that is called the cross contract called SDK which which enables the the calls in between these these cems uh though we have built this stuff I

would like to point out from this this particular talk that please make sure that if if I want you to go with some with one thought after this talk away I would say that please remember that there are still quite a lot of things that l2s need to solve and there are different path that you are able to address this currently ltus are focused on the security however they need to think about scalability and interoperability in between the deployments and these particular two questions are solved in our solution so if you're curious to take a look at this you are able to go to Aurora cloud.dev and yeah that's it thank you very much for your attention [Applause] okay guys we have two or three minutes

for questions so if anybody wants to ask okay that will be it we'll have a small break or we we're gonna have a streaming here right okay okay thanks everyone uh by the way there is a Aurora booth and I'm going to be around so if you want a private conversation you always can do it