David Schwartz & Jordi Baylina: Polygon zkEVM – From Circuits to Mainnet - Part 1 #486

Transcript

welcome to epicenter the show which talks about the Technologies projects and people driving decentralization and the blockchain revolution I am Frederica Antz and I'm here with my hair Roy today we're speaking with David Schwartz and Jody bylina the co-founders of polygons and heads behind um the polygon zkevm and we have so many questions it's going to be a very meaty episode but before we talk um with Jody and David about polygon let me tell you about our sponsor this week Omni is your new favorite multichain Mobile Wallet Omni supports more than 25 protocols so you can manage all of your assets in one place but what's really special about Omni is what you can do inside the wallet want to get Omni

allows you to get the best apis with zero fees and three Taps need to swap Omni Aggregates all major Bridges indexes so you can bridge and swap across all supported networks in one transaction directory in your wallet love nfts Omni offers the broadest nft support of any wallet so you can collect and manage your favorite nfts across all chains all in one place Omni truly is the easiest way to use web3 and it's fully self-custodial meaning you never have to trust anyone with your assets other than yourself and a support Ledger give Omni a try at omnidot app David and Jody it's uh it's such a pleasure to have you guys on the pleasure the pleasure resource uh thank you for inviting us we are very

happy to be here yeah thank you so much for coming us this is one of the podcasts you know when I when I started in blockchain this podcast already was there so that's that's a honor to be here too so that's thank you for for still being here thank you this is our 10th year so I think very few years have actually made it to 10 years in blockchain but uh yeah we're still around so Jody you also have a super long ethereum history so I remember you telling me that you kind of entered the scene right around um the entire the Dao situation and the hack and you kind of join the white hat hackers tell us about that

well that was a long time ago for me looks like prehistoric prehistorical times but this was my my introduction to blockchain so I was uh just learning very excited about ethereum at that point very excited about the Tao and discovering the community discovering the things that you could do in ethereum I was at that point I was writing uh uh liquid democracy smart contracts for The Vow but I learned a lot you know I mainly learn uh how this works on that time and then all the all the hack in the Lao happen uh I was one of the persons that checked more of the code and was very involved at that point so without I must without even realizing I just get involved in the white hacks and

and this was my baptism in in blockchain was very very you know very exciting times for me was it's a story you know I don't think it's the topic of this of this interview but it for me was like a movie you know we just being part of a movie and and you know white hackers the hackers try to attack the hacker the so forth the hard foreign yeah try by fire exactly I'm sure there's going to be a movie about this at some point uh so who do you think is going to be cast as

Jody who's gonna be what the closest who's going to be cast as you oh yeah I I don't know I don't know I don't know um David um what about you you have you are super difficult to Google by the way because you have a very common name and also the same same name as the Ripple CTO so um your background to me comes now comes to me as a complete surprise you can tell me anything and I believe it yeah no no I I I joined the space five years ago you only convinced me to to start together a project and identity and we are still working on it and more recently uh we just started the ckvm

before that it was a Hermes network uh we joined with polygon uh two years ago and it was like a big experience now we are working together in the cpvm I basically am leading the project in terms of execution the coordination of the team the follow-up and also the product side so Jordan is doing the magic and trying to make this happen in the enabling other aspect I'm in your boat so I also I also try to make things happen in every other respect and this is uh it's a very hard job so with with our respect to Jodi but uh yeah David don't don't understand yourself yeah so you guys co-founded um the Hamas Network at the time what what

were you setting out to do with it well we were just trying to scale um say a scale with blockchain so in this case was uh so the first the first version of Hermes was just an only payments uh system but was quite uh good on skills uh quite well and this was the Hermes one was a very good experience on there and from there we just realizing that the important was a scale ethereum and and we just focus on the ckvm since there the story is that so we were doing the the identity project so we were doing 993 project at that point and we were building a lot of zero knowledge

technology and a lot of the technology there so we at that point we realized that this technology was very useful also for scaling actually actually we were trying to build a kind of a roll-up for identity and say okay we can we can also do a roll-up for payments you know it's something that's interesting and uh to do and then we started to a kind of a proof of concept internally in uh side project inside the team and we realized that this work quite well and at some point we just decided to okay let's uh move gears and let's focus on this for uh for a while and and yeah that's when that's how we will hardness one yeah I would say that Hermes one was an amazing experience for us also to you

