Ansgar Dietrichs

It doesn't give you literally infinite throughput, but basically, right?

Like you can have whatever like length of computation you have, you can compress it down into a constant size proof, and then you can verify that with just very little compute.

So compute scaling, that's in a way the easiest one.

That's the one that you get very easily.

Now you look at the other two and you're saying, okay, how does it impact IO, right?

So historically, traditionally, when you execute an Ethereum block, what you do is you start executing, you do some compute.

At some point, you want to load some state.

Actually, already at the beginning of a transaction, you want to, you know, you need to load your account.

You need to load the account that you're calling into, that you're sending ETH to.

So you basically, you immediately need to go to disks, right?

So you have this intermixing of sometimes you go to disk, you load values, sometimes you do some compute, then you go to disk again.

It's like this, this intermixing.

One actual change to Ethereum that we're already doing before ZKVM, it's called block-level access list.

So it allows us to, it basically, it adds some annotations to a block of like, this is the data you'll need.

So actually what happens now is that you actually go to disk at the very beginning.

You bring all the data and then you can do the execution.

But you still have this element of having to go to disk both before the block and then again after the block to go and like be, okay, but what's, you know, like we have to update all the values and then we have to also like compute what is the new state root.

So how does it look with ZKVM?

Well, there's a few things that are fundamentally improved by ZKVM.

So the important part is that ZKVM basically already takes in as part of the claim.