ZK HACK III - Unboxing the zkEVM - Scroll

Transcript

foreign [Music] and so so what's the score so score is a ZKA roll up so for scaling ethereum

um and it attempts to be evm equivalent as much as possible so that means it can read the byte code for this solidity compiler so and modifies and it even calculate the gas and as many details as possible yeah so vision of score and the ZK all up so again scaling uh it's all in the open everything open source and everything is meant to be decentralized it's not easy to do so it will take time but uh teams are working on this centralization yeah what about secrecy

is there also no no that's not in scope so so in the model of the evm is really difficult to make private because it's an account model and if you want to do a private protocol let's say we over people they need the states to make their own transaction right so if I send a private transaction that is kind of encrypted however people are not going to be able to continue and spend their own money or do their own induction contract so it's pretty difficult to make a private evm you you need another model basically of

of computation is this possible it's just very different so how does a work work so we have mainnet uh so there's going to be a smart contract on mainnet but this smart contract it holds basically with stay towards so I hope you're familiar with knuckle trees and search so it's the woods of the current state of the orap and the smart contracts once the next state and just update the next steps like this and that will commit all the

transactions from the roller player so the order is another chain with a whole lot of transactions happening there on Layer Two and we'll send the proof to the main net contract but all those transactions are correct or that the side effects are correct and every smart contract will just update this wood which is very small compared to the amount of computation that was happening yeah the data of the transaction is still on mainnet on ethereum mainnet so the decentralization of ethereum will

guarantee that this data is always available uh so you can always connect to some ethereum node and get uh the compressed form of all the transactions of your app so it's it's much much smaller than the transactions on ethereum for instance they don't have signatures and they are compact in some way but they're enough to to reconstruct what's happening on viola so let's contact the proof so in the architecture of score there's a relayer but

um but but who is this data on our updates it with the transaction data that I just mentioned and it also uh synchronizes the the contracts share the proofs with it and the sequencer sequencer it means it's like a gap right it's actually modified uh yeah so it's what you connect your metamask tool and it can tell you what is your balance and it can accept your transfer transaction so your contract transactions uh and it's going to prepare them into a block right

so from there it needs sends it to approver so approver is a separate component because it's easy it's very big it's like a super computer it's uh that General DK proofs uh goes back to the sequencer and relayers to synchronize let's say something uh several things so the approver does not like basically blindly trusts what the sequencer is is doing yeah it's a service for we sequencer right okay it's here is my blog and give me a proof okay so it's a big machine with a lot of gpus inside okay and right now so in this version of

score I was running on test net it's uh it's basically all together right in in a cloud so but the same organization but then not shown here it's meant to be decentralized so you will have a everybody can run their own Hoover and be paid for it and they just have to accept the block when we post and the proof and the proof is correct they will be rewarded and the sequencer has something to set aside the contact one minute and so if the sequencer is some kind of modified gas what consensus algorithm

does it use and uh is that part of the thing that has been proven by basic Canadian yeah so so again that's that's two phases right that's the phase where it's not decentralized it's not the centralized but it's uh cost less incorrectness right so the sequencer cannot cheat cannot make fake fake transaction or something or steal someone's money but it's centralized like you have to send information to it face to the question uh is the what kind of uh circumstances uh I don't know honestly uh this is

called what does research about that uh so it's in research right but uh will the concept aspects of the consensus will also will they also be proven or is it is it just the execution that gets proven by the by the proverb um our weather the main net verifies the consensus of the Europe right uh I don't think so I would call it the first phase when because this is even more difficult but that's also possible that's something for instance Mina does that like it's a DK proof of consensus as well not at first you have a

consensus of your work and actually the the goals and the constraints the consensus of the verb are different than this of a blockchain so that's that's uh that's why it's an area of research um they doesn't have to do the same things but that's not my expression right I don't want to trail to the Earth too much but uh what are the in what respect okay it's not your area of expertise so yeah we can but the important part when we say we decentralize the sequencer it's about a censorship resistance right so if a sequencer doesn't like you you can always find another sequencer uh to