know make use of this CK technology Journey was one of the Pioneers in this field creating tools like circumstances that's how today are pretty common and very used across many teams 1.0 was payment Network only which was basically what we feel it was possible at that moment but this field has evolved a lot and I'm two years ago this this week KVM seem like um impossible and feasible other teams already said that because your approach was very ambitious you go from from the first step building a payment Network to the full let's say smart contract execution it seemed like

a big deal and uh we are super happy that today we are very close to launch a minute and everybody can see it as net so super exciting times also hard hard work behind this as you can imagine but the story is that we got there um by a lot of hard work and being ambitious and trusting that along the way we will find Solutions which we can spin a little bit more but it happens so very exciting times what is zke EDM ckbm is mainly a Skilling ethereum that means that zkbm is

that works exactly the same that the layer won't roll up they're exactly the same that ethereum but instead of running on a layer one or standard running in ethereum we are running in this layer two so it's a smart contract that emulates or that has this Chain by itself and we are just taking from layer one uh the consensus so the layer 2 does not include a consensus mechanism so we are leveraging on the layer one uh consensus mechanisms but we are building a new layer so a new system on top and the difference will be mainly it should be mainly the the the throughput the quantity of transactions does the network should accept and uh and

the price you know if you have more throughput then the price should go low yeah that's that that's the that's the the concept of the ZK ABN so it's evm is the ethereum virtual machine and the ZK is just we are emulating or we are running an ethereum virtual machine with zero knowledge in our roller that's mainly what it is that we are in the ckvm you are basically changing the trust model um we have this kind of Ledger tool execution uh let's say blockchain that's doing off-chain processing of ethereum like transactions but here instead of having a consensus protocol that

provides the security to the users we rely on The Ledger One Security to verify some kind of validity proofs that are created into this layer 2 and this layer this validity proves basically certified the users that the execution is correct according to the rules of ethereum or the rules that this BM has so the plural is the key let's say key element here because it's where all the trust you know of the users are deposit because the these blueberries or the CK circuits and forces the behavior of an airport if the network is behaving like according to the rules of ethereum then you get the proof otherwise you don't get the proof and this validity proof is kind of the

the new model of trust and this enables to compress in some way you get a lot of transactions that are proven by a succinct a small proof and this is where the scalability happens cool so in a in a typical layer one if I as a let's say I as a business want to be sure that the current Ledger is correct I have to run all of the transactions from uh from basically zero or the first instant to now verify that all of the transactions were correct and the accounting was correct and then I come to the current state and then I know that all the current state is correct

in this case what what yes the essence of what you are developing is that you will have a network where the network and all you can almost imagine the network as emitting enough certificates or proves uh which attest to the fact that some current state so the state that has been reached currently came as a result of you know correct accounting done in history and that correct accounting is certified by by these zero knowledge rules so I only need to uh process the certificates or the proofs which is much lighter than

actually running all of the transactions in the history of that Network exactly you explain it perfectly is it is it you know when when ethereum launched um there was the ethereum network and then there there is was like ethereum virtual machine and of course ethereum Network used the ethereum virtual machine but the ethereum virtual machine is kind of like an abstract concept really that can that was adopted by other networks right so is it similar in your case as well that there is a ZK evm Network that you're trying to build but there's also a ZKA evm like some kind of abstract

computational machine that you're building that can also be in the future used by other networks is that right not exactly I would say so what we are doing here is so from conceptually we're just copying emulating the IBM so we are just so what we are just so that what we are trying to solve is okay is you are doing the same in one thing and you are just doing a DVM so from the user perspective there is nothing nothing else if we check internally and we check the architecture that we are using to build that it's a like a kind of a double layer so there is so we have like a soup processor uh we have a kind of a suit processor that's uh well it's executing

with a specific language and we are emulating or we are just uh running the evm so the program that emulates the VM on top of this ZK processor in the bottom but this is I would say this is more uh so it's more than in the architectural part it's not in the it's not the final it's not the final uh purpose it's not it's not it's not the finally there this this is a private thing it's uh it's a specific process processor to do a specific job in this case is emulate the the the the the ABM well yeah here there is uh we could have other processors here and but but this is not a public process it's not a it's not we don't plan to to

