Keynote: Brevis Pico VM: From Modularity to RTP by Michael Dong, Brevis

Transcript

Okay, up next we've got Michael from Brevis from modularity to real time proving. >> Uh well uh okay, thank you everyone for coming to my talk. Uh I'm Michael. I'm a founder and CEO of Brevis and uh today we're going to talk about like our journey of building uh brevis pick uh pickle VM and uh you know our approach to kind of uh building this kind of high performance uh ZKVM and push it to the real-time proving for Ethereum uh blocks. So uh you know but before we dive into the details of the ZKVM itself I just want to say that we are actually having this vision to build the infinite comput layer for web three and I know we're talking about how ZKVM can accelerate and change fundamentally how

Ethereum consensus work by replacing this kind of replicated computing method to kind of a proven verify based method. But I just want to say that today you can already get the benefit of verifiable computing and specifically uh you know from ZKVM by using this kind of a new design pattern your application level as well. You know whenever you encounter something that is super complex you don't want to run it on your smart contract you can just let the smart contract offload this kind of a computation in this offchain verifiable computing box and inside of this box which is now brevis can it can generate a zk proof to show that the computation is actually done correctly and then you know send the result back to the blockchain so the blockchain smart contract can verify the proof easily and

with extremely low latency so you can consume the result of this very complex computation you know as if this happen directly on chain, right? So this pattern really actually works. Uh there is like we are today already powering numerous different applications across all the different sectors in you know DAX yield protocols, stable tokens like liquid staking, lending, different chains, perpetual DAX and so on and so forth. So we're actually powering this kind of a whole ecosystem. So if you are a developer and actually building something in Ethereum ecosystem, you know, this kind of a new developer pattern development pattern is something that we want to bring to the table as well in addition to the kind of a improvement on the fundamental layer of the Ethereum execution uh engine. So what is inside this Bravis magic box?

Well, you know, we obviously have the Pico ZK VM which is where I'm going to actually start today. So Pico uh is a very moderate ZK VM with a risk five in ISA and a bunch of function level pre-ompiles. So you know we uh uh introduced we start to kind of building pickle around this time last year like around the divecon time and uh you know we uh you know so we spent about three months is to build the first version of pickle which is a CPU only and when we released it at the time uh we showed the state-of-the-art performance on the CPU proving and uh you know the next uh stuff is of course like a GPU acceleration uh on a single card and we also achieved the state of art performance on that you know and I'm

showing this kind of a very nice sequence graph that you can show uh you can see here that is showing that once we moved a lot of these kind of a heavy lifting parts in the entire proving pipeline to GPU the the the green thing is actually you know how how we actually utilize the GPU and we do very optimal kind of a coordination and scheduling between CPU and the GPU so you can see that even on a single card we're actually taking you know 100% utilization for this entire GPU proving therefore like we can actually achieve a very high performance uh uh you know uh even for like pro uh you know Ethereum blocks with 45minut guesses so you know the next step for us was to basically uh move from like a single GPU

construct to multiGPU and uh there we actually did two things one is kind of a looking at this as not only just like a single kind of a GPU scheduling problem but also look at how we can uh you know uh slightly modify the client side of the uh the program as well. So this is something that actually championed and pioneered by SP1 team that they also did uh they used a subblock and uh you know we actually you know uh followed the same kind of a practice there. Uh but first we actually did a lot of optimization on a multiGPU proving pipeline here that allows you to also kind of you know achieve extremely high performance even with just like a a single machine but you know running this on multiple GPUs. Um the key here again

is that we actually kind of do a lot of coordination between GPU and CPU and also the trace generation is entirely moved onto the GPU land. So now you know we uh take the next step to essentially have this kind of a capability to run uh you know different subblocks in different servers with like a parallel proving and uh as you can see that again uh you know um each block that right now is actually divided into seven sublocks and proved on seven GPU machines and then aggregated finally on the last one and this is like how the kind of the entire sequence uh um you know of the computation work. uh you know the thing that I want to point again is that you know you can see on the top there like the the entire kind

of GPU workload is very tightly uh you know arranged and therefore like we can achieve extremely high performance uh when they when we actually do this. So today uh Pico can uh achieve real time proving performance for Ethereum uh you know we released this last uh we released this in October and you know we can prove 99.6% 6% of a blocks under 12 seconds and 96.8% of blocks under 10 seconds. Uh and we basically publish the entire result and uh it is actually replicable uh and reproducible. We have like a entire GitHub repo that you can actually follow step-by-step instructions to set up your server cluster and reproduce our experimental result and performance result here. And

uh you know um so this is actually where we are hosting our servers. And uh you know um the interesting thing is that we actually so um this current version that we released called picle prism the biggest bottleneck there is uh the uh on the trace generation side uh sorry on the emulation side. So uh we actually did a lot of work recently on uh the uh you know emulation aspect of this and uh you know basically are able to achieve this kind of additional benefit and additional acceleration in our pickle prism v2. Uh unfortunately we didn't have time to actually ship the servers so we can actually show this uh you know live in today's demo. uh but we're going to have the server live next week uh to