to include your transaction in some future block so that's that's the decentralization and uh a quick question if someone um like could okay Ur sequencer and I want to prevent you from uh the Euro sequencer and you refuse to censor me for example but someone else doesn't want to build on top of your proof can they do this can they block you this way to build on top of your proof uh like you push your your data you push to improved the the roll up and somehow can they decide I'm not going to build on top of that block on that uh well what is the difference of consensus between

mainnet and all that right because really we rely on the consensus of the main net so once we swallow contracts say that there's a new block right uh you cannot you don't have like a rule of longest chain or something like you don't have another chain right it's where when we when the main net contracts approved the block then that's that's the top of the chain okay so everybody Builds on top of it and the only thing that goes into the roller contract is to say the proof is correct you can't say the proof doesn't follow my uh consensus rules so if you can't oh yeah it's more the contract that's real uh enforce the

consensus world right right so in the not decentralized right simple it's just like uh an admin right it's a privileged accounts every sequencer or medicine seek and that's like consensus so we contracts it sees from where it accents it and if we do a decentralized consensus yeah the mainland contract has to verify that this comes from the the conference protocol so maybe it's not verified in ZK but verified in smart contracts but again I'm not completely sure and this is in research so I guess we'll uh we'll have more communication about that

in the future for sure all right so now let's focus on the ZK evm that is uh that is contract once or maybe you can check for questions first if there's anything um I'm not sure uh not yet yeah so I'm not just tell us if we should go to the chat I will I'll jump on thanks sorry no no it's cool just one thing when you're talking make sure you're in the screen okay yeah exactly because you were a

little bit off earlier but um keep going so the ZK VM now so a particular one that we're talking about uh it's a project of uh Foundation privacy and scaling exploration and the collaboration with score so a PSC group is interested in that because it's to make proofs about a validity of the main net block so to make a kind of lighter nodes right So eventually maybe in some years we can have lighter nodes but just verify if

someone makes a proof and then you only verify the proofs of the blocks and you don't have to have all those like terabytes of data to verify it yourself or however people know this these days right so so that's what uh what's the goal from here L4 is this EK VM is part of your work so but that's the same same code base mostly um have to prove so if people have IDs what does physique evm do what is it executes EDM contracts yes

so it has to execute the contracts so step by step so first get the transactions right so that's to verify the transactions like this encoded like compressed transactions I mean execute the transactions first and then if you're on the producer end then verify them if you're on the receiver end but yeah I assume if you're using zika Roll-Ups you don't really have to verify I mean you're not going to verify directly like it's currently done in get you don't re-execute the program oh yeah it does it does so basically AVM kind of

executes the problem uh when producing blocks yes not when they're refined not when verifying okay so with verifier is a kind of verify your proof is kind of like a compressed way of verifying the entire thing it's you can when you make a proof you can see there's a circuit and you can think of the circuits or the computation and salary proof as being a v-verifier like virtually right it's like a virtual verifier but you try to convince as a proverb and this verifier is this virtual thing is executing the contracts

step by step so so when you have your solidity smart contracts uh it's so it's in byte code right starts at byte code index 0 and goes to the next one and the next one and sometimes it jumps and so on right so so that's to do with step-by-step execution as well as well it has to verify the byte code also because how is you where does the bytecode come from it's uh you're still asking me yeah prove the execution trades service the

condition yeah that's that's a good way um and I would say yeah we buy good where does it come from uh it's the Proverbs the buy code and the verifier wants to do what basically we calculate the hash of the bytecode so because the accounts on ethereum so a contract accounts it's a it Stores Only the hash of its backwards somewhere right um yeah I mean you're also you have to I'm talking about yes you have to store the the code of course but yes the account only has a harsh reference to the to the code that is stored yeah and when there is a call to it you have to

go to your database load this by code so improve up here does the same yeah lots in by code but then you have to also recalculate the hash because it's a sort of like temporary in memory or easy KDM so if we calculate the hash to see that it's uh but but there's a question to highlight from now we'll go back to it um what else do they need to do uh it needs to recalculate the state codes yep because when we go to uh if you are contact we're only going to

