L10 - Decentralising Infrastructure through EigenLayer | by Yash | BlocSoc Lecture Series

Transcript

all right so hello everyone uh today's lecture is basically going to be about ier and how ier works and the reason you're talking about this in this rollup infrastructure lecture is that a lot of rollup uh components are currently centralized and that is a huge issue and I think there is basically a breing protocol that can help us solve some of those issues uh so let's look at how that can be possible so uh first let's talk about what type of components rollups have and uh I think by this point in the lecture series you might have already developed an understanding of what are the different moving parts of a rollup so there are definitely sequences that take the transactions

bash them and submit them to either aover which is again a centralized component or directly to L1 and then uh what happen there are also these things called Rel layers and bridges that I think you might have studied in another lecture uh these basically are also centralized components that convey messages between layers to make them interop level so what exactly is the problem with centralized infrastructure so there are basically two major downsides one of them is sensorship so imagine that you submit a transaction to a sequencer and the sequencer does not include a transaction in a batch so in case of rollups you can actually buy

bypass the sequencer direct like directly and submit the transaction onto the layer one but that definitely requires you to spend a lot of gas and you should not be able to do you should not have to do that right because the in point of a rollup is for you to seamlessly submit transactions with as little gas as possible right so if a sequencer is malicious if it's trying to sensor your transaction then uh then you you have an option to include it but still it is uh inconvenient to use and another thing is definitely downt like what if the infrastructure itself stops working it's faulty or any other problem in its deployment occurred right so that way the entire chain can halt which I

think did happen with arbitrum as well I'm not sure if the downtime was because of a sequencer or something else but I recently heard that arbm chain was down for a while so these are a few problems that happen with centralized infrastructures which should not happen on blockchains like you have you might have never heard that ethereum has suffered a downtime unlike a chain like Solana so so basically each rollup has a road map to decentralize its infrastructures so how does it happen how do you decentralize centralized component and the answer to that is simply proos and I hope that you understand what Pro proos is by now but

let's briefly go through it again so you have basically a bunch of node that perform operations and there is a fixed algorithm by which they have to perform a transaction for example in a sequencer you take the transactions and after a certain time you badge them and submit them onto the canonical chain that is your algorithm for a sequencer uh and uh and The Operators all the operators in this network have to obey that algorithm there are stakers that basically stake assets and then delegate task to noes so basically what you have to do is that these nodes must have an incentive not to cheat right so they are asked to put some Capital down uh as basically collateral and often times uh

what happens is that these operators they for doing this task they get rewards on their on their stake right because like then why would they do it if they don't get rewards so they get rewards and people want to get in on get in on these rewards but they'll also have to perform task for that and not everyone wants to do that so that's why this Shaker delegator concept also came along where there is a group of stakers which Provide Capital which provide Economic Security for a network and they delegate their tasks to be done by node or to be done by an operator and if the operator performs a malicious task then the stake is actually flash so so yeah there there there is some trust

assumptions that if you a Staker and you're delegating to an operator then you must trust that the operator is not going to perform a malicious staff and there are there is a lot of research going on uh to mitigate this trust and properly handle the economics of this take a delegator model uh but like in an ideal scenario the node themselves would provide Capital so their own Capital if their own capital is SL they have a very good incentive not to behave maliciously and uh so before going into I there I want to briefly touch about a topic called token toxicity and why like how is it different from slashing so there is an argument that a few people would like to make that uh you don't need

slashing in a proof of State Network to have Economic Security uh and the logic behind that is basically that if you are taking some tokens into a network then it's not some random token it's the token of that network if you realize that ethereum allows you to stake e if you are a node on file coin then you have to stake fil tokens and uh and so on like each proof of stake Network like chain link you have to stake link tokens right so the asset that you're taking is of that Network right so if something malicious happens to that Network like if a if on

ethereum let's say an invalid block is finalized then that is a very huge deal because the entire point of a blockchain the entire point of a decentralized network is to have permissionless but verifiable and immutable data and if there is anything wrong with that if there is anything wrong with this with this basically Pro proposition then uh then what is the point of the network the value of the network the reputation of the network will fall drastically and along with that the token price of the network will also fall drastically so uh that is the concept of token toxicity that if you're a node and you have you you have some stake in the