people run programs for this processor users to write for this processor so we just uh it's a specific solution for having a ZK ebm CK roll up yeah basically the mission of polygon is scaling ethereum to bring a case this video mainstream and this is what we are trying to build uh mimic uh essentially what ethereum is doing so your service doesn't have any friction the same thing we did with the POs so that we want to replicate this kind of experience for users but with the security of ethereum because we will be deploying a layer 2. but we are

basically following ethereum with ethereum introducing new changes we will catch up as you all know there's different kinds of CK Road there's also optimistic role let's roll ups let's not talk about those for now so let's just concentrate on ZK Roll-Ups and basically if you zoom out and kind of explain and explain in like normal people terms how they differ my take on what the zkevm is would be um that the zkevm just transposes every op code um that the evm has into a ZK version of that opcode and that means it becomes trivial to kind of transpose any kind of

smart contract that you already have um into the the smart contract that can be compiled by the zkevm because it just replace every op code that you've used with um the equivalent um of the zkebm is that high level understanding correct yeah but it's it's not even that there is not even that transposition you just can take a smart contract you don't even have to recompile and you just deploy you you just deploy this smart contract in the zkbm you don't need to have special compilers you don't need to have a special version of metamask you don't need to have a special version of our hat or you don't need to translate any of code in other report you are just

taking uh ethereum transactions you are just taking ethereum smart contracture you're just using the same way that you are using ethereum you are using the you are just you just plug metamask in to the zkvm and and you deploy there so it's it's it's as easy as at CCS as direct as that and this is the magic is this easy this easiness uh on that this is the idea of as a KVM I mean that that that sounds um uh I I don't want to say straightforward but it seems like a very natural approach right seeing that you already have the evm you already said like 10 minutes or so ago um that it was through that this

approach would be too hard that it was inconceivable that this could be built within like a reasonable time state scale what were the limits are the challenges I mean I think we surpassed the limit yeah maybe before that we can go back to the previous question is uh there are different approaches to ckbm I don't think we can just say all are the same um vitalik explained this very well in ambition post or maybe it was like yeah last year but there are different times types we are targeting evm equivalence which was basically what Jordy was defining so no friction for users you are deploying the same thing that you do

in ethereum in our modern uh there are other approaches that were let's say started probably before we did like suitcasing or Star War they were doing kind of uh building a VM which was more CK friendly uh which is basically uh the internals of the of the engine of the CK Bluebird is more simplified let's say they are not supporting the same set of codes that we want to to deliver so you the users need to transform The Code by recompiling in some way or even in this approach of a starboard that you need to use a new language or they also they have some kind of compilers and this

kind of things but uh the when we said it was difficult I mean that these teams started before and they felt this was the the approach that was visible at the tournament to build uh let's say BM that was CK friendly uh in some way they felt that in intensive is is like this in the computation of proofs is a very intensive calculation and you need to prepare this correlated so so you can be efficient so they were following kind of more simple strategies that paid let's say immediatically better outcome in terms of feasibility of calculation for for this kind of processing of transactions

and we were following our approach which was more ambitious that basically it was ABM equivalence that and anyone could use ethereum as we have today but it seemed more complex the internals were more complex and in fact they are probably uh since we are all the complexity we are avoiding for users we are putting in inside of the system that's the general concept uh so this is the reason why we are so so happy that we are able to deliver this uh so soon and it works because it seemed like a impossible two years ago and today we are in a position that we are super happy to be

can you give us an idea of the challenges that kind of you needed to that you were up against in kind of building this more complex technology that kind of abstracts um some of the complexities or most of the complexities away from the user you can enumerate some of them but for example uh if you want ABM for example you want that the signatures are the same way so you need to use the cdsa the same way that ethereum does so that means that you need to do a circuit or you need to do a zero knowledge circuit that validates uh normal ethereum signators or Ketch acts you know you need to also have a circuit that's that emulates sketch acts these are not so is cdsa or ketchag is not something it's

