rename: leaf->vm; root->stark; (#154)

lispc · web-flow · commit 75289ce8f5b9 · 2025-08-06T17:26:46.000+08:00
* rename: leaf-&gt;vm; root-&gt;stark;

* minor
diff --git a/.dockerignore b/.dockerignore
@@ -11,6 +11,8 @@ Dockerfile.backup
 
 docs
 
+releases
+
 *.yml
 
 *.sh
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -41,7 +41,7 @@ openvm-bigint-guest = { git = "https://github.com/openvm-org/openvm.git", rev =
 openvm-pairing-guest = { git = "https://github.com/openvm-org/openvm.git", rev = "5368d4756993fc1e51092499a816867cf4808de0", default-features = false }
 openvm-rv32im-guest = { git = "https://github.com/openvm-org/openvm.git", rev = "5368d4756993fc1e51092499a816867cf4808de0", default-features = false }
 
-# openvm guest libs
+# openvm host libs
 openvm-build = { git = "https://github.com/openvm-org/openvm.git", tag = "v1.2.1-rc.1", default-features = false }
 openvm-circuit = { git = "https://github.com/openvm-org/openvm.git", tag = "v1.2.1-rc.1", default-features = false }
 openvm-continuations = { git = "https://github.com/openvm-org/openvm.git", tag = "v1.2.1-rc.1", default-features = false }
@@ -64,8 +64,6 @@ sbv-kv = { git = "https://github.com/scroll-tech/stateless-block-verifier", bran
 sbv-trie = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "chore/openvm-1.3" }
 sbv-precompile = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "chore/openvm-1.3" }
  
-scroll-alloy-evm = { git = "https://github.com/scroll-tech/reth", rev = "090d7950d169abbfb896875a7b1ff3f8ca356ac8", default-features = false }
-
 
 alloy-primitives = { version = "1.2", default-features = false, features = ["std", "map-hashbrown", "map-fxhash", "rkyv"] }
 alloy-serde = { version = "1.0.13", default-features = false }
diff --git a/crates/build-guest/src/main.rs b/crates/build-guest/src/main.rs
@@ -295,7 +295,7 @@ fn run_stage4_dump_vk_json(
             {
                 let app_vk = scroll_zkvm_types::types_agg::ProgramCommitment {
                     exe: *exe,
-                    leaf: *leaf,
+                    vm: *leaf,
                 }
                 .serialize();
 
diff --git a/crates/circuits/batch-circuit/src/circuit.rs b/crates/circuits/batch-circuit/src/circuit.rs
@@ -48,11 +48,11 @@ impl AggCircuit for BatchCircuit {
 
     fn verify_commitments(commitment: &ProgramCommitment) {
         assert_eq!(
-            commitment.leaf,
+            commitment.vm,
             child_commitments::LEAF_COMMIT,
             "mismatch chunk-proof leaf commitment: expected={:?}, got={:?}",
             child_commitments::LEAF_COMMIT,
-            commitment.leaf,
+            commitment.vm,
         );
         assert_eq!(
             commitment.exe,
diff --git a/crates/circuits/bundle-circuit/src/circuit.rs b/crates/circuits/bundle-circuit/src/circuit.rs
@@ -41,11 +41,11 @@ impl AggCircuit for BundleCircuit {
 
     fn verify_commitments(commitment: &ProgramCommitment) {
         assert_eq!(
-            commitment.leaf,
+            commitment.vm,
             child_commitments::LEAF_COMMIT,
             "mismatch batch-proof leaf commitment: expected={:?}, got={:?}",
             child_commitments::LEAF_COMMIT,
-            commitment.leaf,
+            commitment.vm,
         );
         assert_eq!(
             commitment.exe,
diff --git a/crates/integration/src/lib.rs b/crates/integration/src/lib.rs
@@ -6,7 +6,7 @@ use scroll_zkvm_prover::{
     utils::{read_json, vm::ExecutionResult, write_json},
 };
 use scroll_zkvm_types::{
-    proof::{EvmProof, ProofEnum, RootProof},
+    proof::{EvmProof, ProofEnum, StarkProof},
     public_inputs::ForkName,
 };
 use scroll_zkvm_verifier::verifier::UniversalVerifier;
@@ -155,7 +155,7 @@ pub trait ProverTester {
 
     fn build_guest_input<'a>(
         witness: &Self::Witness,
-        aggregated_proofs: impl Iterator<Item = &'a RootProof>,
+        aggregated_proofs: impl Iterator<Item = &'a StarkProof>,
     ) -> Result<StdIn, rkyv::rancor::Error> {
         use openvm_native_recursion::hints::Hintable;
 
@@ -270,7 +270,7 @@ pub fn tester_execute<T: ProverTester>(
         witness,
         proofs
             .iter()
-            .map(|p| p.as_root_proof().expect("must be stark proof")),
+            .map(|p| p.as_stark_proof().expect("must be stark proof")),
     )?;
 
     let ret = prover.execute_and_check_with_full_result(&stdin)?;
@@ -307,7 +307,7 @@ pub fn prove_verify<T: ProverTester>(
             witness,
             proofs
                 .iter()
-                .map(|p| p.as_root_proof().expect("must be stark proof")),
+                .map(|p| p.as_stark_proof().expect("must be stark proof")),
         )?;
         // Construct stark proof for the circuit.
         let proof = prover.gen_proof_stark(stdin)?.into();
@@ -318,7 +318,10 @@ pub fn prove_verify<T: ProverTester>(
     };
 
     // Verify proof.
-    UniversalVerifier::verify_proof(proof.as_root_proof().expect("should be stark proof"), &vk)?;
+    UniversalVerifier::verify_stark_proof(
+        proof.as_stark_proof().expect("should be stark proof"),
+        &vk,
+    )?;
 
     Ok(proof)
 }
@@ -363,7 +366,7 @@ where
             witness,
             proofs
                 .iter()
-                .map(|p| p.as_root_proof().expect("must be stark proof")),
+                .map(|p| p.as_stark_proof().expect("must be stark proof")),
         )?;
         // Construct stark proof for the circuit.
         let proof: EvmProof = prover.gen_proof_snark(stdin)?.into();
@@ -374,16 +377,14 @@ where
 
     let vk = prover.get_app_vk();
     // Verify proof.
-    assert!(
-        verifier.verify_proof_evm(
-            &proof
-                .clone()
-                .into_evm_proof()
-                .expect("must be evm proof")
-                .into(),
-            &vk,
-        )?
-    );
+    verifier.verify_evm_proof(
+        &proof
+            .clone()
+            .into_evm_proof()
+            .expect("must be evm proof")
+            .into(),
+        &vk,
+    )?;
 
     Ok((proof, verifier, path_assets))
 }
diff --git a/crates/integration/tests/batch_circuit.rs b/crates/integration/tests/batch_circuit.rs
@@ -48,7 +48,7 @@ fn test_e2e_execute() -> eyre::Result<()> {
 
     let stdin = BatchProverTester::build_guest_input(
         &wit,
-        agg_proofs.iter().map(|p| p.as_root_proof().unwrap()),
+        agg_proofs.iter().map(|p| p.as_stark_proof().unwrap()),
     )?;
     let _ = prover.execute_and_check_with_full_result(&stdin)?;
 
diff --git a/crates/integration/tests/chunk_circuit.rs b/crates/integration/tests/chunk_circuit.rs
@@ -23,10 +23,9 @@ fn exec_chunk(prover: &Prover, wit: &ChunkWitness) -> eyre::Result<(ExecutionRes
     let cycle_count = exec_result.total_cycle as u64;
     let cycle_per_gas = cycle_count / stats.total_gas_used;
     println!(
-        "blk {blk}->{}, cycle {cycle_count}, gas {}, cycle-per-gas {cycle_per_gas}, tick-per-gas {}",
+        "blk {blk}->{}, cycle {cycle_count}, gas {}, cycle-per-gas {cycle_per_gas}",
         wit.blocks.last().unwrap().header.number,
         stats.total_gas_used,
-        exec_result.total_tick as u64 / stats.total_gas_used,
     );
     Ok((exec_result, stats.total_gas_used))
 }
@@ -140,30 +139,27 @@ fn test_execute_multi() -> eyre::Result<()> {
         .build()
         .unwrap();
     // Execute tasks in parallel
-    let (total_gas, total_cycle, total_tick) = pool.install(|| {
+    let (total_gas, total_cycle) = pool.install(|| {
         // comment by fan@scroll.io: why we need to load prover multiple times (which is time costing)
         let prover = ChunkProverTester::load_prover(false).unwrap();
-        let init = (0u64, 0u64, 0u64);
-        let adder = |(gas1, cycle1, tick1): (u64, u64, u64),
-                     (gas2, cycle2, tick2): (u64, u64, u64)| {
-            (gas1 + gas2, cycle1 + cycle2, tick1 + tick2)
-        };
+        let init = (0u64, 0u64);
+        let adder =
+            |(gas1, cycle1): (u64, u64), (gas2, cycle2): (u64, u64)| (gas1 + gas2, cycle1 + cycle2);
         preset_chunk_multiple()
             .into_iter()
-            .map(|task| -> (u64, u64, u64) {
+            .map(|task| -> (u64, u64) {
                 let (exec_result, gas) =
                     exec_chunk(&prover, &task.gen_proving_witnesses().unwrap()).unwrap();
-                (gas, exec_result.total_cycle, exec_result.total_tick)
+                (gas, exec_result.total_cycle)
             })
             .fold(init, adder)
     });
 
     println!(
-        "Total gas: {}, Total cycles: {}, Average cycle/gas: {}, Average tick/gas: {}",
+        "Total gas: {}, Total cycles: {}, Average cycle/gas: {}",
         total_gas,
         total_cycle,
         total_cycle as f64 / total_gas as f64,
-        total_tick as f64 / total_gas as f64,
     );
 
     Ok(())
diff --git a/crates/prover/Cargo.toml b/crates/prover/Cargo.toml
@@ -9,8 +9,7 @@ version.workspace = true
 scroll-zkvm-types.workspace = true
 scroll-zkvm-types-chunk = { workspace = true, features = ["scroll-compress-ratio"] }
 scroll-zkvm-verifier.workspace = true
-
-scroll-alloy-evm = { workspace = true, features = ["std", "zstd_compression"] }
+scroll-zkvm-types-batch.workspace = true
 
 alloy-primitives = { workspace = true, features = ["tiny-keccak"] }
 rkyv.workspace = true
diff --git a/crates/prover/src/prover/mod.rs b/crates/prover/src/prover/mod.rs
@@ -27,7 +27,7 @@ use crate::{
     task::ProvingTask,
 };
 
-use scroll_zkvm_types::proof::{EvmProof, ProofEnum, RootProof};
+use scroll_zkvm_types::proof::{EvmProof, ProofEnum, StarkProof};
 
 /// The default directory to locate openvm's halo2 SRS parameters.
 const DEFAULT_PARAMS_DIR: &str = concat!(env!("HOME"), "/.openvm/params/");
@@ -133,9 +133,9 @@ impl Prover {
         );
 
         let exe = commits.app_exe_commit.to_u32_digest();
-        let leaf = commits.app_vm_commit.to_u32_digest();
+        let vm = commits.app_vm_commit.to_u32_digest();
 
-        scroll_zkvm_types::types_agg::ProgramCommitment { exe, leaf }.serialize()
+        scroll_zkvm_types::types_agg::ProgramCommitment { exe, vm }.serialize()
     }
 
     /// Pick up the actual vk (serialized) for evm proof, would be empty if prover
@@ -241,7 +241,7 @@ impl Prover {
     /// Generate a [root proof][root_proof].
     ///
     /// [root_proof][openvm_sdk::verifier::root::types::RootVmVerifierInput]
-    pub fn gen_proof_stark(&self, stdin: StdIn) -> Result<RootProof, Error> {
+    pub fn gen_proof_stark(&self, stdin: StdIn) -> Result<StarkProof, Error> {
         // Here we always do an execution of the guest program to get the cycle count.
         // and do precheck before proving like ensure PI != 0
         self.execute_and_check(&stdin)?;
diff --git a/crates/types/base/src/aggregation.rs b/crates/types/base/src/aggregation.rs
@@ -31,8 +31,8 @@ pub struct AggregationInput {
 pub struct ProgramCommitment {
     /// The commitment to the child program exe.
     pub exe: [u32; 8],
-    /// The commitment to the child program leaf.
-    pub leaf: [u32; 8],
+    /// The commitment to the child program vm.
+    pub vm: [u32; 8],
 }
 
 impl ProgramCommitment {
@@ -48,7 +48,7 @@ impl ProgramCommitment {
 
         Self {
             exe: archived_data.exe.map(|u32_le| u32_le.to_native()),
-            leaf: archived_data.leaf.map(|u32_le| u32_le.to_native()),
+            vm: archived_data.vm.map(|u32_le| u32_le.to_native()),
         }
     }
 
@@ -63,7 +63,7 @@ impl From<&ArchivedProgramCommitment> for ProgramCommitment {
     fn from(archived: &ArchivedProgramCommitment) -> Self {
         Self {
             exe: archived.exe.map(|u32_le| u32_le.to_native()),
-            leaf: archived.leaf.map(|u32_le| u32_le.to_native()),
+            vm: archived.vm.map(|u32_le| u32_le.to_native()),
         }
     }
 }
diff --git a/crates/types/circuit/src/lib.rs b/crates/types/circuit/src/lib.rs
@@ -112,7 +112,7 @@ fn verify_proof(commitment: &ProgramCommitment, public_inputs: &[u32]) {
         openvm::io::store_u32_to_native(native_addr, x);
         native_addr += FIELDS_PER_U32;
     }
-    for &x in &commitment.leaf {
+    for &x in &commitment.vm {
         openvm::io::store_u32_to_native(native_addr, x);
         native_addr += FIELDS_PER_U32;
     }
diff --git a/crates/types/src/proof.rs b/crates/types/src/proof.rs
@@ -8,7 +8,7 @@ use openvm_stark_sdk::{
 use serde::{Deserialize, Serialize};
 
 /// Alias for convenience.
-pub type RootProof = RootVmVerifierInput<SC>;
+pub type StarkProof = RootVmVerifierInput<SC>;
 
 /// Helper type for convenience that implements [`From`] and [`Into`] traits between
 /// [`OpenVmEvmProof`]. The difference is that the instances in [`EvmProof`] are the byte-encoding
@@ -26,8 +26,8 @@ pub struct EvmProof {
 
 /// Helper to modify serde implementations on the remote [`RootProof`] type.
 #[derive(Serialize, Deserialize)]
-#[serde(remote = "RootProof")]
-struct RootProofDef {
+#[serde(remote = "StarkProof")]
+struct StarkProofDef {
     /// The proofs.
     #[serde(with = "as_base64")]
     proofs: Vec<Proof<SC>>,
@@ -95,15 +95,15 @@ impl From<EvmProof> for OpenVmEvmProof {
 #[serde(untagged)]
 pub enum ProofEnum {
     /// Represents a STARK proof used for intermediary layers, i.e. chunk and batch.
-    #[serde(with = "RootProofDef")]
-    Root(RootProof),
+    #[serde(with = "StarkProofDef")]
+    Stark(StarkProof),
     /// Represents a SNARK proof used for the final layer to be verified on-chain, i.e. bundle.
     Evm(EvmProof),
 }
 
-impl From<RootProof> for ProofEnum {
-    fn from(value: RootProof) -> Self {
-        Self::Root(value)
+impl From<StarkProof> for ProofEnum {
+    fn from(value: StarkProof) -> Self {
+        Self::Stark(value)
     }
 }
 
@@ -114,10 +114,10 @@ impl From<EvmProof> for ProofEnum {
 }
 
 impl ProofEnum {
-    /// Get the root proof as reference.
-    pub fn as_root_proof(&self) -> Option<&RootProof> {
+    /// Get the stark proof as reference.
+    pub fn as_stark_proof(&self) -> Option<&StarkProof> {
         match self {
-            Self::Root(proof) => Some(proof),
+            Self::Stark(proof) => Some(proof),
             _ => None,
         }
     }
@@ -133,9 +133,9 @@ impl ProofEnum {
     }
 
     /// Consumes the proof enum and returns the contained root proof.
-    pub fn into_root_proof(self) -> Option<RootProof> {
+    pub fn into_stark_proof(self) -> Option<StarkProof> {
         match self {
-            Self::Root(proof) => Some(proof),
+            Self::Stark(proof) => Some(proof),
             _ => None,
         }
     }
@@ -151,7 +151,7 @@ impl ProofEnum {
     /// Derive public inputs from the proof.
     pub fn public_values(&self) -> Vec<u32> {
         match self {
-            Self::Root(root_proof) => root_proof
+            Self::Stark(stark_proof) => stark_proof
                 .public_values
                 .iter()
                 .map(|x| x.as_canonical_u32())
diff --git a/crates/types/src/task.rs b/crates/types/src/task.rs
@@ -1,4 +1,4 @@
-use crate::proof::RootProof;
+use crate::proof::StarkProof;
 use serde::{Deserialize, Serialize};
 
 /// Universal task for zkvm-prover, with encoded bytes which can be used
@@ -9,7 +9,7 @@ pub struct ProvingTask {
     pub serialized_witness: Vec<Vec<u8>>,
     /// aggregated proof carried by babybear fields, should be written into stdin
     /// followed `serialized_witness`
-    pub aggregated_proofs: Vec<RootProof>,
+    pub aggregated_proofs: Vec<StarkProof>,
     /// Fork name specify
     pub fork_name: String,
     /// The vk of app which is expcted to prove this task
diff --git a/crates/verifier/src/verifier.rs b/crates/verifier/src/verifier.rs

-Original file line number
+Diff line change
 docs
 +releases
++
 *.yml
 *.sh
Original file line number	Diff line number	Diff line change
`@@ -295,7 +295,7 @@ fn run_stage4_dump_vk_json(`
`295`	`295`	`{`
`296`	`296`	`let app_vk = scroll_zkvm_types::types_agg::ProgramCommitment {`
`297`	`297`	`exe: *exe,`
`298`		`- leaf: *leaf,`
	`298`	`+ vm: *leaf,`
`299`	`299`	`}`
`300`	`300`	`.serialize();`
`301`	`301`