network then if you do something malicious then your stake will decrease in value because the entire network is has decreased in value so you will not have uh you will basically not have a incentive to do something wrong but plenty of people point point out that that is not a right way to think about it and the answer to that is simply prisoners dma so if you have so here is an example in front of your screen so let's look at the first table right and this is the table where slashing does not occur and it it's a network that basically works on token toxicity so imagine that you're a node and you as a node have been given a dilemma that uh someone is someone has come to you and

is asking you to behave maliciously right and obviously they'll have to give you some bribe uh for you to uh act in not not in the best interest of the network so let's say that you're given a bribe B1 in case the attack is not successful and you're given a bribe B2 in case the attack is successful okay uh so now you'll have to V your basically chances of what's going to happen you have a stake s right and uh you have a stake is uh and on that stake you're getting a reward so in case you do not take the bribe and the attack is not successful then nothing happens to you

you have your stake and for doing the task you got a reward so in that case you have basically s+r Assets in case the attack is successful then you basically do not get a reward because then a malicious transaction has happened and you are not part of that so you don't get a reward so you're still left with s um with basically with basically s uh with basically EST right now let's say that the node did agree to take a bribe oh oh sorry I think I flipped the table so yeah the token toxicity situation is the one in the bottom table so what

happens is that uh uh basically you have a stake and you have a reward right and if you if the attack is indeed successful then the then you are lost right because an attack was happened and you were not part of it so you you lose everything so you basically get zero if the attack is successful and you did not take a bribe now in case that you do take a bribe and the attack is not successful then you still get the bribe B1 because that was promised to you but your stake is not taken away from you so you still have assets S Plus One S Plus P1 and in case the attack is successful then you have then you get the bribe B2 right so in this case is B2 must be

greater than zero and B1 must be greater than R for you to be incentivized to actually do this attack so now this is not a bad condition to have right like if you if you're bribing someone then you have to bribe B2 that must be greater than zero and you have to bribe B1 that must be greater than R these are not huge amounts right and this is it could be possible for you to actually have this capital and actually convey a third of a network to behave maliciously so that's not a good argument for token toxicity in terms of slashing as you can see that if you agree to take a bribe your stake s will be slashed so in case

the attack is not successful you get B1 and if the in case the attack is successful you get B2 so in this case if you are the briber and you have to provide B1 and B2 values your B1 must be greater than the stake plus the reward and the B2 must be greater than the stake itself and the stake is not a small amount the stake is like for ethereum the stake is 32 each so yeah 32 each is not a small amount right so you basically so if you're the briber in the case where slashing does occur you have to brive a B2 that is more than the amount of St 32 e and if you uh and you cannot just brive one single node because then your attack will not be successful in order for your attack to be successful you have to bribe more

than a third of the network so in ethereum the total St amount is100 billion doar so if you want to attack a third of the network then you'll have to basically you need to have a capital of around 3540 billion and that is a huge sum of money that we assume that no one is going to spend that much money to attack ethereum because even if they do attack e ethereum everyone else would know that okay this is a malicious transaction and they can just fog the blockchain because blockchains have been foged in the past for far less value far lesser amounts right so that is basically an argument of why something like toen toxicity is not sufficiently

uh is not providing sufficient Economic Security in in comparison to slashing so now let's actually jump into I and understand what it does a so I basically introduce the concept of reaking so we all know that ethereum is based on this proof of mechanism where nodes on malicious transactions will be slashed right uh and they'll take some amount so what end does is that it allows these validators that already have an amount stake to uh use their stake to reuse the stake basically to secure other networks as well so let's say that uh you want to secure ethereum and filecoin you have to

provide 32 we on ethereum and you have to provide uh the stake amount on filecoin as well so you're basically using a lot of capital right but what if you use the same amount of capital to secure multiple multiple services and that is basically the point of reaking right so so basically a state deep is getting additional slashing conditions so what does that mean so like uh your STD for ethereum the slashing condition would be that you have to attest blocks and if you attest a wrong block then your St will get slashed on top that let's say that you also decide to you also decide to secure an oracle service so what you have to do is you have to