not something that's uh prepared for doing efficiently in the ZK so we we have to do uh invent and do things uh just to to optimize and to do that that things faster but other more I would say other more trivial let me tell you some other more trivial things for example the transactions in ethereum are in code with rlp okay so you need we need another P decoder inside the inside the inside the proverb okay and this is it's it's a stupid if you do it the normal processor but doing in the in IBM in a in a CK circuit that's much it's it's harder than that but I mean a lot of

things have you know for example the the AVM has this memory alignment you know it's a byte related but then you read 256 words or 256 arithmetics uh you need to to to deal with that in an efficient in an efficient way um it's I would say is uh during a year and a half that we have been working for this project almost two years right now uh it has been like one two challenge per per week uh at least and and and and solving you know that has missed a huge uh team effort to to to to to solve for this uh engineering challenges that uh compose the ckvm do you guys know that it's always

possible to kind of transpose this I mean is there a mathematical proof that you can kind of take any smart contract and kind of transpose it into you know an equivalency case circuit uh I mean did you know it was an engineering challenge uh was it also questionable whether it was doable at all possible so mathematically speaking possible it is so there is no no restriction for not being the question is more how efficient uh this is is the just as as a as a number as just as I I tell you one one and like that one one one thing from when we started the the system we were discussing with a bit and

and we were talking about uh proving computation we were talking in we were measuring the first estimations we're measuring in in hours and the computation power where where we're measuring with uh lots of servers you know when we were talking about data centers at some point uh uh on that at this point building uh a proof of 10 million gas it takes less than two minutes uh this has been the Improvement of this but the the challenge was not in the single server yeah so that's that's so that's that has been the the Improvement that we made in these two years this has been mainly a fight about optimization

optimization and here is all the all the possible things that you can optimize you know from the mathematical perspective the engineering perspective of the way you do it the programming perspective if you are using Vector backer instructions assembly uh we trade also with gpus we trade with so it's like um like taking account the cash but taking also in account the different protocols we went to the Goldilocks this is one of the the things that make us improve a lot you know it's it's a lot a lot of things and a lot of improvements and a lot of small details that when you're putting together is when you can have these times but it's not this is a result of it's not a result of a simple thing it's a result of hundreds of uh

engineering decisions and you know and Engineering the details that when you put them together and you were just fine-tuning all of them is when you are getting this when you are getting these numbers but we started you know the first expectations were were huge we were in the limit of uh feasibility when we started okay so literally gradient hard work and you know kind of optimizing like every single thing that you can optimize for exactly that's that's been that's been my job uh that actually the job for for the team for the last two years how big is me how many people do you have on the team and what what are their backgrounds are they mathematicians or cryptographers

computer scientists all of them we have a team of Engineers at work with Jordan approver with the CK part actually five six people we have uh something working in the in the contracts protocol like four people we have uh like seven people working in the client of the network but we as a polygon we have uh contributions for many other teams polygon teams we have a a big family you're working on this with different profiles from cryptographers

to to Engineers but on Project I would Define as early was saying before it was Julie was doing a lot of research in the CK and the feasibility feasibility of this implementation we have clear ideas from a long time ago probably one year and a half but it has been one year and a half of improvements of optimizations and we are still working on it so basically the team the team has been composed by engineers and they are doing an amazing great job we have some mathematicians but this is an engineering project Maybe I'm trying to understand the difference between the approach zkvm is taking versus like something like what

stockware is taking with Cairo land and what I understand is that ultimately any kind of uh virtual machine is is essentially defines a set of operations that it can do these might be operations like add subtract multiply right like simple operations all of us understand but in the ethereum machines case there are also complex operations which are like take a hash of certain data or verify a signature or there is something which is called the jump instruction which which does something which basically allows for Loops to exist in

the ethereum virtual machine so the ethereum virtual machine has a set of operations that were chosen in the history of development of the ethereum virtual machine maybe 2014 and um and the difference between your approach as as as polygon versus something like stock where it is you're saying okay ethereum virtual machine defines these I don't know 128 or 150 set of op codes and we are going to take these op codes and we are going to develop a system that can emit zero knowledge proofs for a chain of operations that are that are using these op codes