show the performance of pickle person which is going to be another sort of performance uh in today's ZKVM land. Uh so how did we kind of be able to how do we able to kind of basically achieve all this uh in such a short period of time like you know within like one year we can build a ZK VM really from an idea to kind of a real-time proving well the trick here is that we actually build this entire ZK VM in a very very modular fashion from the very beginning so like we actually cleanly separate different components into risk five convert combine and compress sending bad and finally kind of you know put that into um the you know EVM uh verification if you need that kind of verification bit

capability on chain and in each of these component we actually make it a super modular and you know just like a lago. So we have a bunch of different things you can choose from. And then finally you can basically say okay even for fields you can choose baby bear or koala bear. Um for hash functions you can use Poseidon or catch or whatever. But you know once you kind of combine these different uh pieces together you actually get the concrete ZK VM that you that you're using. So that's something that you know we did and that this really benefited the entire performance optimization process and this is something that I want to share to you to you guys uh is that you

know this kind of a separation allows us to profile um to very detail that okay this part is actually taking this amount of time that part is actually taking this amount of time so we can quickly iterate and improve the performance um as we build out this entire system. So Pico is now open sourced. It is a uh you know under one of the the picle GPU is actually under BSL and it's actually security audit and then the performance reproducible and we're working on a formal verification for pickle as well. So now what I want to talk about is that we built this very general ZKVM that can you can use to basically prove any software you want. But you know just like any computer systems you know generity comes with a trade-off right.

So like we know that if you build very specialized circuits or very specialized system you'll get higher performance even if you lose kind of some generality. So for priv as a whole we want to operate at that point. We want to operate at the optimal point of the entire trade-off plane. So how do we do that? Well you know we do that again with modularity. So we treat the ZKVM that we have as a glue and then we are able to plug in a bunch of what do we call application level co-processor to address some very commonly seen use cases uh and accelerate that for further for example we have a co-processor called onching data zk co-processor that allows you to generate proof of

historical oning data data such as events states and transactions So the reason this kind of thing is very useful for many applications is because now you can allow your smart contract to actually see into the past and understand what is a user behavior in the past. For example, if you want to build user experience customization applications that allows you to differentiate a different user based on their past interaction with your system or with your application. You can now do that. This was something that was not possible but only made possible with uh our ziki data co-processor.

So you know we can clearly see the benefit of adding this kind of application level co-processor because once you have this and by the way this is not just a special circuit like a you know kind of a pre-ompile this this by itself is a GPU accelerated system as well to kind of you know have a parallel proving capability to generate individual data points say okay this is a this guy actually swapped this uh you know uh token from that token in the past and you know kind of be able to put that in into our ZKVM. So you can actually compute on these data points effectively.

So you know this is precisely the reason why I showed you the in the second slide you know Pico has and previous has so many different use cases touching so many different spaces because we use the ZKVM as a glue to power the infinite amount of computation in your smart contract applications. So some kind of a very simple example is that you can do dynamic fee on your exchanges. Now you know we're launching this with pancake swap sorry we're launching this with unis swap very soon that allows you to essentially do that dynamic fee based on your historical trading volume. You can generate a zk proof of your historical trading volume and gather trading fee discount. And we're also working on uh you know we're working with one very kind of

high-profile team to enable this kind of a ZK powered perpetual swap to have a centralized you know exchange user experience while it can actually settle all the matching engine match result back to the Ethereum layer 1 with Ethereum layer 1 level security and also with privacy orders and we recently also launched this new thing with uh poly market which is you know one the prediction market uh you know product in Ethereum community to allow Kaio to generate a proof of their mind share uh you know computation algorithm. So you can actually trade mind shares without trusting Kaido as a centralized and independent platform. So there are so many kind of different application you can do but I don't have time to talk go through each of them but my key point

here is that you know we are actually definitely scaling up the Ethereum layer one with ZKVM and ZK proof but on the application side my prediction is that 99% of the computation for blockchain application is actually going to happen offchain and verified hopefully by ZK proof. So with that uh I'm ready to take questions. All right. Thank you, Michael. Got a couple questions here. Y >> um any plans for auto pre-ompiles? Do they play well with your proof system? >> Uh yeah, we're we're definitely looking at that and uh you know, kind of a playing with that for sure. So, we know there are some very awesome teams that are working on that and uh yeah.

>> Okay. Uh last question. You're uh you're planning to do a 2x with Pico Prism V2. How many security bits are you targeting right now? >> Right now 100. and are you taking into consideration moving to 128 bits of provable security in your calculations? Yeah. So, uh, you know, there are several things we're looking at. You know, kind of on the short term, we're kind of doing a further optimization on the emulation process. Uh, but we are also looking at the things like Latis and, uh, you know, but in on in a longer term, we are actually as I mentioned in the morning like taking a very hard and long look at the GR based systems and you know, we have already done a bunch of things on that front and you know, kind of going to hopefully release something soon.

>> Excellent. >> Yeah. >> Thank you very much, Michael. >> Thank you.