chore: Update SDK example for app and EVM proofs

book/src/SUMMARY.md

@@ -28,5 +28,7 @@
 
 # Advanced Usage
 
-- [SDK](./advanced-usage/sdk.md)
+- [SDK](./advanced-usage/sdk/index.md)
+  - [App Proof Generation and Verification](./advanced-usage/sdk/app-proof.md)
+  - [EVM Proof Generation and Verification](./advanced-usage/sdk/evm-proof.md)
 - [Creating a New Extension](./advanced-usage/new-extension.md)

book/src/advanced-usage/sdk/app-proof.md

@@ -0,0 +1,53 @@
+# App Proof Generation and Verification
+
+To generate an app proof using the SDK, follow the steps below.
+
+## Building and Transpiling a Program
+
+The SDK provides lower-level control over the building and transpiling process.
+
+```rust,no_run,noplayground
+{{ #include ../../../../crates/sdk/examples/sdk_app.rs:build }}
+{{ #include ../../../../crates/sdk/examples/sdk_app.rs:read_elf}}
+
+{{ #include ../../../../crates/sdk/examples/sdk_app.rs:transpilation }}
+```
+
+### Using `SdkVmConfig`
+
+The `SdkVmConfig` struct allows you to specify the extensions and system configuration your VM will use. To customize your own configuration, you can use the `SdkVmConfig::builder()` method and set the extensions and system configuration you want.
+
+```rust,no_run,noplayground
+{{ #include ../../../../crates/sdk/examples/sdk_app.rs:vm_config }}
+```
+
+## Running a Program
+
+To run your program and see the public value output, you can do the following:
+
+```rust,no_run,noplayground
+{{ #include ../../../../crates/sdk/examples/sdk_app.rs:execution }}
+```
+
+### Using `StdIn`
+
+The `StdIn` struct allows you to format any serializable type into a VM-readable format by passing in a reference to your struct into `StdIn::write` as above. You also have the option to pass in a `&[u8]` into `StdIn::write_bytes`, or a `&[F]` into `StdIn::write_field` where `F` is the `openvm_stark_sdk::p3_baby_bear::BabyBear` field type.
+
+> **Generating CLI Bytes**  
+> To get the VM byte representation of a serializable struct `data` (i.e. for use in the CLI), you can print out the result of `openvm::serde::to_vec(data).unwrap()` in a Rust host program.
+
+## Generating App Proofs
+
+After building and transpiling a program, you can then generate a proof. To do so, you need to commit your `VmExe`, generate an `AppProvingKey`, format your input into `StdIn`, and then generate a proof.
+
+```rust,no_run,noplayground
+{{ #include ../../../../crates/sdk/examples/sdk_app.rs:proof_generation }}
+```
+
+## Verifying App Proofs
+
+After generating a proof, you can verify it. To do so, you need your verifying key (which you can get from your `AppProvingKey`) and the output of your `generate_app_proof` call.
+
+```rust,no_run,noplayground
+{{ #include ../../../../crates/sdk/examples/sdk_app.rs:verification }}
+```

book/src/advanced-usage/sdk.md → book/src/advanced-usage/sdk/evm-proof.md

@@ -1,42 +1,46 @@
-# Using the SDK
+# EVM Proof Generation and Verification
 
-While the CLI provides a convenient way to build, prove, and verify programs, you may want more fine-grained control over the process. The OpenVM Rust SDK allows you to customize various aspects of the workflow programmatically.
+Generating an end-to-end EVM proof that can be used on-chain contains many steps that are similar to previous App Proof section, but we will call some other SDK functions to generate and verify the final EVM proof.
 
-For more information on the basic CLI flow, see [Overview of Basic Usage](../writing-apps/overview.md). Writing a guest program is the same as in the CLI.
+## Setup
 
-## Imports and Setup
+To generate an EVM proof, you'll first need to ensure that you have followed the [CLI installation steps](../../getting-started/install.md). get the appropraite KZG params by running the following command.
 