whereas star player is saying that actually let's define a different set of op codes which are not exactly the same as that used in the evm and let's define those OP codes in a way that it becomes easy to write zero knowledge proofs uh for them but it's a different set of op codes and because now it's a different set of op codes ultimately they need a different programming language Cairo Lang to also run on top of their virtual machine whereas in your case because the set of op codes is the same as ethereum virtual machine developers will be able to write in solidity or Piper or any of these languages that they are used to right is

that kind of English course exactly yeah exactly that's uh that's that's a different approach the approach you you explain that is a starboard approach or even polygon zero for example has started also these uh well no sorry a polygon might then started this approaches okay let's build a let's build like a new new new virtual machine this is one approach uh there is another approach that for example the one that was used by polygon 0 or that was is used for for MATA maps for example that's okay let's try to be compatible but not compatible at top code level but compatible at language level so let's

take solidity and then you just transpile it to uh our own virtual machine okay or to this is another approach it was probably was the best approach uh you could choose uh two two years ago or three years ago when was started because you know was doing an OP code compatible IBM compatible had a lot of challenges in there so this was a another approach and then the third approach that is is the one that's okay let's let's not do not be compatible at language level but be compatible at all levels so that means that this is the one that's closer to ethereum and this is uh this is the approach that uh the approach that we took or from a scroll people also took

this approach into the result for other teams that took this approach there are different ways different ways to approach the same problem uh with uh with different implications for the end users you know the uh or approaches is theoretically it should be less efficient but more but more uh easy for the user what's interesting and here is the maybe the main thing is that uh it should be more it should be less efficient but actually it's even much more efficient than the other the other systems and here is I think here we are very uh because you know all the other all these improvements that we made were

not like specific for what we were doing is very specific to the how we build relapse itself so the optimizations that we make I think that this this creates us a lot of a big difference between the competitors because we have the best of awards we have the easiness for the for the users and at the same time we are very very very uh very optimal even more optimal but we don't have the numbers because you know the competitors we don't we don't they never publish approver that yeah it's difficult to work hard but but I mean uh um it looks like that we are much much more optimal that uh the the competitors but this is actually quite a little bit

counter intuitive that it should be the case because normally in the history of programming and software engineering you you have languages that are like closer to English easier to write like a JavaScript or python and then you have languages that are much harder to learn and harder to write like like a c the advantage that the usually the harder to write thing gives is that it is efficient and uses less computational resources and disadvantage of JavaScript basically use more computational resource but I mean one possible explanation would be that the competitors just haven't seen the optimization optimization to its end right so basically if we kind of put

jardi uh now on you know the competitors and say Jordy please optimize this do you think you could get it to a more efficient Point than where CK ebm currently is absolutely yeah I'm sure but no yeah because it's uh it's a lot of it's a lot of things for example I don't know how we are writing a storage this is not related this is how we are Computing the storage this is not related to uh being evm compatible or not compatible it's just how you structure the restoration how you uh how you how you create how you define the storage in a way that's efficient okay this is a lot of knowledge and testing and and and and improvements in in how we are writing

the story and this is this can be used in any in any so in in any of these architectures on that and this is an improvement that we made uh uh on that but it's not but let's let's talk about the arithmetic optimizations again this is transversal so this is not like a specific uh to ethereum or we are Computing the cdsa well if you want to if your system wants to have a CDS size then this is hard and we solve that so if you see all these improvements that we make and we put them all together so all these can be used in other systems that don't necessarily be uh ethereum compatible we created for ethereum because this was what what was our goal was was or specifications as engineering

but all this work that we make it can be used in any most of the works can be used in other projects in in in transversary and and this is the cool thing of uh open sourcing the the code is like everything is in there so all the knowledge is in there of course it takes it's time to be absorbed and to be understood and things but there is a lot of knowledge that's in there that I'm sure that uh other projects will will use it in the in the ethereum space and outside ethereum uh space for sure it's a lot of Innovations but still engineering yeah it's like the cool thing of engineering is that you can advance

there is like two things one is in the balance and and when in engineering sometimes you need to choose between a balance that's what you think or the good engineering is when you don't need to be in this balance when you are advancing in both fronts and this is the real progress when you are creating things that are doing better no matter what the the variable that you are measuring um like you mentioned okay in this space today all like three approaches exist right so one is okay let's define a new virtual machine downside it will be a new language which is like Cairo Lang and let's try to build CK GK two words that can do General computation that way you have

