RISC Zero Zeth: a type 0 zkEVM and what proving an Ethereum block costs
Thread1,159 words
Explains Zeth, built on RISC Zero's zkVM by reusing reth and revm to prove entire Ethereum blocks, and why RISC Zero calls it type 0. Benchmark: block 17735424 (182 txs, 3.4B cycles) proven on 64 GPUs in 50 minutes for about $21.72.
Key claims
Block 17735424 had 182 transactions, 3242 segments and about 3.4B cycles
End-to-end proof on 64 g5.xlarge nodes took 50 minutes at about $21.72
With 50x more workers it would take about 42 seconds
0/ @RiscZero is a leading ZK project that is building a general purpose zkVM that is able to prove any computation & provide almost instant verification.
Recently, @RiscZero announced Zeth or what they refer to as the first type 0 zkEVM.
A 🧵 on Zeth & why it matters (0/47) 👇
1/ This 🧵 will cover:
📚 Introduction (Post 2)
⚙️ Technical Foundation (3-10)
🖥 zkEVM vs. zkVM (11-16)
🌟 Why Zeth is a Type 0 zkEVM (17-18)
📊 Zeth Performance (19-35)
🚀 The Road ahead for Ethereum with Zeth (36-38)
🔍 Conclusion (39-47)
2/ 📚 Introduction
Zeth is fully built on the @RiscZero zkVM and is written in Rust.
Overall, Zeth provides a performant, upgradable, and scalable way for developers to ZK prove any #Ethereum block.
It can support #zkEVM rollups or ZK Bridges, among other ZK use cases.
3/ ⚙️ Technical Foundation
Zeth can prove all aspects of #Ethereum, from every EVM opcode and EIP to the block construction itself.
@RiscZero is able to accomplish this because Zeth was built by reusing major parts of reth and revm on top of the RISC Zero #zkVM.
4/ Reth (short for Rust Ethereum) is a new #Ethereum full node implementation focused on user-friendliness, modularity, scalability & efficiency
Reth is an Execution Layer (EL) and is compatible with all Ethereum Consensus Layer (CL) implementations that support the Engine API.
5/ For performance, Zeth takes advantage of @RiscZero's accelerator circuit for ECDSA signature verification, as well as continuations.
6/ Continuations are a novel feature of the @RiscZero ZK framework that makes it easy to quickly prove large computations using clusters of GPUs working in parallel (using either nVidia CUDA or Apple Metal).
7/ Continuations are easy to use: The feature is transparently provided to all guest programs running in the #zkVM, abstracting the need to make any changes to the codebase. But more on this later on.
8/ Zeth is able to cheaply generate a #ZK proof of the validity an Ethereum block within minutes.
This makes it possible to prove that a given #Ethereum block is valid (i.e., is the result of applying the given list of transactions to the parent block).
9/ This is because Zeth does all of the work needed to construct a new block from within the #zkVM.
Running this process within the zkVM, this results in a #ZK proof that the new block is valid.
10/ Leveraging the #Bonsai proving service enables Zeth to cheaply generate these proofs in minutes.
And with support for on-chain verification, these proofs can also be cheaply verified on-chain (more on this later).
11/ 🖥 zkEVM vs. zkVM
I will add some context here to explain the difference between zkEVM and #zkVM.
The term #zkEVM is used to describe software that runs a smart contract on the EVM bytecode engine and generates a receipt for a particular computation (or transaction).
12/ This software can usually prove that two or more receipts are valid and generate another receipt.
By using this mechanism, #zkEVMs can run many transactions and represent it using a single receipt and this is referred to as a “rollup”.
13/ Rather than doing all computations on-chain, projects written in Solidity can use #zkEVMs to scale transactions by posting a single receipt on the blockchain to represent many transactions that happen off-chain.
14/ A zero-knowledge virtual machine (zkVM) is different.
The difference between the two is that a “VM”, which stands for “virtual machine”, is more general than the #EVM (a specific application).
15/ On the #zkVM, you can run just about any software that runs on a computer rather than anything that can run on Ethereum.
More specifically, @RiscZero is building a zkVM based on the RISC V instruction set that supports programming languages beyond Solidity (e.g. Rust).
16/ Zeth is one example of a Rust program that runs on @RiscZero’s zkVM.
For more on @RiscZero's zkVM, check my thread below! 👇
x.com/expctchaos/status/1643342685250682880
17/ 🌟 Why Zeth is a Type 0 zkEVM
Because Zeth constructs standard #Ethereum blocks, it can be thought of as a Type 1 #zkEVM (see visualization below).
But it’s more than that.
As mentioned before, #Zeth was built using standard Rust crates.
18/ These are the same crates used by popular full nodes like Reth (see above).
Hence @RiscZero coined the term “Type 0” zkEVM, which they define as follows:
“Full protocol compatibility, together with significant code re-use.”
19/ 📊 Zeth Performance
To gather some basic performance data, @RiscZero spun up a test instance of #Bonsai with 64 GPU workers, which was subsequently used to prove block 17735424 (182 transactions, 3242 segments, or roughly 3.4B cycles) in Zeth.
20/ The @RiscZero zkVM implements a standard RISC-V processor.
Therefore, execution proceeds in cycles. Simple programs typically only require a few hundred thousand cycles to execute, but more complex programs can easily require several billion cycles.
21/ As the number of cycles increases, so does the time and memory required to generate that proof.
To improve scalability, @RiscZero splits the execution of these cycles into segments, typically representing around 1M cycles.
22/ These segments are distributed to a pool of workers.
The workers generate #ZK proofs for their given segments. Importantly, they are able to do this in parallel.
With enough workers, all of the segments can be proven in the time required to prove only 1 segment.
23/ Because the segments are small, this time is typically very short (a couple dozen seconds).
As the segment proofs are generated, they are “rolled up.”
Each #rollup operation takes a pair of sequential segment proofs & generates a new proof for the composition of segments.
24/ In the case of block 17735424, the executor ultimately split execution into 3242 segments, which is a lot of segments for a mere 64 GPUs.
25/ As such, each worker node had to generate 50 segment proofs, which took 35 minutes.
With 50x as many workers, this would have only required 42 seconds though.
26/ The test cluster described above was deployed to AWS.
It consisted of 64 g5.xlarge proving nodes and 1 m5zn.xlarge executor node. According to Amazon, each g5.xlarge node has:
🔹 1 GPU with 24 GiB of GPU memory
🔹 4 vCPUs with 16 GiB of memory
27/ With 64 deployed proving nodes, the proof required 50 minutes to generate (end-to-end).
Ignoring idle worker time, this results in a cost of $21.72. However, this is likely an over-estimate, as it assumes paying for idle workers.
28/ If the cost of idle workers is excluded (say, by shutting them down or having them do other work), the cost is roughly $19.61.
29/ The Zeth proof was subsequently verified on Sepolia using the RISC Zero Groth16 verifier.
This is a relatively new part of the @RiscZero stack, announced just last month. 👇
x.com/RiscZero/status/1688913077755092992
30/ It works by using #Bonsai to convert #zkVM’s native STARK proofs into an equivalent SNARK proof and submitting that proof to an on-chain SNARK verifier contract.
1 more image on X
What came next · since 08 Sep 2023
Show how the covered asset moved
This breakdown analyzes the project without making a call on the token, so price moves since publication are shown as market context.
Mentioned for context
Since then
Zero has written 13 more pieces on RISC Zero since this one.
Daily closes in USD from DefiLlama and Yahoo Finance. Only a bullish or bearish call in a thesis or market take is tracked; explainers, lists, maps and mentions are neutral context. Not financial advice.