give a word right like 32 bytes right so when we contacted as the previous word and the next words right so that's like 32 bytes each so with ZK evm has two whatever it reads from Storage it has to check that it is included in the old statehoods so it has to do macro paths and the things that changes it has to do a micro buffing to be new statehoods so it has to verify it's just all its storage axis so all this um there's a lot of information Associated uh with the execution of a contract and the zkdm needs to validate

in regular outside of the KV in the regular evm uh there's a lot of cryptographic Primitives used like let's say classic uh cryptographic Primitives used to validate the data in your past is correct yeah and you need to do the same thing in the zik area the same kind of verification but presumably uh in a more ZK way yeah it has its cryptography and inside race cryptography right the actual thing you compute is a cryptographic like hash functions right in your country for instance and verifying signatures from the transactions

so it has to do that as well so it's also cryptography and it makes sense that every time you have a ZK something a ZK socket what are you going to do inside there is always going to be some cryptography inside like to communicate between the circuits and the outside right so there is maybe a lot of data inside of a circuit that is being proven something about uh with English and uh but it does to calculate a hash of it some kind of commitment to the outside right but the outside knows what the circuit was talking about for this time like these State Foods or also the hash

of transactions right so it's always like this but the ZK is okay it always does cryptography inside and that's why we are so concerned about finding Primitives that are efficient indicating like so for Harsh functions everybody likes the opposite for the album the selection for instance yeah uh yeah because the problem with the current state of ethereum is that we're relying on some cryptographic Primitives which is called the ketchak yeah which is the one of the precursor to to shop um and uh shaft 3 and we uh this is something that really doesn't play nice with ZK circuits yeah so do you use

other Primitives inside like because you have control over this this sequencer you could decide to change somethings while not changing the functionality you could change the flavor of some exactly yeah and it goes back to what it means to be equivalent so if we change the hash function of these statehoods of the Immaculate tree is it still equivalent or not I think so it's equivalent but it's not compatible it's not compatible on uh like on the bike like serialization right yeah but from the point of view of a smart contract the contract doesn't care it just says I want to read and write into

the storage and it doesn't seem enough to know by the way it's a marker tree or passion absolutely but there are other places who have a smart contracts explicitly once a catch up right and if it's not a cash check it's a different value it's going to be incompatible with yourself yes that's true so so there are both so in physics functions there's the cash check one which is a bit more expensive and the cheaper one so it has both depends on places so solidity does a lot of cash check inside right yeah every time you read if you can use this storage it doesn't get shock to find the key of storage and this will have to do as well you have a

question uh I have to move here no no no it was it was right here can you discuss Scrolls work on GPU Yes actually oh just one thing about the questions if you you might want to start at the bottom so if you look there's some that were answered that was from the previous session and then you might want to work your way up just FYI oh wow yeah no no five questions basic q a tab but this is still about the over so here I'm in the chat tab right uh you should say q a there's if you click on Q a q a this is go sessions q a I have to go to the top oh this is so confusing this is

our product ah well we've been using it for a while but yeah do you see it it's just like because in KVM it's a flavor yeah so at the tops so GPU so yeah we have an Ontario team working on the the poover here which is a lot faster yes I need to interrupt you real quick uh you do need to read out the question that you're answering because the video we won't actually know what you're reading so say the question give the answer and just to note there's four four of them there that you want to answer so someone is asking about scores walk on GPU acceleration and uh yes there's an entire team working in life

um so you have the cooler implementing in in Cuda [Music] and a lot of this Decay game a lot of improving can be done in parallel to not all of it so we are still bottlenecks but a lot of it can be in parallel and on gpus it's it's very effective it's all arithmetic so uh yeah so so it's really important yeah away from proof of work we have a lot of gpus available right yes yeah and we use a ridiculously big gpus um whatever is this available