the approach where okay you have the evm let's keep the evm upward compatible and then let's build ZK proving systems on top of evm that's the second approach there can be something intermediate which is like okay let's build a virtual machine which is similar to the ebm but not exactly the same but still in in that kind of virtual machine you will still be able to write infinity right that that kind of approach also exists so this is happening because of course much of the intellectual energy of the ZK theme is going after these crypto problems but will it be the

case that in the future there's a zero knowledge proving system for the jvm Java virtual machine as as well we think in the future there will be a ZK prover system for uh a language like go or rust uh as well or or is there something fundamentally hard about buildings for jvm and golang definitively well you need to distinguish between the the low level of codes and the high level languages okay so in general there are some intermediate representations like VM or some Yule or you know other intermediate representations that I mean that are in the middle but uh uh the the interesting

thing is that what we did is we created a processor that's equivalent to the AVM the same way that we did a processor that's equivalent to the evm we could easily write a processor that's equivalent to wasm or that's equivalent to a risk 5 or equivalent to uh um you know to arm uh processor uh somehow and then you can reuse the stack actually for example there is a very interesting project it's called re-zero that it's like it's always five emulation okay and they are just you know you can have a program that's writing for risk five you can write that in rust or in C and you compile and then you compile for for risk five so you are using all the other compiling stack and then you are running

there these things are you you can definitely do it actually we did that for the ABM for a specific processor this ethereum processor but the same way that we did for a processor we can do it for any other any other uh processor this of course here again is how efficient it is uh but it's definitively possible and this is the the way it's uh I think this is the way it's going the the the you know the ZK space is so every time writing ZK circuits is it's going to be is every time that the thing is going to be written more in C

or in rust or in high level language uh that in or even solidity that in that in low level circuits we know with circum or or things like that there or Noir or even you know this is like a I would say this is kind of bright so uh doing electronics and the other is just doing real programs so until now the ZK was about doing Electronics we were just doing uh some gates and pulling them together and writing you know just doing some electronics that do maybe a specific calculator or do something that's a specific now we are creating processors we are start creating processors and then you are not going to you are you will not need to write Electronics you will just read programs

for these processors and this is how is how is how is evolving okay and as the KVM is a clear milestone in in that direction all these technology to build this processor that you're just describing is also a contribution we have in the repositories of the project uh all of this tooling is open source um also as early was saying before we had this kind of uh big work of optimization to build our system like visible system to to prove ethereum uh all these ideas are just out there and probably other teams will just reuse on

catch up which is fine perfectly fine for us uh the the point is that we get from the situation that we had initially estimating that the centers to prove this this protocol we have now a single server and the cost we have today they are so so irrelevant that we feel that this is going to become kind of a super interesting technology many in many lines so um the optimizations we have implemented and the ones we have in the pipeline and the bugle tool to continue doing I feel uh very very soon there will be more processors running on CK and we are super happy about these two so basically the entire development is a

little bit reminiscent of um the history of Chip design right so basically if you think back to like the I mean not literally think back because none of us are old enough to think back that far but basically if you look at how everything kind of evolved we had like um these integrated circuits and in the beginning the integrated circuits they always had one very particular um function the program was kind of hard-coded into the chip itself and only with um the uh the um Advent of general purpose CPUs that could kind of do anything that kind of opened up this entire space for building in software kind of in order to

kind of make a program you no longer had to build a new chip circuit you could just kind of reprogram a general purpose one you already had um and obviously it's not optimized for any particular thing but it still works well enough that you can kind of use it and kind of the advantage the advantages you gain and kind of speed and execution and agileness and so on those kind of trump the fact that it's not optimized for any one particular thing and if you look at kind of how this entire space has evolved like in the last probably like decade or so high-end tech companies have actually

started building um single purpose chips again right I mean so basically the entire GPU thing that kind of I mean that's I mean that obviously that was kind of for gaming and shaders and whatever and kind of this has been taken over by the AI crowd to a large extent but even kind of if you if you look at CPUs um for instance Apple Now Designs its own chips and I mean this is just so it can optimize for very specific things Samsung does the same thing and I think other high-end tech companies do the same do you actually see this happening in the zero knowledge space as well or do you think this will happen