provide some Oracle data uh some price data or whatever the Oracle wants to do and if you provide a wrong price from the average then you'll get slash so the slashing the slash assets will be the same so like if you have a 100 E Light lying around uh if you do anything wrong on ethereum then the 100 will get slashed and if you do anything wrong on let's say the Oracle then also the 100 e will get slashed so it has higher risk but with higher risk also comes higher reward because then you're also getting because since you're doing more task you're testing blocks on ethereum and you're providing data for orles you're getting rewards from both of these sources you're basically you're trading risk for reward you're uh exposing

yourself to higher risks but you're also getting higher rewards for that and this is not just any type of risk this is something called as endogenous risk and endogenous risk basically means that it is up to you like you will not be slashed if you do not do anything bad at least that is how the system is supposed to work there are obviously some external risk like there could be smart contract risk that the like the like let's say the smart contract get hacked that is an external risk but with a lot of audits you can be assured that this is a very minimal risk and also there could be a risk that the exact slashing condition that exact slashing condition is not 100% deterministic so like that is a

really big condition for any service is that if you want to build on a proof of proof of stake Network then you have to be 100% deterministic in pointing out in identifying who the malicious behaving behaving operators are and who are the honest operators because if it is not deterministic then there will be some external risk for ex for honest operators that their stake can get slashed and that is something that that might be uh that might be huge barrier for someone to become an operator because like if you have some external risk and you're also doing tasks then why would you then maybe the reward you're getting is not is not uh is not

matching with what you perceive the risk is uh so these are basically two important factors to consider and that is basically what recking is in an acell so now Let's uh go deeper into the P architecture so as you can see there they have they have separated the sers and operators from each other the seers are the people that have the capital and they depo and they provide Economic Security to to a service and The Operators are basically nodes that actually perform the task to perform the task for the service right so there are basically three major comp components in

a ler one is the token manager which handles all the assets one is the delegation manager which basically uh handles like who the operators are what the operator what the task is supposed to be they interact with the middleware contracts and stuff like that and then there is a slasher manager which is uh as the name suggest it is responsible for uh managing uh that the slashing conditions are verified or not so like if an operator is malicious then someone will raise an event on the slasher manager it will rerun the it will reexecute the operation and if it deems the operator to be malicious then it will slash its

assets uh and in the token manager you can see that there are multiple token pools so that is like the eventual plan of Aer is to not just uh is to not just basically use e security so like validators have to provide e on the beacon chain right and that is like the beacon that is sted into ethereum but not everyone everyone wants to get an on this action everyone wants to get rewards from staking right but not everyone has like can afford 30 to eat right so there is something called liquid staking protocols and what they do is that let's say that you don't have 32 e you have let's say one e or you have two eat and there are like multiple

people uh who collectively have 32 weat so what these liquid liquid sticking protocols do is that they take all of this e from people and and they combine it and they run a node by themselves right and whatever rewards they get uh they distribute it proportionately to the stickers so uh what happens is that along with the rewards they also provide a liquid token to them to basically make the asset to make the acid liquid so what happens that if the E is Tak into the network then it is logged you cannot use that right but what so Lio is one of the companies that does this what Lio can do is that it can take like one e

two eat five eat from all these people it will St it into the network and then it will create a token out of th uh like let's say you give me one e so I'll create one st e that represents that okay this person has Tak one e with me okay and uh and it can give me this one St token which is basically like a receipt that you have given me one e to stake in the network so now this one e does have value because it represents one e State through the Lio protocol right so you have simultaneously provided security to the network and you have also made that token liquid so that it can circulate in the D5 protocols and

generate more yield instead of being logged into a single play place right and you might think that okay that is like that's duplicate money because like the same asset is being used to but that is not nothing new because that happens in traditional Banks as well if you deposit like say 1,000 rupees into a bank uh then you then you can see that your bank balance is 1,000 rupees but I can go to the bank and I can see that hey I want to borrow 800 rupees and the bank will happily give me 800 rupees from the, that you gave me so now I have 800 rupees and you can see that you have a th000 rupees in your bank account so total in total both of us think that we

have 1,800 rupees but in actuality there is only 1,000 rupees in the bank physically like 200 in the bank and now 800 with me so this is basically how money has worked for a very long time there is a lot of duplication of money and there is a lot of reusing and like it basically increases the utility of money and defi is just doing what traditional Banks has been uh like have been doing for a very long time already uh so these token pools basically represent all these take asset classes so instead of having like redirecting your beacon chain each that you have St maybe a 32 each St you're a validator so instead of uh putting that into the token manager you can also put this Lio