-If you have a guest program and would like to try running the **host program** specified below, you can do so by adding the following imports and setup at the top of the file. You may need to modify the imports and/or the `SomeStruct` struct to match your program.
-
-```rust,no_run,noplayground
-{{ #include ../../../crates/sdk/examples/sdk.rs:dependencies }}
+```bash
+cargo openvm setup
 ```
 
+> ⚠️ **WARNING**  
+> Generating an EVM proof will require a substantial amount of computation and memory. If you have run `cargo openvm setup` and don't need a specialized aggregation configuration, consider deserializing the proving key from the file `~/.openvm/agg.pk` instead of generating it.
+
+> ⚠️ **WARNING**  
+> `cargo openvm setup` requires very large amounts of computation and memory (~200 GB).
+
 ## Building and Transpiling a Program
 
 The SDK provides lower-level control over the building and transpiling process.
 
 ```rust,no_run,noplayground
-{{ #include ../../../crates/sdk/examples/sdk.rs:build }}
-{{ #include ../../../crates/sdk/examples/sdk.rs:read_elf}}
+{{ #include ../../../../crates/sdk/examples/sdk_evm.rs:build }}
+{{ #include ../../../../crates/sdk/examples/sdk_evm.rs:read_elf}}
 
-{{ #include ../../../crates/sdk/examples/sdk.rs:transpilation }}
+{{ #include ../../../../crates/sdk/examples/sdk_evm.rs:transpilation }}
 ```
 
 ### Using `SdkVmConfig`
 
 The `SdkVmConfig` struct allows you to specify the extensions and system configuration your VM will use. To customize your own configuration, you can use the `SdkVmConfig::builder()` method and set the extensions and system configuration you want.
 
 ```rust,no_run,noplayground
-{{ #include ../../../crates/sdk/examples/sdk.rs:vm_config }}
+{{ #include ../../../../crates/sdk/examples/sdk_evm.rs:vm_config }}
 ```
 
 ## Running a Program
 
 To run your program and see the public value output, you can do the following:
 
 ```rust,no_run,noplayground
-{{ #include ../../../crates/sdk/examples/sdk.rs:execution }}
+{{ #include ../../../../crates/sdk/examples/sdk_evm.rs:execution }}
 ```
 
 ### Using `StdIn`
@@ -46,37 +50,23 @@ The `StdIn` struct allows you to format any serializable type into a VM-readable
 > **Generating CLI Bytes**  
 > To get the VM byte representation of a serializable struct `data` (i.e. for use in the CLI), you can print out the result of `openvm::serde::to_vec(data).unwrap()` in a Rust host program.
 
-## Generating Proofs
+## Generating App Proofs
 
 After building and transpiling a program, you can then generate a proof. To do so, you need to commit your `VmExe`, generate an `AppProvingKey`, format your input into `StdIn`, and then generate a proof.
 
 ```rust,no_run,noplayground
-{{ #include ../../../crates/sdk/examples/sdk.rs:proof_generation }}
-```
-
-## Verifying Proofs
-
-After generating a proof, you can verify it. To do so, you need your verifying key (which you can get from your `AppProvingKey`) and the output of your `generate_app_proof` call.
-
-```rust,no_run,noplayground
-{{ #include ../../../crates/sdk/examples/sdk.rs:verification }}
+{{ #include ../../../../crates/sdk/examples/sdk_app.rs:proof_generation }}
 ```
 
 ## End-to-end EVM Proof Generation and Verification
 
 Generating and verifying an EVM proof is an extension of the above process.
 
 ```rust,no_run,noplayground
-{{ #include ../../../crates/sdk/examples/sdk.rs:evm_verification }}
+{{ #include ../../../../crates/sdk/examples/sdk_evm.rs:evm_verification }}
 ```
 
-> ⚠️ **WARNING**  
-> Generating an EVM proof will require a substantial amount of computation and memory. If you have run `cargo openvm setup` and don't need a specialized aggregation configuration, consider deserializing the proving key from the file `~/.openvm/agg.pk` instead of generating it.
-
 > ⚠️ **WARNING**  
 > The aggregation proving key `agg_pk` above is large. Avoid cloning it if possible.
 
-Note that `DEFAULT_PARAMS_DIR` is the directory where Halo2 parameters are stored by the `cargo openvm setup` CLI command. For more information on the setup process, see the `EVM Level` section of the [verify](../writing-apps/verify.md) doc.
-
-> ⚠️ **WARNING**  
-> `cargo openvm setup` requires very large amounts of computation and memory (~200 GB).
+Note that `DEFAULT_PARAMS_DIR` is the directory where Halo2 parameters are stored by the `cargo openvm setup` CLI command. For more information on the setup process, see the `EVM Level` section of the [verify](../../writing-apps/verify.md) doc.

book/src/advanced-usage/sdk/index.md

@@ -0,0 +1,20 @@
+# Using the SDK
+
+While the CLI provides a convenient way to build, prove, and verify programs, you may want more fine-grained control over the process. The OpenVM Rust SDK allows you to customize various aspects of the workflow programmatically.
+
+For more information on the basic CLI flow, see [Overview of Basic Usage](../../writing-apps/overview.md). Writing a guest program is the same as in the CLI.
+
+## Imports and Setup
+
+If you have a guest program and would like to try running the **host program** specified in the next section, you can do so by adding the following imports and setup at the top of the file. You may need to modify the imports and/or the `SomeStruct` struct to match your program.
+
+```rust,no_run,noplayground
+{{ #include ../../../../crates/sdk/examples/sdk_app.rs:dependencies }}
+```
+
+## Types of Proofs
+
+The SDK can generate two types of proofs, depending on your specific use case.
+
+- [App Proof](./app-proof.md): Generates a STARK proof of the guest program
+- [EVM Proof](./evm-proof.md): Generates a halo2 proof that can be posted on-chain

crates/sdk/examples/sdk_app.rs

@@ -0,0 +1,105 @@
+// ANCHOR: dependencies
+use std::{fs, sync::Arc};
+
+use eyre::Result;
+use openvm::platform::memory::MEM_SIZE;
+use openvm_build::GuestOptions;
+use openvm_sdk::{
+    config::{AppConfig, SdkVmConfig},
+    prover::AppProver,
+    Sdk, StdIn,
+};
+use openvm_stark_sdk::config::FriParameters;
+use openvm_transpiler::elf::Elf;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+pub struct SomeStruct {
+    pub a: u64,
+    pub b: u64,
+}
+// ANCHOR_END: dependencies
+
+#[allow(dead_code, unused_variables)]
+fn read_elf() -> Result<(), Box<dyn std::error::Error>> {
+    // ANCHOR: read_elf
+    // 2b. Load the ELF from a file
+    let elf_bytes = fs::read("your_path_to_elf")?;
+    let elf = Elf::decode(&elf_bytes, MEM_SIZE as u32)?;
+    // ANCHOR_END: read_elf
+    Ok(())
+}
+
+#[allow(unused_variables, unused_doc_comments)]
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // ANCHOR: vm_config
+    let vm_config = SdkVmConfig::builder()
+        .system(Default::default())
+        .rv32i(Default::default())
+        .rv32m(Default::default())
+        .io(Default::default())
+        .build();
+    // ANCHOR_END: vm_config
+
+    /// to import example guest code in crate replace `target_path` for:
+    /// ```
+    /// use std::path::PathBuf;
+    ///
+    /// let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).to_path_buf();
+    /// path.push("guest");
+    /// let target_path = path.to_str().unwrap();
+    /// ```
+    // ANCHOR: build
+    // 1. Build the VmConfig with the extensions needed.
+    let sdk = Sdk;
+
+    // 2a. Build the ELF with guest options and a target filter.
+    let guest_opts = GuestOptions::default();
+    let target_path = "your_path_project_root";
+    let elf = sdk.build(guest_opts, target_path, &Default::default())?;
+    // ANCHOR_END: build
+
+    // ANCHOR: transpilation
+    // 3. Transpile the ELF into a VmExe
+    let exe = sdk.transpile(elf, vm_config.transpiler())?;
+    // ANCHOR_END: transpilation
+
+    // ANCHOR: execution
+    // 4. Format your input into StdIn
+    let my_input = SomeStruct { a: 1, b: 2 }; // anything that can be serialized
+    let mut stdin = StdIn::default();
+    stdin.write(&my_input);
+
+    // 5. Run the program
+    let output = sdk.execute(exe.clone(), vm_config.clone(), stdin.clone())?;
+    println!("public values output: {:?}", output);
+    // ANCHOR_END: execution
+
+    // ANCHOR: proof_generation
+    // 6. Set app configuration
+    let app_log_blowup = 2;
+    let app_fri_params = FriParameters::standard_with_100_bits_conjectured_security(app_log_blowup);
+    let app_config = AppConfig::new(app_fri_params, vm_config);
+
+    // 7. Commit the exe
+    let app_committed_exe = sdk.commit_app_exe(app_fri_params, exe)?;
+
+    // 8. Generate an AppProvingKey
+    let app_pk = Arc::new(sdk.app_keygen(app_config)?);
+
+    // 9a. Generate a proof
+    let proof = sdk.generate_app_proof(app_pk.clone(), app_committed_exe.clone(), stdin.clone())?;
+    // 9b. Generate a proof with an AppProver with custom fields
+    let app_prover = AppProver::new(app_pk.app_vm_pk.clone(), app_committed_exe.clone())
+        .with_program_name("test_program");
+    let proof = app_prover.generate_app_proof(stdin.clone());
+    // ANCHOR_END: proof_generation
+
+    // ANCHOR: verification
+    // 10. Verify your program
+    let app_vk = app_pk.get_app_vk();
+    sdk.verify_app_proof(&app_vk, &proof)?;
+    // ANCHOR_END: verification
+
+    Ok(())
+}

crates/sdk/examples/sdk.rs → crates/sdk/examples/sdk_evm.rs

@@ -7,7 +7,6 @@ use openvm_build::GuestOptions;
 use openvm_native_recursion::halo2::utils::CacheHalo2ParamsReader;
 use openvm_sdk::{
     config::{AggConfig, AppConfig, SdkVmConfig},
-    prover::AppProver,
     Sdk, StdIn,
 };
 use openvm_stark_sdk::config::FriParameters;
@@ -87,32 +86,19 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // 8. Generate an AppProvingKey
     let app_pk = Arc::new(sdk.app_keygen(app_config)?);
-
-    // 9a. Generate a proof
-    let proof = sdk.generate_app_proof(app_pk.clone(), app_committed_exe.clone(), stdin.clone())?;
-    // 9b. Generate a proof with an AppProver with custom fields
-    let app_prover = AppProver::new(app_pk.app_vm_pk.clone(), app_committed_exe.clone())
-        .with_program_name("test_program");
-    let proof = app_prover.generate_app_proof(stdin.clone());
     // ANCHOR_END: proof_generation
 
-    // ANCHOR: verification
-    // 10. Verify your program
-    let app_vk = app_pk.get_app_vk();
-    sdk.verify_app_proof(&app_vk, &proof)?;
-    // ANCHOR_END: verification
-
     // ANCHOR: evm_verification
-    // 11. Generate the aggregation proving key
+    // 9. Generate the aggregation proving key
     const DEFAULT_PARAMS_DIR: &str = concat!(env!("HOME"), "/.openvm/params/");
     let halo2_params_reader = CacheHalo2ParamsReader::new(DEFAULT_PARAMS_DIR);
     let agg_config = AggConfig::default();
     let agg_pk = sdk.agg_keygen(agg_config, &halo2_params_reader)?;
 
-    // 12. Generate the SNARK verifier contract
+    // 10. Generate the SNARK verifier contract
     let verifier = sdk.generate_snark_verifier_contract(&halo2_params_reader, &agg_pk)?;
 
-    // 13. Generate an EVM proof
+    // 11. Generate an EVM proof
     let proof = sdk.generate_evm_proof(
         &halo2_params_reader,
         app_pk,
@@ -121,7 +107,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         stdin,
     )?;
 
-    // 14. Verify the EVM proof
+    // 12. Verify the EVM proof
     let success = sdk.verify_evm_proof(&verifier, &proof);
     assert!(success);
     // ANCHOR_END: evm_verification