that there will be certain sets of applications that will run on very specialized ZK infrastructure that is not general purpose but purpose built for this particular so things I'm thinking about are for instance you said that one of the very first things he built was payments protocol because obviously payments are simple it's kind of it's kind of like you could do it on uh you know State channels or something it's pretty that you don't need like a generalized state or anything don't need you know smart contract computation um do you think we will see the rise of um you know ZK um machines that can only do very that are optimized for very specific sets of

applications I mean uh definitively yes but uh I think you explain it very very good uh so but we are we we can say that we're in the 60s right now in the processor okay so and you are talking the gpus that's in the 2000s at least uh the thing so we are still so we are still we right now we have a lot of uh specific circuits but it's not because we want to optimize them because sometimes it's the only way to do it it's like in the 60s so the real you want to do a calculator and you either do it uh an electronic or is impossible you cannot do a processor

okay so here right now for example in the stocks I could I I can compare start with the gate arrays okay so it's like okay it's not that you are writing processor we have a gate array so you can have uh uh you can you can write you know just uh Hardware in in Gatorade systems and there is a kind of a compiler and and puts that okay so this is a stark and pill and all this technology we create okay we created um we create a processor but you know the processors is that we are very easily in the technology still so the processors that we are building right now they cannot do things so you for example then the quantity of clocks that you can run in a proof is not that much so it's like we're running uh a million clocks or

something like that okay a million you know a million clocks how many things how much computation you can do in 8 million clocks if you have an eight megahertz processor this is just one second of processor in a proof okay and and right now our 34 gigahertz so just to just to to see where we are in the processors in the processor setup so when you have this you know these limitations in the electronics because we still have this uh theoretical limitations in this uh in the zero space we are much better that uh three years ago but we still have we are starting to do this and that means that you need to do things that are specific for example if you are trying to build a zkbm with a

normal grease zero processor for this five processor uh with uh the thing that drives you will you will the problem is that the you can do it but the program will be too complex and will not fit uh will not fit well you know it's like you are doing a huge program and you are trying to run in a very very old processor it's like you are trying you're building um I don't know a Linux operating system and you are trying to run it in a z80 uh processor you know it is I mean it's just not some feed you know you need more memory you need more uh you need to secure more things so we are in in this in this stage still so okay we start having processors right now writing processors is is possible this

processor are doing amazing things if we compare of what we had until the point but it's still a long long run to do it's like I'm going to a generic you know this commoditization of of the of the processing power we are not there yet okay and so at this point I would say yes it's going to be it's still going to be a specific processors but it's not but but that's because you know if you want to have a lot of payments you it's difficult to do it in a normal processor so we probably will see this face now that everything goes to a generic and maybe at some point you need some specific but we need to wait in the in the kind of the processor we need to write like 40 years okay so for that to happen

maybe like seven crypto years I'll share my opinion besides technology there's the we are in a very let's say intense exploration phase probably will need more stable use cases to make this uh you know specific purpose uh secrets they may be worth it because uh if the generic as you describe this wave of genetic processors will happen I probably will be covering a lot of use cases and will have flexibility for the apps so probably with somebody else being stable it will make sense again to to come to this application specific circuits I want to cover one final topic regarding

um the zkevm itself and that's kind of audits so basically if you look at the different approaches that we have for um zero knowledge roll ups um what are the implications for Audits and how much basically you you said that a lot of the complexity you kind of abstract away from the user does this also mean that um you abstract a lot of the auditing requirements away from the user because I mean all of us most of us don't read bytecode maybe or you do but um probably no one in the entire world reads CK uh circuit byte code I mean this is just how do you audit this and how how does

this compare between the ZK evm and the other CK rollups look at the the the nice nice thing of of of of this is that uh or approach of this architectural approach is based on layers you explain it very well we have the hardware layer you know we just uh we have the but we call it the pill then we have the processor then we have the ROM and then we have the program that's so the so we have the problem the ROM and this is our like different layers and that this is this has been very good also for developing because we can have like different uh parallel teams some of them doing Hardware so others doing software you know just so you can see it that way of course it's not Hardware is the solid meditation uh on these things