uh private Seafood so those physical VM have policy features so we explained uh but no because of the account model of the easier it's very difficult what are we security challenges you are facing uh will face requirements so so this is very actual so we're running the security audits now it's starting now uh and there are so many I have a lot of slides about that [Music] um really challenges so one of them is you you want to be deterministic so you have the old statehoods and you have the transactions

and that implies the new status so you have to be very careful there are so many steps and it has to be all deterministic into the new States because otherwise we have the problem I explained earlier but other people will not be able to make a new transactions or to continue in Europe uh because they don't know if you can generate another state that is not deterministic and that's different what what other people would would want with the honest software when other people will not know what is inside of the states and so they cannot make a market pass anymore

so so very important to be deterministic and then of course important to be correct right all of your walls are these smart contact has been prevented uh there are so many so many words so many so that's um then you have another security aspect which is the security of smart contracts so the solidity compiler and the smart contract Developers uh they make some assumptions about all the evm was also so of course there is this spec the yellow paper and then you have a but there are also other assumptions a lot

of details that they rely on and they rely on the latest eips and whatnot so you want uh that when people deploy smart contracts on the overlap but it is uh to work the same it's as secure um needs to run a big transaction sometimes right and that uses a lot of gas right and of course if developers have to be careful that this big transaction fits into a magnet block but now I have to be careful also that it fits on the overall block right so ideally it will be as big capacity but if it's not we have to

design this smart contract to [Music] the main thing right and you also sorry you also have potentially because if you're using Poseidon so um I know I mean people most people trust it but there's still some uh suspicion about the the eventual security that this item brings um is that also something you I mean I assume you must look into that into the the security the safety of the core Primitives you're using yes yes and that's two things you need to live in

the cryptography of the hash functions and the cryptography of improving system also and you need to trust yourself implementation right right yes the implementation of it in circuit uh and again both PSE and score of teams of cryptographers um looking into this so lots of crypto what else insecurity uh yeah I mean maybe we can get another question yeah but yeah security questions then you have a question or maybe you

will move on to the next topic uh there was there was a question at the top easy communication it is a sequencer and we layer real time on the schedule I I don't know I don't know what to say uh well I mean it's got to be scheduled at least uh between the real the relayer and the sequencer uh depending on how the the sequencer works but if it's like block based it has to follow the clock of the block production so somehow it's at least somewhat scheduled I assume yeah I'm not sure what is meant by scheduled but it is I can show something yes

uh so presentation from here and you see it so you see me sequence it's a pipeline actually of proof generation like that [Music] so T that's twice so that's a block that's already all the mini steps inside of a block we work transactions and okay you have here a block all right so basically if you understand correctly uh the sequencer yeah it's really just like gas producing blocks and then um the whatever you call it the coordinator will generate uh for the

proverb basically will follow the chain maybe a bit behind and produce proofs uh possibly for a series of blocks to attach to keep catching right um so yeah it looks like indeed it's kind of uh I mean it's both real time and scheduled in this way I assume uh because it is it's scheduled in the sense that blocks get produced with some regularity and then uh it's real time in the set that uh you still need to be able to to generate proofs that requires a lot of computation so it's on the yeah it becomes available when it's when it's

ready basically yes and the Proverbs we call them auras they they really work as a service but they're not the ones communicating with chain it's the sequence uh requests please make me a proof and when it's there then it can but so again this is not much but so maybe I will say something wrong but um their faces um but so block is proposed uh then you have a transaction data is committed so it's available everybody can see the

transaction data and it's finalized once you have proven what's the result of those transactions so there is a multi-step like that but I don't want to call it more on that because I'm not so sure uh I'm working more on the inside of Education uh all right yeah maybe you want to show some traces yeah maybe let's let's uh let's yeah so oh we were still talking about that so we said I think we're inside but

um so then what's inside so we Trace that comes in so that's all these steps uh but we every transaction does uh won't be smart contract uh read and write and transfer tokens and such so that's all this steps that does and this goes into a circuit so it's the Tracy sort of encoded in a way in the inner circuit and you call this B Witness now basically here it's not just this processor of bytecode right it's a full computer inside it has also it has a CPU