de into the token manager or you can put in rocket pool e into the manager or you can put in any other asset it doesn't have to be rested you can also provide assets in general into I which can be used to secure the network that is not currently uh that functionality is not currently available currently there are only three tokens three liquid sticking tokens that is available uh which is from Lio rocket pool and coinbase Native sticking uh but like yeah there are plans to expand this uh such that you can basically use any token or any security to secure the pro of network then the delegation manager as I said it's responsible to manage like which

stakers are delegating to which operators and uh like whenever you have this service so these services that are run on top of I like an orle service or like any other service these are basically called actively validated services abss so these AVS need to as I said previously must have a very defined mechanism to identify malicious behavior and that mechanism must be uh this mechanism must be uh verified on chain right because as I said it has to be deterministic and if there is any ambiguity then that adds external risk for honest operators which should not happen in theory honest operators should have zero risk right like it's not true

in practice because there is some smart contract and there might be other risk but as an EVs and like AER itself all of these parties are are trying their best to minimize the external risk because the like uh the higher the external risk the more friction or the more uh conservative operators would be to provide security and you need to have a high security because as I said before uh is that you have to if you want to corrupt a network you need to have a third of the total stake security so let's say that your network has a total of a billion dollars that is staking that is staking in your network right so you have to own $300 million in order to

corrupt a network that is a big sum $300 million is good amount of sum that someone might not spend to attack a network right but what if it's only 50 million then a third of that would be like around what a third of 50 million would be somewhere like 16 million or so right 16 million mean it may be true that 16 million that someone can spend 16 million to attack a network and gain hundreds of millions of profit from that it is possible so as an EVS or as a protocol it is in your best interest to smooth the bootstrapping process so that more and more stickers can deposit so

that you have a huge Economic Security backing you uh which so that you can be assured that there is no that people are incentivized not to behave maliciously into your network uh yeah so that is basically of architecture of how ier works and what is the tokenomics behind it so here is basically like a architecture of how an example of it works and I'll get to it later because uh uh I'd like to talk about why I why you need to use igen layer to bootst or to bootstrap your network because uh yeah that that is a

lecture that is what the lecture is about so you have to decentralize you have to decentralize uh centralized components right and in order to do that you can use proof of sck networks instead of having a single sequencer you can have multiple sequences instead of having a single Pro Network you can have multiple provs and uh in order to in order to uh ensure that they're not they're not doing anything malicious you can use a proof of S network you can ask them to deposit a collateral so that they have an incentive to act properly so how does igen ler accelerate this process uh and the simple answer is that building a proof of stake network is hard and it is hard because you have to convince a lot

of operators to first come to your network and work for your network and uh what's harder is uh to basically get the stake is to get the economic security required to have a network that people can believe in that people can trust that people can use because you need to have a good amount of Economic Security backing your network uh so that people can believe that it's functional right and that might be because like if you're a Staker and you see that okay this project is coming up and it is building a proof of S network and it is like launching its own token and stuff like that why would you put your assets into that Network because it's

not even like you're submitting eth you're not putting in because each network has its own everyone have an incentive to build their own tokens so that they can control the toonomic they don't want to use e nobody uses e for the proof of s networks right so you have to basically trust trust a entirely new token and that the all of this creates a lot of friction all of this creates a lot of uh basically barriers to entry and this is what is this these are the reasons that make proof of s networks difficult to bootstrap and the solution to that is that I in I you don't have to bootstrap Network yourself because there is already a proof of St Network the largest in existence which is ethereum

ethereum has1 billion uh secured and there are around a million validators that uh attest block headers uh basically attest in block and validate ethereum transactions so if you can convince them to also run your service on top of that that is a easier ask than onboarding brand new operators and asking them to stake directly right because as I said uh I basically allows you to restake the same assets into securing multiple services so it is also uh in in a way saving a lot of money because as I said that if you have 100 lock in ethereum and you have 100