but this is again happens with them with the audits in the audience you can assume that the low layer is okay and then you are just checking these basic layers so this allows us also to structure the the the uh and divide and conquer uh from the audit uh from the audit front we have been auditing the system for the last three months right now with different uh themes uh different Auditors that they went really deep uh I'm even very surprised of how deep this auditor themes uh just uh went there but again said that um it's a new you know it's a new um it's a new technology it's a new stack and there is a lot of code that

needs to be checked because you need to check the hardware the software I mean check out the pieces and if there is just a single a single piece that goes wrong you know everything can goes wrong also again said that we are also putting the the measures in the smart contract level in the higher level so that if there is something wrong in this proverb system we can fix it or or at least the users don't don't lose phones okay and this is a here is a would say a deployment or security technology that's uh put on that without uh losing the centralization or without losing too much centralization on that it's a

balance here but it's it's it's important and it's also important that these systems to start and and see how they work and and see in real life in real in the real world how their performance and the issues that may happen and so on but this is this has been the or the the the the work of the team for the last three months yes we are doing the audits in our system um but the advantage of our approach is that the users they don't need to realize their applications then using the same smart contracts and Technology they are running on ethereum or polygon POS or other chains uh so one approach

is kind of clean for them and there's no transformation of smart contracts anything so users are let's say not a gliding any of it one final questions last verification so in the early days of zero knowledge proving we had systems that required trusted setups the most famous of which was probably Z cash where there was a trusted setup ceremony I think 30 or 40 people came together generated some Randomness together and you had to trust at least one of these 30 or 40 people would destroy their part of the randomness for the system to be

secure first one was nine the first the first one was was nine percent so first one was nine persons okay and the second one I think was like 84 or something like that before okay so you have to trust one person in nine to behave correctly the first one and one person 84 do we have correctly in the second one is there anything like that in your system uh let's see uh yes and no okay so uh so we are planning we are planning to to put the the so that it's uh flunk so the last the last part of the proverb so well first so all the other program is based on historics okay it starts on required to set up at all okay and this

is like 95 of the proof there is a last stage in the program so I said that when we convert the Stark into a snark okay so here is just a normal circuit silicon program and here we can use either uh we have three options here we can use grow 16 okay uh we probably we're gonna try to run with uh we run with flonk okay we are pending because flunk is very new it's a very new protocol and we are running uh an audit uh on the implementation of flank and on flog itself so that we are sure that this is correct okay if there is nothing Exchange in the audit and we see that everything is okay we are gonna run it

in we are gonna put it in flock if there is something we have a kind of a backup plan which is run it in growth system okay let me explain you uh what are the difference okay uh uh uh growth so plan can flunk they require what's called a universal setup Universal process setup okay that means it's a ceremony that's run once and uh anybody and and then you can use it in any circuit on that that's why it's called Universal this ceremony for example in ethereum it's a has been a ceremony that there is more than 100 persons uh country more than 100 contributions and very trusted people here which are from the Vitality battery

life so you can see the list which is like a lot of trusted persons and it is like a sick you know it's in Hermes I think was like something like 70 and currently I think it's something like 100 you can you can you you can check it because it's a public it's a it's a it's a public Ceremony this is I would say this is square except that this ceremony is okay the problem is that growth 16 requires uh a specific ceremony so for for the edge circuit so every time you do an application you need to run a ceremony you need to run a trusted setup and this is a little bit annoying and this is I mean this is not it's a pain running these ceremonies so our plan here is we will try to run with flunk if

everything works with flung is flunk and we will use this Universal this Universal ceremony that's already run from the community uh it's the same one uh so and if if we have some issue here maybe we we step back to to grow system maybe we'll run a small you know a small ceremony with some trusted with Auditors and internal people and maybe some members of the community but a small ceremony because it's going to be a temporary ceremos it's going to be a temporary ceremonial until we fix or we change to flonk or plonk uh in case it doesn't it doesn't work so this is a little bit like I like avaka plant but the idea is to go to to

to to flonk which is uh Universal ceremony and also the good thing of flunk is that the verification cost is exactly the same or it's very similar to the grocery so we have the best of upwards the only problem of flunk is that the proving time is a little longer that it's uh but it's just the last stage so it's not that much and it's okay for us to spend this extra time so this is the this is the yeah this is the the thing