kind of CPUs but it also has a memory it has a stack and it has the permanent storage that's an SSD compared to one that looks the same these days um and it has other things so for instance uh the the cat shark and both the island and so on both are separate circuits so so they are quite quite a lot of them and with different specialties so it's like co-processor in a computer right that's specialized for machine this storage circuit is specialized to ride those marker workers proofs and so on uh you've got a question uh what's

good so what's the constraint size of the aggregation circuits uh well this is getting very specific uh they're trying to steal your idea well it's not in the open right so you can do with the code um yeah what idea mention yet uh to go for this is that both are we so okay vvm circuits that makes a proof or maybe we can think of it as multiple proofs and then there is an aggregation so in program moving dkdm pools are for this Decay part like compresses a lot right

it's a lot of computational that's complex into a small proof but even that is still too big for maintenance but even verifying the proof uh this is too much for the smart contract or too too expensive and it's too big um so so there is another circuit which verifies the Decay um uh and then let's approve that it does verified it right that's two layers thing and this proof is uh smaller and this is what goes to the to the main net contracts and then in the magnet contract there is also verifier but but they find the

small proof uh and this aggregation here this is this is also very big uh so story maybe half half in in costs or such well it can be tuned so so we can change the barometer and change like which one has the most constraint so that's because we use Halo 2 and Halo 2 is very flexible so if you want you can you have basically a kind of parameter that you can tune that's what I call the width and um and you can choose if you want the faster approver or a faster verified

right so so the answer to this question is uh depends we we tune it to optimize it like how many uh how big the aggregation is um it's not another question oh yeah you have to expand so he's there checksum mechanism for the correctness of information sent to this Russia I understand the question um

I mean basically a DK uh very big generalization of Jackson it's uh so yes it verifies the correctness of everything [Music] um a full transactions there but by the way that's the question I had for you does it verify or does it leave it on the on the blockchain to let anybody else uh you know kind of a optimistic roll-up kind of thing uh does the contract do the verification or does it actually just put the proof and someone else can come and say and flag the proof as invalid

so this is the difference with optimistic overlaps it's uh no there is no someone comes to do something if this smart contract sees the proof verify the proof and it goes to the next stage instantly because it has verified by cryptography rather than they fight by someone else who would be watching right okay like in an optimistic so so no there's no such thing well we could have right that's kind of like a vitalik's points about like the training wheels and so on and having [Music] um multiple mechanism so so you could say

you have the proof and plus uh fraud pools maybe someone that watches uh that has one hour to to dispute people so we could do that yeah [Music] um maybe let's let's move on yep so we were focusing let's focus now on the process of parts right that execute the bytecode so looks like this so the steps they are like cycles of the machine um it's like time basically uh and at each time step you have an

instruction coming so you have to read it so there's a program counter and that tells you which instruction you buy code is just to execute now and it close it verify that deployed it correctly and when executed so that situates that's clear to it yes um when for each step of the machine there is a like sub circuit let's say that's going to verify its execution so what does it do it it applies yes a step what does it do it has to apply the side effects of this instruction but as if it's push

here that's going to change the stack it's a side effect and the second thing has to do it has to move to step two so verify that it updates the states correctly between steps and steps don't have all the same size so some are like more complex than others and take more more space more weakness space in the circuit so um what about many more things um what's inside yeah so we step us to support the

different type of instructions but you could see that any cycle um so it's a sort of switch statement right you know like looking at which op code we have and do something different for each popcorn and then play some space for the witness and depending which of code it is there will be some logic and this area of weakness will be used by the implementation of that one up code right so so that's that's what you are you know in this step and this is really very similar to a regular CPU right so we Pipeline with of CPU it's a fetch

instruction decode instruction uh execute instruction and write back the results so that's you can identify this also in this EK VM for instance you have a program counter um you have a stack pointer so all all very similar very familiar uh for people who know CPUs um so basic part which is like a state as in a state machine where's the part that looks at instructions and there is report that executes the instructions including the side effects like white to storage unit side effects um