logged up in file coin then you have basically 200 locked up that is not being used to circulate around because if money does not circulate here is a simple concept from economics if money does not circulate if money is if it is locked into Banks or it is locked into lockers at people's homes then the rate of economic growth is going to be less and there are several economic factors behind that which is basically that the more the money circulates the more trade happens the more Innovation happens and the more prosperous an economy is and so if you have a lot of services then these Services would demand a lot of ethereum to be stayed and a lot of not just ethereum in general just just a lot of assets to be

stayed and that would basically hinder Innovation right so reaking allows you to use the same asset to St multiple services this way a lot more asss each or a lot more assets can be in circulation uh that is uh one a good thing that is U and the other thing is basically pooled security because like you're basically pooling security uh increases the cost of corruption for everyone so imagine that you are using a Dap okay and app has some underlying services that it uses so it uses ethereum because it's built on ethereum it uses let's say chain link for its

Oracle service and it uses a bridge which is let's say that the bridge is decentralized okay so so it's basically using three decentralized components ethereum has an economic security of100 billion wow a lot that's good te drink I think has a Economic Security of around 800 million uh so yeah 800 million is also a decent amount but this bridge let's say this Bridge only has an economic security of around 100 million so what do you think is the economic security of the protocol itself that is using the three services uh and the answer to that question is 100 million the weakest the the strongest like basically the network is only as strong as its weakest link so it doesn't matter with has 100

billion it doesn't matter if chain link has 800 million the weakest link the weakest part which is the bridge is uh has 100 million security so that is going to be the overall security of the network and that is somewhat uh that you might uh that you might realize that is not a very desirable situation because uh because if you want equal security for all these Services because in future because you can already understand that in order to scale blockchain in order to basically provide the infrastructure for Mass adoption you need to have a lot of different services and if you want of these services to be secure there needs to be a lot of state capital behind each Service uh and that could be that could

become a huge problem so that's why that is the reason why Ender is so revolutionary because it removes this need for each service to be backed by a lot of capital you can have a huge set of capital and that single set of capital can provide pool security to each and every user one risk is obviously that uh what if multiple of these operators are slashed at once like let's say that you're an operator uh that you have St 100 e and you are validating ethereum and filecoin let's say and let's say that you're a bad actor and you do malicious transaction on ethereum and filecoin both then both of them will come to slash or 100 e tokens uh but ially uh you should be

slash about 200 e right uh but you're only SL 100 e so only 50 e per Network so you must some people have this argument that uh because of weaking the exact security is diluted uh which might be true to some extent but uh something like that happening is not very practical however you might still want to get uh some security insurance that okay even if everything goes to hell even if everything goes to mhem I still have a set of Economic Security that is mine that is 100% M and that is where something called attributable security comes into play uh this is that is currently being developed in house in aen and uh the basic concept is is it's

like an elastic uh it's an elastic demand for trust so like let's say that you are a network and you have a few users so you using the pro pool security and you have a small Insurance of 10 million each a long 10 million dollar worth of security on top of the pool security so this 10 million of attributable security is y so this 10 million is only going to be slashed if the operators are doing malicious transaction are doing malicious behavior for your network and only onor and let's say that your user base increases in the future what so what you can do is you can increase this set you can pay you can pay more so that is where the elastic demand part comes

in you can pay you can basically ask for more service and you will be given more service like more people can devote attribut security to your network so that that piece of stti will only get slashed if something bad happens on your network and it doesn't has any correlation with any other network so you are free from the risk of other networks that way and uh another thing that I is building is something called dual staking so as I said that each network has an incentive to basically launch their own token because everyone wants to be in control of their own tokenomics right and uh the problem with that is it's basically that the token at start definitely volatile why would I

secure your network using my Assets in your token so what if the token is volatile what if it's a pump inum scheme like there could be multiple cases why there are risk associated associated with a new token so in order to reduce that something called D dual sticking was proposed and what it basically means is that the network will be secured both by a stable asset like e or usdc or something similar and with a token that the network has created itself so let's say that there is an ALICE network with an Al token let's say so at the start no one would want to buy the AL token so what you can do is using dual sing you can secure 90% of the

network using each and 10% of the network using the AL token so you need to hit need to hit a quorum on E and you need to hit a quorum on the AL token and then only a of task will be validated right and as time progresses as your network stabilizes as you're bootstrapping to a higher level of Economic Security and uh as you're building a community so people are basically trusting you and the token volatility decreases over time you can slowly increase the share of security that your token provides compared to each so let's say after a few months you increase it to 20 then a few months after that you increase it to 308 and slowly slowly slowly you increase the token

