chore: Rust fmt

3 files changed, 33 insertions, 46 deletions

diff --git a/zkvms/zkm/guest/src/main.rs b/zkvms/zkm/guest/src/main.rs
index 1aa27b8..e8f9daf 100644
--- a/zkvms/zkm/guest/src/main.rs
+++ b/zkvms/zkm/guest/src/main.rs
@@ -4,8 +4,8 @@
 use wrapper_macro::make_wrapper;
 
 extern crate alloc;
-use alloc::{ vec::*, collections::* };
-use zkm_runtime::io::{ read, commit };
+use alloc::{collections::*, vec::*};
+use zkm_runtime::io::{commit, read};
 
 zkm_runtime::entrypoint!(main);
 
diff --git a/zkvms/zkm/host/src/main.rs b/zkvms/zkm/host/src/main.rs
index f71dcc5..db1a5cb 100644
--- a/zkvms/zkm/host/src/main.rs
+++ b/zkvms/zkm/host/src/main.rs
@@ -1,8 +1,15 @@
 use anyhow::{bail, Result};
 use std::{env, fs::read, time::Instant};
-use zkm_sdk::{prover::ClientCfg, prover::{ProverInput, ProverResult} , ProverClient};
+use zkm_sdk::{
+    prover::ClientCfg,
+    prover::{ProverInput, ProverResult},
+    ProverClient,
+};
 
-use zkvms_host_io::{read_args, benchmarkable, RunType::{ Execute, Prove, Verify }};
+use zkvms_host_io::{
+    benchmarkable, read_args,
+    RunType::{Execute, Prove, Verify},
+};
 
 async fn setup(
     prover_client: &mut ProverClient,
@@ -26,16 +33,12 @@ async fn get_proof(
 
     if let Ok(Some(prover_result)) = proving_result {
         prover_result
-    }
-    else {
+    } else {
         panic!("Failed to generate proof!");
     }
 }
 
-async fn execute(
-    prover_client: &mut ProverClient,
-    prover_input: &mut ProverInput,
-) {
+async fn execute(prover_client: &mut ProverClient, prover_input: &mut ProverInput) {
     let prover_result = get_proof(prover_client, prover_input).await;
 
     prover_client
@@ -52,12 +55,7 @@ async fn prove(
     let prover_result = get_proof(prover_client, prover_input).await;
 
     prover_client
-        .process_proof_results(
-            &prover_result,
-            &prover_input,
-            &proof_results_path,
-            "local",
-        )
+        .process_proof_results(&prover_result, &prover_input, &proof_results_path, "local")
         .expect("process proof results error");
 }
 
@@ -68,30 +66,14 @@ async fn main() -> Result<()> {
         panic!("Off-chain verification is not supported!");
     }
 
-    let seg_size: u32 = run_info
-        .env_then_or(
-            "SEG_SIZE",
-            |seg| seg.parse::<u32>().ok(),
-            65536,
-        );
+    let seg_size: u32 = run_info.env_then_or("SEG_SIZE", |seg| seg.parse::<u32>().ok(), 65536);
 
     let elf_path = env::var("ELF_PATH").expect("ELF PATH is missing");
 
-    let proof_results_path = run_info
-        .env_or(
-            "PROOF_RESULTS_PATH",
-            "/tmp/contracts",
-        );
-    let vk_path = run_info
-        .env_or(
-            "VERIFYING_KEY_PATH",
-            "/tmp/input",
-        );
-
-    let mut client_config = ClientCfg::new(
-        "local".to_string(),
-        vk_path.to_owned(),
-    );
+    let proof_results_path = run_info.env_or("PROOF_RESULTS_PATH", "/tmp/contracts");
+    let vk_path = run_info.env_or("VERIFYING_KEY_PATH", "/tmp/input");
+
+    let mut client_config = ClientCfg::new("local".to_string(), vk_path.to_owned());
 
     let mut prover_client = ProverClient::new(&client_config).await;
 
@@ -118,11 +100,11 @@ async fn main() -> Result<()> {
 
     match run_info.run_type {
         // only excute the guest program without generating the proof.
-        Execute => benchmarkable!{
+        Execute => benchmarkable! {
             execute(&mut prover_client, &mut prover_input).await;
         },
         // excute the guest program and generate the proof
-        Prove => benchmarkable!{
+        Prove => benchmarkable! {
             prove(&mut prover_client, &mut prover_input, &vk_path, &proof_results_path).await;
         },
         Verify => unreachable!(),
diff --git a/zkvms/zkm/wrapper_macro/src/lib.rs b/zkvms/zkm/wrapper_macro/src/lib.rs
index 216d3d8..cb8060a 100644
--- a/zkvms/zkm/wrapper_macro/src/lib.rs
+++ b/zkvms/zkm/wrapper_macro/src/lib.rs
@@ -2,7 +2,9 @@ use proc_macro::TokenStream;
 
 #[path = "../../../../guests_macro/src/parse_fn.rs"]
 mod parse_fn;
-use crate::parse_fn::{ split_fn, args_split, args_divide_public, args_divide_grouped, group_streams };
+use crate::parse_fn::{
+    args_divide_grouped, args_divide_public, args_split, group_streams, split_fn,
+};
 
 /// Create a body, which reads all public and private inputs, stores them in
 /// variables, then executes the guest entrypoint function with those arguments
@@ -33,14 +35,17 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
 
     let (ts_patterns, _) = args_divide_grouped(&args);
 
-    let public_inputs = toml::from_str::<toml::Table>(
-            include_str!(concat!(env!("INPUTS_DIR"), "/default_public_input.toml"))
-        )
-        .unwrap();
-    let ((pub_pat, pub_typ), (prv_pat, prv_typ)) = args_divide_public(&args, &public_inputs.keys().collect());
+    let public_inputs = toml::from_str::<toml::Table>(include_str!(concat!(
+        env!("INPUTS_DIR"),
+        "/default_public_input.toml"
+    )))
+    .unwrap();
+    let ((pub_pat, pub_typ), (prv_pat, prv_typ)) =
+        args_divide_public(&args, &public_inputs.keys().collect());
     let ((pub_pat, pub_typ), (prv_pat, prv_typ)) = (
         (group_streams(&pub_pat), group_streams(&pub_typ)),
-        (group_streams(&prv_pat), group_streams(&prv_typ)));
+        (group_streams(&prv_pat), group_streams(&prv_typ)),
+    );
 
     let mut out = TokenStream::new();
     // NOTE: The first read returns public data, the second returns private