yeah and it does calculate the gas as well as part of this applications of this code [Music] one question I had uh yeah uh it's a the stack I'm trying sorry I lost my train of thoughts but uh yes what about uh immediates you know you have some some uh instructions uh well actually there's very few of them but there's push for example in the evm by code push is followed by uh the value that should be pushed on the on the stack yeah uh how do you encode this in uh yeah in this case actually that's that's something

that makes our life easier right as you said in the evm where there is very little robots right yeah like in immediate so immediate means so that's an instruction as an opcode but the family of instruction and it might have an argument like this and inside the byte code and that's inside of a byte code so that's basically the next byte and maybe next next uh but the evm either so the instruction set that I think it's only push that does this I think all the others we don't even have arguments they don't have appearance yeah uh there might be a jump but I don't know if it's it was

debated I don't remember but yeah I think we jump with from the stack also yeah there's a jump immediate yeah maybe yeah but mostly the the instructions were just awkward so most of them so it's uh it's much easier to decode it's basically the simplest either uh before turing machine right that's um so that's really good and your question was how do so how do we actually handle because there are some some like this you could have you have a plush push 16 or something with 16 bytes behind

um and that's a separate circuit actually was it on my list today uh well it's yeah there's a there's a bytecode circuit but does this so but decodes we buy code and it recognizes but [Music] um when the op code is expects an operon like push one next byte is like this it decodes this and puts it in the in into a regular table like with a regular form but it's easier to read so the evm circuit can just say give me this index and it gets uh the proper bytes and it gets information but this device is an opcode or it's an

operand so yeah so there's a dedicated circuit to to reformat the bytecode and also calculate the hash of the Black Codes yeah you got another question let's see uh how modular is your circuit arithmetization with a real code of a circuit so if we our code has an implementation in a big circuit so um so the information is very it's a good job right it's like maybe a good show somewhere at least let's see I can look for some code just

to show you uh how how much is uh you see that's uh oh yeah I was showing the white screen so you you see that leader like so this is very decoupled so you have an implementation of each hop code here inside so and then it's every each one is in a separate file so it's pretty modular um and that's all one circuits well Matthew one second with the op code implementation but the implementations they rely also on those separate circuits for instance you buy code one

and some other helpless circuits that's not the upgrade uh what else can I say about this this is uh yeah no this is very very modular design and also can be tuned as I said about performance of proverb versus the fire [Music] so someone's asking how we run West code on Nvidia gpus it's not so the the implementation of a circuit like it might might be fairly complicated uh

to implement in us but really what we Implement is we verifier right you know not not the approver uh a program there is of course implementation of the program but on GPU is different and we program this University and it might be fairly complicated to generate the witness but after that we the circuits that we described it gets compiled into something much simpler the form that it's compiled to is basically just a sequence of addition and

multiplications so long sequence of operations that are very simpler and that then is implemented not in us but when the rest Cuda right so yeah because presumably there's an llvm back end that compiles includer I'm pretty sure yeah and so if you have rust I mean if you rust is based on llvm so you could you could potentially uh write rust code that calls the Kuda function yeah it's a wrapper right so you have a core or canner but when your application your voice is invest and you call

you can this yeah um but again you don't have to implement all the complexity of making the witness for Physical Realm in Cuda right like this is all in West and once the witness is generated to go from weakness to proof that's a much simpler operations it's just sequence of additional multiplications and connecting them together uh so it doesn't have to implement evm stuff inside of the GPU program I believe um

to us um so are these circuits written by hand and how do you verify them so yes they are written by hand we use the Halo 2 crate and when the strategy to write circuits is we or maybe it's a big community and where they are written first a second Builder or constraint Builder right that's that has a lot of helper functions but as it has a helper function for a push to stack let's say