your own token uh as Bic to secure the network so that is the also another thing that I is working on these are all the benefits uh which basically allow anyone to bootstrap a proof of network with EAS and without any of the constraints that they used to face traditionally so now coming back to an example ABS architecture so there's this repository by called The Incredible squaring abs uh and that is basically uh uh that is basically like a hello world example of what a simple EVS would look like so as the name implies uh it's an ABS that sends a number to The

Operators and it asks The Operators to square that number and return back so uh uh so basically yeah that is the task that they are supposed to do so let's see like how it can be architected like how an EVS can work internally so in the uh and a disclaimer is that this incredible squaring architecture is something for demonstration purposes the exact architecture design of any AVS is like highly specific to exactly what that AVS does so a lot of these components like the aggregator that's written here and the Tas generator these are not something that you might find in other evses as well so this is just a very general overview of how it could look like and it might widely

differ based on the exact task and the slashing conditions that the AVS must that the AVS actually goes through so in this particular example there is a Tas generator which is like an offchain component and it generates basically random numbers at a fixed interval so what it does is that there is a set of AVS contracts right and these and the task generator basically calls a function on this contract uh to upload the number on chain so whenever the whenever the number is updated on chain The Operators The Operators that are opted opted in into this ABS they listen to that event and uh they receive the

number from from the from the blockchain and then they actually perform the trans they perform the task they Square the number and then send this number to an aggregator this aggregator now basically takes all these responses and it Aggregates them into a single response and then it pushes this information on the AVS contract as well saying stating the task is done and in this process like if the the any of the operators have done any malicious task then uh it can call it can talk with the I contracts and it can actually slash the uh Slash that operator take so here is a more detailed overview of how it works

so you basically have three components you have an aggregator you have an operator and you have the contracts on so in this particular example the task manager and the aggregator are actually uh coupled into a single coupled into a single machine right so the agregator spun up basically two threads where the mean thread uh has the task generator it sends an event to the contract and uh like it calls a function which emits an event so when the event is emitted the operator has a subscribed thread which basically listens to that event now these distributed networks are basically like generally written in

goang and goang has some Concepts like go routines and channels so like go routines is basically used for concurrency to concurrently execute operations uh on multiple threads and channels is basically a communication method that can basically send data from one go routine to another so we have the subscrib thread which basically listens for the events and through a channel it sends that data to the main thread which performs the task it squares the number signs the transaction and then calls the aggregators RPC RPC thread which verifies the signature that the operator has sent and then it Aggregates the

signature so now like let's talk a bit about signature aggregation so if if I have ever talked about it in a previous lecture that ethereum itself uses something called BLS aggregation and that is basically signature scheme which allows you to combine multiple signatures into a single signature and if you can verify that signature then you know that all of the underlying signatures are also valid and this is important because let's say you have thousands or millions of operators and all of these send you signatures stating that okay this is the task that I have done so here's the signature proving that I have done this task right so uh if you sit down and try to verify all

of these signatures then it's going to take you a long time because like signature verification is not like a trivial Tas it's like somewhat mathematically complicated so that is that was actually a problem with ethereum at like when Pro of St was being developed in the earlier stages before the merge is that they could have only uh they could have only supported a validated Network or a few thousand operators before the scheme was introduced because that's how expensive signature verification got and if you wanted a high enough security then each operator like to give you a sense of uh how bad the situation was each operator would need to have state around 1,500 e

in order to secure the network because if there are only a few th000 operators and 1500 e is like it's a lot of money so like if I think 1,500 each at a current price of around I think $3,500 it's around5 million doll per operator per validator that's definitely that was a very undesirable situation so that that is when ethereum basically went out and created this BLS aggregation scheme where you can add all the signatures together and then you can you just need to verify a single signature this allowed ethereum to reduce the reduce the basically staged amount down to 32 each which allowed more than which as of

today allows around a million operators to attest the ethereum blockchain uh so that is a technological fat and that is what is happening here as well in the aggregator where it is using BLS schemes to aggregate all the signatures and if it reaches a quorum because let's say that only one of these operators let's say responded right you're not going to say that okay this task is done and there is a verifi uh like okay I have verified okay that this task is done when only a single operator has actually given you a signature right so that is not something

