refactor: update guest program workspace and add public values

Author: Sahilgill24

Cargo.lock

@@ -9,13 +9,18 @@ members = [
     "crates/common/crypto",
     "crates/common/metrics",
     "crates/common/test-fixtures",
-    "crates/common/types", "crates/guest-program/sp1",
+    "crates/common/types",
     "crates/net/api",
     "crates/net/p2p",
     "crates/net/rpc",
     "crates/storage",
 ]
 
+# NOTE: zkVM guest programs are their own workspaces: they build for the respective 
+# target ISA via their respective build commands, not for the host, so `cargo {clippy,test}
+# --workspace` must not try to compile them.
+exclude = ["crates/guest-program/sp1"]
+
 [workspace.package]
 authors = ["LambdaClass"]
 edition = "2024"

Cargo.toml

@@ -1,15 +1,37 @@
 use libssz::{SszDecode, SszEncode};
 use serde::{Deserialize, Serialize};
 
-use crate::{block::Block, state::State};
+use crate::{block::Block, primitives::H256, state::State};
 
-// we will pass as bytes, as we want this to be definitely serializable and both implement Sszencode and decode
+
+/// Input type for the zkVM's 
+/// 
+/// The inputs to the zkVM need to derive serde Serialize/deserialize
+/// which is not derived for state (libssz traits)
+/// wrapping pre-serialized SSZ bytes sidesteps that part. 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct StfInput {
     state: Vec<u8>,
     block: Vec<u8>,
 }
 
+/// Public values committed by the STF guest program.
+///
+/// These bind a proof to one concrete transition: applying the block with
+/// `block_root` to the state with `pre_state_root` yields the state with
+/// `post_state_root`. A verifier reads these back from the proof without ever
+/// seeing the full pre-state or block, and can chain proofs by matching one
+/// transition's `post_state_root` to the next's `pre_state_root`.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StfPublicValues {
+    /// `hash_tree_root` of the pre-state.
+    pub pre_state_root: H256,
+    /// `hash_tree_root` of the block being applied.
+    pub block_root: H256,
+    /// `hash_tree_root` of the post-state (equals `block.state_root`).
+    pub post_state_root: H256,
+}
+
 impl StfInput {
     pub fn new(state: State, block: Block) -> Self {
         StfInput {
@@ -18,11 +40,11 @@ impl StfInput {
         }
     }
 
-    pub fn return_state(input: Self) -> State {
-        State::from_ssz_bytes(&input.state).expect("error decoding State")
+    pub fn state(&self) -> State {
+        State::from_ssz_bytes(&self.state).expect("error decoding State")
     }
 
-    pub fn return_block(input: Self) -> Block {
-        Block::from_ssz_bytes(&input.block).expect("error decoding block")
+    pub fn block(&self) -> Block {
+        Block::from_ssz_bytes(&self.block).expect("error decoding block")
     }
 }

crates/common/types/src/stf.rs

@@ -1,15 +1,15 @@
+# Standalone workspace: this guest builds for a RISC-V zkVM target via
+# `cargo prove build`, so it is excluded from the root workspace and cannot
+# inherit its `[workspace.package]` / `[workspace.dependencies]` values.
+[workspace]
+
 [package]
 name = "zkvm_guest_sp1"
-authors.workspace = true
-edition.workspace = true
-keywords.workspace = true
-license.workspace = true
-readme.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-version.workspace = true
+version = "0.1.0"
+edition = "2024"
+publish = false
 
 [dependencies]
 sp1-zkvm = "6.1.0"
-ethlambda-types.workspace = true
-ethlambda-state-transition.workspace = true
+ethlambda-types = { path = "../../common/types" }
+ethlambda-state-transition = { path = "../../blockchain/state_transition" }

crates/guest-program/sp1/Cargo.toml

@@ -2,12 +2,28 @@
 sp1_zkvm::entrypoint!(main);
 
 use ethlambda_state_transition::state_transition;
-use ethlambda_types::{primitives::HashTreeRoot, stf::StfInput};
+use ethlambda_types::{
+    primitives::HashTreeRoot,
+    stf::{StfInput, StfPublicValues},
+};
 
 fn main() {
-    let input: StfInput = sp1_zkvm::io::read();
-    let mut state = StfInput::return_state(input.clone());
-    let block = &StfInput::return_block(input.clone());
-    let _ = state_transition(&mut state, block);
-    sp1_zkvm::io::commit(&state.hash_tree_root());
+    let input: StfInput = sp1_zkvm::io::read(); 
+    let mut state = input.state();
+    let block = input.block();
+
+    // Capture the pre-state and block roots before mutating the state, so the
+    // committed public values bind the proof to this specific transition.
+    let pre_state_root = state.hash_tree_root();
+    let block_root = block.hash_tree_root();
+
+    state_transition(&mut state, &block).expect("state transition failed");
+
+    let public_values = StfPublicValues {
+        pre_state_root,
+        block_root,
+        // state_transition already asserts this equals block.state_root.
+        post_state_root: state.hash_tree_root(),
+    };
+    sp1_zkvm::io::commit(&public_values);
 }