when in the circuit Builder and then the implementation of code they can reuse that [Music] um so it's still regular like software engineering work when you do not repeat yourself and so on and split everything into components and uh how do you verify it so that's a big process right uh of what it's so so that's uh mostly my job uh and other people's and we are so involved with um uh basically or uh security firms out there um

yeah so it's just a big process it's it's a whole new scale actually of audits um because it's so many pieces uh to verify so it's going to be lots of auditor themes uh one after the viewers with the timeline of that so can you just give a couple examples of tasks that you do to to verify them about to verify

yeah just how do you say for example what would be an obvious example of something going wrong [Music] uh let's see I don't even have this I have 14 slides about that and each one has like five bullet points of things that can go wrong okay so for example a wrong like incorrect wiring would be an example yeah for for example uh you when you program it you

know to explain so when you program this you need weakness so witness that would be like one of those steps let's say right let's say my task is I have program counter here and I have a program counter on the next one and I want to check that they are like a PC Plus One The Next Step and so that's two cells oh witness and everywhere this PC and this PC is also involved in other things that is fetching the bicycle right so I need to make sure that it is the same variable this PC that does by code and the next step right

but when you program it it's very easy to write a function but some helper function and it's very easy to use because it allocates everything it needs it's important that someone else got another function which also allocates new cells and so you might have this problem but you end up with two different cells for with the PC variable and they were supposed to be the same right so you have to make sure that you really use that everything is connected correctly or that you something must be equal we don't forget to say it's equal or use the same you can forget the range checks as well

because let's say one of those things needs to be a Boolean needs to be zero one does it forgets or it needs to be a byte zero to 56 uh uh don't forget if you're going to check um best determinism as I mentioned like we want the entire thing to be deterministic so you guys a way that you could take two paths and they will both be values that's not good uh hey I just want to jump on real quick because we only have a few minutes left in the hour um there are there were a few questions that were were asked sort of back at the beginning of the session I don't know if

you want me to ask those or if you wanna yeah yeah go for it okay so one was uh how do you see the efficiency of scroll ZK evm changed once each sharding is implemented so we once once you got all the cooler things like really optimize and fast and it's cheap to make hooves uh versus the size of a block so it's cheap per transaction upper gas when the bottleneck is storing the transaction on maintenance so it's going with transaction data it's much

cheaper than executing transactions but it still has a cost and I believe this if sharding is about data right it's about data sharpening uh yes and that will make this cheaper so you can have like very large War apps right um so if I may just add a quick question uh you you might have heard of eip4844 um that uh basically it's a way yeah it's a way to reduce the cost because I see you're pushing a lot of data I mean yeah yeah uh kind of kind of the same question but

with uh with eip4844 namely uh yeah basically do you need this or do you not miss this yes it's an intermedi step to data shots right yeah yeah so yes uh same uh making the transaction data cheaper because uh we we need data to be available right another question was what can a community do to improve scroll [Music] what can a community do um so go to it

perfect so you can try it so we have a that's very useful try it do I use Smart contracts and tell us if it works if you metamask Works in if so testing right generic testing that's great then give a feedback about how reliable that is uh and you can join us also to work on it uh yeah one other question was what what does day-to-day work look like or what does the day-to-day work as a security engineer on an L2 project look like

so that's uh reading a lot of code reading code making checklists and uh third is communicating so I explained a lot of mistakes that happen or could happen or yes I make lists of things to be careful about like [Music] one last one very big lists there was one last one that was actually the first one and it's very high level

what do you think is important for this project to survive for a long time an ecosystem or with all the device and that's what's great about the the war ups with the evm and contract compatibilities that you can deploy a lot of ecosystem that can that can be composed right this is what ethereum is all about and also of ZK olaps that you can compose with different kind of defy with the different nfts and and all that

right so so you need all those projects to be you want to be able to combine them all on the other and also give us the most important and also maybe all those GPU miners if they realize they can finally use those gpus again that might make it yeah to make proofs yeah fantastic thank you both thank you thank you for this great uh presentation and workshop all about scroll all right thanks for having us so thank you yeah cheers bye [Music]