that that is not something that you'll consider secure right so that that's what the concept of a quorum threshold is is basically that okay if you you don't need a single operator signature you actually need a multiple operator signature and there must be a threshold of not operators per se but like the economic security backing it so like let's say an operator has St one e another has take let's say 10 e another un s let's a three right so like the sum of all the economic security Behind These operators must pass a particular threshold so you can say that okay this task has been done with an eon Economic Security of x x million doll let's say and that amount should be sufficient enough for you to say that okay this

condition is indeed verifiable because it's a high enough uh uh because it has high enough Economic Security backing it uh and yeah so if a if a particular quum threshold is reached then the task is marked as completed and the response is submitted on chain and that is basically an overview of how the incredible squaring repository works there could be multiple EVS designs so now let's look at what are the different evss that can be built on a and how can it help basically roll up interest so uh the first thing that comes to mind is definitely decentralizing sequencers right so you have a sequencer the sequencer is supposed to bash transactions so instead of having a single node run it you have

multiple operators that do these transactions and if any operator is acting maliciously then you can just slash them this solves the situation of censorship because uh like when you submit a transaction on ethereum then you don't s like you basically give that transaction to a node and that node gossip the transaction around the entire ethereum blockchain right so you are sure that your transaction is eventually going to get propagated to the block minor so similarly if you have a multiple sequences then if you subm a transaction is going to be gossiped around basically all the entire P2P Network and then you can be sure that even if one particular node is malicious that okay I will not include a

transaction another node might uh so that solves the problem of censorship and also downtime because if a particular node is faulty or down then it doesn't matter because there are a lot of other nodes that can pick up the slack uh so that is like a very good argument to have decentralized sequences which can be built on aen another thing that can be built on a is basically data availability so if you remember the lecture uh from aail they talk about how there are bunch of nodes that uh a bunch of nodes that store data temporarily and these nodes can be built on AER and AER does have a data available called I da that is it has developed in house uh on top of that it can

also uh include fast finality I will come more I will talk more about it in further slides uh another thing that can be built is Prov networks so as I said that in ZK rollups you basically the sequencer provides a batch to the prover and the prover generat ZK proofs for these transactions and submits an onchain but the ZK prover can if it wanted can censor transactions and not generate proof for your transaction it um I might remind you again that a ZK approver cannot Forge transactions and it cannot generate invalid ZK proofs that is not mathematically possible but the ZK prover can sensor your

transaction and it can be down so like the entire batch is not submitted because the prover is not working so again yeah AAL Network can be built on top of I layer or any proof of network and uh this will solve both these problems there is a lecture further in the series that talks entirely about proven networks and proven markets because it's a very complicated and evolving field and uh yeah so we'll learn more about that later and uh other things that can be built on a are keeper networks or watch Towers watch towers are basically notes that look for invalid transactions so like if you remember the fraud proofs lecture uh there in optimistic rollups you basically assume that every transaction is correct and you submit

that transaction on chain and if if the transaction is indeed invalid then someone can point out that the transaction is invalid and you can run a fraud proof to like basically revoke that state so in order to do that someone has to check someone has to look in ethereum everyone checks everyone looks all the transactions are re executed by the entire syn like the entire validator committee for walk right as I said in the finality lecture but on optimistic rollers you only need at least a single node a single operator to rerun the transaction to check if the if the transaction is valid or not and if it is not valid it has to submit a

fraud proof so that is fine for optimism that is fine for arbitrum but uh if you notice in the ecosystem that a lot of app specific chains are popping up a lot of general purpose chains are popping up and in this ecosystem where there are a lot of different networks and a lot of them might have this optimistic approach then it might be difficult for these operators to basically rerun every single transaction that happens right so you need a set of watchtowers a set of nodes that specifically rerun each transaction and submit fraud proofs for for any invalid transaction is in all these chains like right now the chains are not

that huge but there is a road mapap there is a design philosophy this modular philosophy that there will be several app specific chains in the future so there needs to be a bunch of notes that should rerun transactions and watch if all these operations are indeed valid and submit fraud proof is then not right so this is something this network of notes is something that can be built on using proof of K keep networks are same keep networks are somewhat similar in the sense that they do conditions like if then if this then that right what that means is that let's say that I submit a transaction on chain and uh you need to run a script if my transaction is submitted so you need to

