feat(l2): initial state pruned trie in zkVM program

crates/l2/docs/README.md

@@ -6,9 +6,10 @@ For a high level overview of the L2:
 
 For more detailed documentation on each part of the system:
 
+- [Contracts](./contracts.md)
+- [Execution program](./program.md)
 - [Proposer](./proposer.md)
 - [Prover](./prover.md)
-- [Contracts](./contracts.md)
 
 ## Configuration
 

crates/l2/docs/program.md

@@ -0,0 +1,43 @@
+# Prover's block execution program
+
+The zkVM block execution program will:
+1. Take as input:
+    - the block to verify and its parent's header
+    - the L2 initial state, stored in a `ExecutionDB` struct, including the nodes for state and storage [pruned tries](#pruned-tries)
+1. Build the initial state tries. This includes:
+    - verifying that the initial state values stored in the `ExecutionDB` are included in the tries.
+    - checking that the state trie root hash is the same as the one in the parent's header
+    - building the trie structures
+1. Execute the block
+1. Perform validations before and after execution
+1. Apply account updates to the tries and compute the new state root
+1. Check that the final state root is the same as the one stored in the block's header
+1. Commit the program's output
+
+## Public and private inputs
+The program interface defines a `ProgramInput` and `ProgramOutput` structures. 
+
+`ProgramInput` contains:
+- the block to verify and its parent's header
+- an `ExecutionDB` which only holds the relevant initial state data for executing the block. This is built from pre-executing the block outside the zkVM to get the resulting account updates and retrieving the accounts and storage values touched by the execution.
+- the `ExecutionDB` will also include all the (encoded) nodes necessary to build [pruned tries](#pruned-tries) for the stored accounts and storage values.
+
+`ProgramOutput` contains:
+- the initial state hash
+- the final state hash
+these outputs will be committed as part of the proof. Both hashes are verified by the program, with the initial hash being checked at the time of building the initial tries (equivalent to verifying inclusion proofs) and the final hash by applying the account updates (that resulted from the block's execution) in the tries and recomputing the state root.
+
+## Pruned Tries
+The EVM state is stored in Merkle Patricia Tries, which work differently than standard Merkle binary trees. In particular we have a *state trie* for each block, which contains all account states, and then for each account we have a *storage trie* that contains every storage value if the account in question corresponds to a deployed smart contract.
+
+We need a way to check the integrity of the account and storage values we pass as input to the block execution program. The "Merkle" in Merkle Patricia Tries means that we can cryptographically check inclusion of any value in a trie, and then use the trie's root to check the integrity of the whole data at once.
+
+Particularly, the root node points to its child nodes by storing their hashes, and these also contain the hashes of *their* child nodes, and so and so, until arriving at nodes that contain the values themselves. This means that the root contains the information of the whole trie (which can be compressed in a single word (32 byte value) by hashing the root), and by traversing down the trie we are checking nodes with more specific information until arriving to some value.
+
+So if we store only the necessary nodes that make up a path from the root into a particular value of interest (including the latter and the former), then:
+- we know the root hash of this trie
+- we know that this trie includes the value we're interested in
+thereby **we're storing a proof of inclusion of the value in a trie with some root hash we can check*, which is equivalent to having a "pruned trie" that only contains the path of interest, but contains information of all other non included nodes and paths (subtries) thanks to nodes storing their childs hashes as mentioned earlier. This way we can verify the inclusion of values in some state, and thus the validity of the initial state values in the `ExecutionDB`, because we know the correct root hash.
+
+We can mutate this pruned trie by modifying/removing some value or inserting a new one, and then recalculate all the hashes from the node we inserted/modified up to the root, finally computing the new root hash. Because we know the correct final state root hash, this way we can make sure that the execution lead to the correct final state values.
+

crates/l2/proposer/prover_server.rs

@@ -25,9 +25,9 @@ use risc0_zkvm::sha::{Digest, Digestible};
 
 #[derive(Debug, Serialize, Deserialize, Default)]
 pub struct ProverInputData {
-    pub db: ExecutionDB,
     pub block: Block,
-    pub parent_header: BlockHeader,
+    pub parent_block_header: BlockHeader,
+    pub db: ExecutionDB,
 }
 
 use crate::utils::{
@@ -408,7 +408,7 @@ impl ProverServer {
 
         let db = ExecutionDB::from_exec(&block, &self.store).map_err(|err| err.to_string())?;
 
-        let parent_header = self
+        let parent_block_header = self
             .store
             .get_block_header_by_hash(block.header.parent_hash)
             .map_err(|err| err.to_string())?
@@ -419,7 +419,7 @@ impl ProverServer {
         Ok(ProverInputData {
             db,
             block,
-            parent_header,
+            parent_block_header,
         })
     }
 

crates/l2/prover/Makefile

@@ -1,5 +1,5 @@
 RISC0_DEV_MODE?=1
-RUST_LOG?="debug"
+RUST_LOG?="info"
 perf_test_proving:
 	@echo "Using RISC0_DEV_MODE: ${RISC0_DEV_MODE}"
 	RISC0_DEV_MODE=${RISC0_DEV_MODE} RUST_LOG=${RUST_LOG} cargo test --release --test perf_zkvm --features build_zkvm -- --show-output

crates/l2/prover/src/prover.rs

@@ -1,34 +1,19 @@
-use serde::Deserialize;
 use tracing::info;
 
 // risc0
-use zkvm_interface::methods::{ZKVM_PROGRAM_ELF, ZKVM_PROGRAM_ID};
-
-use risc0_zkvm::{default_prover, ExecutorEnv, ExecutorEnvBuilder, ProverOpts};
-
-use ethrex_core::types::Receipt;
-use ethrex_l2::{
-    proposer::prover_server::ProverInputData, utils::config::prover_client::ProverClientConfig,
+use zkvm_interface::{
+    io::{ProgramInput, ProgramOutput},
+    methods::{ZKVM_PROGRAM_ELF, ZKVM_PROGRAM_ID},
 };
-use ethrex_rlp::encode::RLPEncode;
-use ethrex_vm::execution_db::ExecutionDB;
 
-// The order of variables in this structure should match the order in which they were
-// committed in the zkVM, with each variable represented by a field.
-#[derive(Debug, Deserialize)]
-pub struct ProverOutputData {
-    /// It is rlp encoded, it has to be decoded.
-    /// Block::decode(&prover_output_data.block).unwrap());
-    pub _block: Vec<u8>,
-    pub _execution_db: ExecutionDB,
-    pub _parent_block_header: Vec<u8>,
-    pub block_receipts: Vec<Receipt>,
-}
+use risc0_zkvm::{default_prover, ExecutorEnv, ProverOpts};
+
+use ethrex_l2::utils::config::prover_client::ProverClientConfig;
 
 pub struct Prover<'a> {
-    env_builder: ExecutorEnvBuilder<'a>,
     elf: &'a [u8],
     pub id: [u32; 8],
+    pub stdout: Vec<u8>,
 }
 
 impl<'a> Default for Prover<'a> {
@@ -41,29 +26,20 @@ impl<'a> Default for Prover<'a> {
 impl<'a> Prover<'a> {
     pub fn new() -> Self {
         Self {
-            env_builder: ExecutorEnv::builder(),
             elf: ZKVM_PROGRAM_ELF,
             id: ZKVM_PROGRAM_ID,
+            stdout: Vec::new(),
         }
     }
 
-    pub fn set_input(&mut self, input: ProverInputData) -> &mut Self {
-        let head_block_rlp = input.block.encode_to_vec();
-        let parent_header_rlp = input.parent_header.encode_to_vec();
-
-        // We should pass the inputs as a whole struct
-        self.env_builder.write(&head_block_rlp).unwrap();
-        self.env_builder.write(&input.db).unwrap();
-        self.env_builder.write(&parent_header_rlp).unwrap();
-
-        self
-    }
-
-    /// Example:
-    /// let prover = Prover::new();
-    /// let proof = prover.set_input(inputs).prove().unwrap();
-    pub fn prove(&mut self) -> Result<risc0_zkvm::Receipt, Box<dyn std::error::Error>> {
-        let env = self.env_builder.build()?;
+    pub fn prove(
+        &mut self,
+        input: ProgramInput,
+    ) -> Result<risc0_zkvm::Receipt, Box<dyn std::error::Error>> {
+        let env = ExecutorEnv::builder()
+            .stdout(&mut self.stdout)
+            .write(&input)?
+            .build()?;
 
         // Generate the Receipt
         let prover = default_prover();
@@ -72,7 +48,7 @@ impl<'a> Prover<'a> {
         // This struct contains the receipt along with statistics about execution of the guest
         let prove_info = prover.prove_with_opts(env, self.elf, &ProverOpts::groth16())?;
 
-        // extract the receipt.
+        // Extract the receipt.
         let receipt = prove_info.receipt;
 
         info!("Successfully generated execution receipt.");
@@ -87,8 +63,7 @@ impl<'a> Prover<'a> {
 
     pub fn get_commitment(
         receipt: &risc0_zkvm::Receipt,
-    ) -> Result<ProverOutputData, Box<dyn std::error::Error>> {
-        let commitment: ProverOutputData = receipt.journal.decode()?;
-        Ok(commitment)
+    ) -> Result<ProgramOutput, Box<dyn std::error::Error>> {
+        Ok(receipt.journal.decode()?)
     }
 }

crates/l2/prover/src/prover_client.rs

@@ -7,9 +7,10 @@ use std::{
 use tokio::time::sleep;
 use tracing::{debug, error, info, warn};
 
+use zkvm_interface::io::ProgramInput;
+
 use ethrex_l2::{
-    proposer::prover_server::{ProofData, ProverInputData},
-    utils::config::prover_client::ProverClientConfig,
+    proposer::prover_server::ProofData, utils::config::prover_client::ProverClientConfig,
 };
 
 use super::prover::Prover;
@@ -38,7 +39,7 @@ impl ProverClient {
         loop {
             match self.request_new_input() {
                 Ok((block_number, input)) => {
-                    match prover.set_input(input).prove() {
+                    match prover.prove(input) {
                         Ok(proof) => {
                             if let Err(e) =
                                 self.submit_proof(block_number, proof, prover.id.to_vec())
@@ -58,7 +59,7 @@ impl ProverClient {
         }
     }
 
-    fn request_new_input(&self) -> Result<(u64, ProverInputData), String> {
+    fn request_new_input(&self) -> Result<(u64, ProgramInput), String> {
         // Request the input with the correct block_number
         let request = ProofData::Request;
         let response = connect_to_prover_server_wr(&self.prover_server_endpoint, &request)
@@ -71,7 +72,11 @@ impl ProverClient {
             } => match (block_number, input) {
                 (Some(n), Some(i)) => {
                     info!("Received Response for block_number: {n}");
-                    Ok((n, i))
+                    Ok((n, ProgramInput {
+                        block: i.block,
+                        parent_block_header: i.parent_block_header,
+                        db: i.db
+                    }))
                 }
                 _ => Err(
                     "Received Empty Response, meaning that the ProverServer doesn't have blocks to prove.\nThe Prover may be advancing faster than the Proposer."

crates/l2/prover/tests/perf_zkvm.rs

@@ -2,16 +2,16 @@ use std::path::Path;
 use tracing::info;
 
 use ethrex_blockchain::add_block;
-use ethrex_l2::proposer::prover_server::ProverInputData;
 use ethrex_prover_lib::prover::Prover;
 use ethrex_storage::{EngineType, Store};
 use ethrex_vm::execution_db::ExecutionDB;
+use zkvm_interface::io::ProgramInput;
 
 #[tokio::test]
 async fn test_performance_zkvm() {
     tracing_subscriber::fmt::init();
 
-    let mut path = Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../../test_data"));
+    let path = Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../../test_data"));
 
     // Another use is genesis-execution-api.json in conjunction with chain.rlp(20 blocks not too loaded).
     let genesis_file_path = path.join("genesis-l2-old.json");
@@ -34,23 +34,22 @@ async fn test_performance_zkvm() {
 
     let db = ExecutionDB::from_exec(block_to_prove, &store).unwrap();
 
-    let parent_header = store
+    let parent_block_header = store
         .get_block_header_by_hash(block_to_prove.header.parent_hash)
         .unwrap()
         .unwrap();
 
-    let input = ProverInputData {
-        db,
+    let input = ProgramInput {
         block: block_to_prove.clone(),
-        parent_header,
+        parent_block_header,
+        db,
     };
 
     let mut prover = Prover::new();
-    prover.set_input(input);
 
     let start = std::time::Instant::now();
 
-    let receipt = prover.prove().unwrap();
+    let receipt = prover.prove(input).unwrap();
 
     let duration = start.elapsed();
     info!(
@@ -62,12 +61,5 @@ async fn test_performance_zkvm() {
 
     prover.verify(&receipt).unwrap();
 
-    let output = Prover::get_commitment(&receipt).unwrap();
-
-    let execution_cumulative_gas_used = output.block_receipts.last().unwrap().cumulative_gas_used;
-    info!("Cumulative Gas Used {execution_cumulative_gas_used}");
-
-    let gas_per_second = execution_cumulative_gas_used as f64 / duration.as_secs_f64();
-
-    info!("Gas per Second: {}", gas_per_second);
+    let _program_output = Prover::get_commitment(&receipt).unwrap();
 }

crates/l2/prover/zkvm/interface/Cargo.toml

@@ -4,17 +4,15 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-serde = { version = "1.0", default-features = false, features = ["derive"] }
-thiserror = "1.0.64"
+serde = { version = "1.0.203", features = ["derive"] }
+serde_with = "3.11.0"
+thiserror = "1.0.61"
 
-ethrex-storage = { path = "../../../../storage/store" }
-
-# revm
-revm = { version = "14.0.3", features = [
-    "std",
-    "serde",
-    "kzg-rs",
-], default-features = false }
+ethrex-core = { path = "../../../../common/", default-features = false }
+ethrex-vm = { path = "../../../../vm", default-features = false }
+ethrex-rlp = { path = "../../../../common/rlp", default-features = false }
+ethrex-storage = { path = "../../../../storage/store", default-features = false }
+ethrex-trie = { path = "../../../../storage/trie", default-features = false }
 
 [build-dependencies]
 risc0-build = { version = "1.1.2" }

crates/l2/prover/zkvm/interface/guest/Cargo.toml

@@ -7,10 +7,13 @@ edition = "2021"
 
 [dependencies]
 risc0-zkvm = { version = "1.1.2", default-features = false, features = ["std"] }
+zkvm_interface = { path = "../" }
 
 ethrex-core = { path = "../../../../../common", default-features = false }
 ethrex-rlp = { path = "../../../../../common/rlp" }
-ethrex-vm = { path = "../../../../../vm", default-features = false }
+ethrex-vm = { path = "../../../../../vm", default-features = false, features = [
+  "l2",
+] }
 ethrex-blockchain = { path = "../../../../../blockchain", default-features = false }
 
 [build-dependencies]