basically listen to my uh you basically have to listen to what my transaction is doing you might realize that this is similar to what relays do and what I've written here as well that Bridges and relay networks can also be developed uh on evss because what is a relay basically like if you want to transfer assets from let's say e to arbitrum you lock your assets on ethereum so when you actually lock it on ethereum an event is emitted a centralized Bridge or a centralized relay basically listens to that event and it releases assets on arbitrum chain to your account right that's how you're basically getting uh that is how you're basically getting that the assets

transfer from one chain to another and and then you're locking it on one chain and you're releasing it on another and that happens through by basically listening to events that happens right so keeper networks are that that there's a bunch of note that listen to these events and they do stuff based on that event so for example let's say that you have a strategy or you have a position on a or compound and your position is close to liquidating right so if your POS is let's say your health Factor drops below let's say 1.5 then that is an that might be an alarming state to be in so you might have a condition where okay if this if my health Factor have drops down or if

let's say my LP position goes out of bounds or if any particular X condition happens then I need to take y action okay and if you run this type of logic on a centralized server then you might have the downsides of a centralized server that the server might go down or if the server is owned by someone else then it may not do that or it may do something else um right and you might not want that so these keep an networks that do that listen to blockchain events and do actions based like based on your instructions these can also be developed as decentralized networks so that you can be sure that okay I want if x happens I want y to Y to take place and

you can enforce this using a proof of stick network using keeper networks and another thing that you can do is basically Bridges which is as I said that okay you in instead of having a centralized server listening to transactions you have a decentralized server so it always because that is a very problematic thing to have like let's say you lock your funds on E that is irreversible you cannot change that that happened on ethereum Main night right and if the Rel network is down let's say and the Rel Network or the Rel network is let's say malicious it might not it might refuse to release your assets on the other chain so that is like a very big concern and to solve that concern you can you can basically decentralize

brides and decentralize Rel networks so yeah going SL deeper so like data availability so as I said that igen layer is building an inhouse da called igda which also hit main net a few months ago and uh basically how it works is that the sequencer sends a batch of transactions and through some math you're basically dividing that up into multiple chunks multiple blobs per se and you send these blobs to operators to hold now these operators have to submit what is called a proof of custody which basically proves that they are indeed holding this uh data set right and if

they're not holding this data set then their stake will get slashed so that is where the slashing condition uh is enforced in igda and that is how you can basically decentralize the entire da layer you can decentralize data availability which has first of all the benefit of being censorship resistant and you know that this thing is not going to Hal and it also has a benefit that da itself enables far cheaper gas prices as was explained in the da lecture another thing that can uh be built as I said was fast finality so when when we were talking about finality uh we know that optimistic rollups have a finality about

of one week right if you assume that the if you don't believe in their Economic Security if you believe that yeah the economic security sound if you believe the fraud proofs of sound then you might assume that okay every few hours that the batch is submitted you get a finality uh but that is as I said very much dependent upon the economic security that is backing it so uh as you can see that you can build something called a fast finality layer on I layer which is going to be a proof of S network that can either give you a soft confirmation where you use uh basically a you basically attest that okay this particular information is

going to be is correct and you get an instantaneous uh uh you get an instantaneous finality for that transaction but there will be like a 7-Day period where someone can attest uh where someone can challenge your claim and if through I layer if you can imass a high enough Economic Security backing the system system you can basically discard that 7day period and you can say that okay well like when I propose the block that is the final block because I have no incentive to lie because the economic security backing it is too large for me to lie and uh another thing one variation of this would be that previously say optimism has to attest the entire state of all transactions

onto ethereum M head but now what it can do is that it can send that statement to I operators which can then submit a receipt that the like that the state is correct on let's say a different chain like arbitr and then they can settle uh they can settle this data on the finality layer and then they can ensure that there is first of all cross chain interop interoperability because you have like the data on multiple chains and you have a finality because there is a lot of Economic Security back in this network so yeah this is basically like an overview of a bunch of rollup infrastructure that can be built on a ler and uh that was it for the lecture these are a few references that you can look

at to learn more about what I talked about in this lecture so yeah are there any doubts or any questions