chore: Rust fmt

18 files changed, 304 insertions, 227 deletions

diff --git a/zkvms/jolt/guest/src/lib.rs b/zkvms/jolt/guest/src/lib.rs
index d90b3f2..e8618e8 100644
--- a/zkvms/jolt/guest/src/lib.rs
+++ b/zkvms/jolt/guest/src/lib.rs
@@ -1,7 +1,7 @@
 //#![cfg_attr(feature = "guest", no_std)]
 #![no_main]
 
-use wrapper_macro::make_wrapper;
 use std::collections::*;
+use wrapper_macro::make_wrapper;
 
-zkp::entrypoint_expr!{}
+zkp::entrypoint_expr! {}
diff --git a/zkvms/jolt/host/src/main.rs b/zkvms/jolt/host/src/main.rs
index 54a6e61..3ad8377 100644
--- a/zkvms/jolt/host/src/main.rs
+++ b/zkvms/jolt/host/src/main.rs
@@ -1,4 +1,7 @@
-use zkvms_host_io::{benchmarkable, read_args, RunType::{ Execute, Prove, Verify }};
+use zkvms_host_io::{
+    benchmarkable, read_args,
+    RunType::{Execute, Prove, Verify},
+};
 
 type Input = (Vec<Vec<bool>>, u32, Vec<Vec<u32>>);
 
@@ -14,11 +17,11 @@ pub fn main() {
 
     match run_info.run_type {
         Execute => unreachable!(),
-        Prove => benchmarkable!{
+        Prove => benchmarkable! {
             let (output, _) = prove_guest(run_info.input.clone().into());
             println!("Prove output: {}", output);
         },
-        Verify => benchmarkable!{
+        Verify => benchmarkable! {
             let (_, proof) = prove_guest(run_info.input.clone().into());
             let is_valid = verify_guest(proof);
             println!("Verify is valid: {}", is_valid);
diff --git a/zkvms/jolt/wrapper_macro/src/lib.rs b/zkvms/jolt/wrapper_macro/src/lib.rs
index 7631950..5f73e70 100644
--- a/zkvms/jolt/wrapper_macro/src/lib.rs
+++ b/zkvms/jolt/wrapper_macro/src/lib.rs
@@ -4,7 +4,7 @@ use quote::quote;
 
 #[path = "../../../../guests_macro/src/parse_fn.rs"]
 mod parse_fn;
-use crate::parse_fn::{ split_fn, args_split, args_divide, group_streams };
+use crate::parse_fn::{args_divide, args_split, group_streams, split_fn};
 
 /// Create a set of three helper functions.
 ///
@@ -54,10 +54,28 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
     out.extend(format!("zkp::{}{}", name, ts_patterns).parse::<TokenStream>());
 
     let mut func = TokenStream::new();
-    func.extend(format!("#[jolt::provable(max_input_size = 100000)] fn guest{} -> {} {{ {} }}", args, ret, out).parse::<TokenStream>());
-
-    func.extend(make_build_fn(patterns.clone(), types.clone(), ts_patterns.clone(), ts_types.clone(), ret.clone()));
-    func.extend(make_preprocess_fn(patterns, types, ts_patterns, ts_types, ret));
+    func.extend(
+        format!(
+            "#[jolt::provable(max_input_size = 100000)] fn guest{} -> {} {{ {} }}",
+            args, ret, out
+        )
+        .parse::<TokenStream>(),
+    );
+
+    func.extend(make_build_fn(
+        patterns.clone(),
+        types.clone(),
+        ts_patterns.clone(),
+        ts_types.clone(),
+        ret.clone(),
+    ));
+    func.extend(make_preprocess_fn(
+        patterns,
+        types,
+        ts_patterns,
+        ts_types,
+        ret,
+    ));
     func
 }
 
@@ -75,7 +93,11 @@ fn make_build_fn(
     let types = types.iter().map(|t| TokenStream2::from(t.clone()));
     let ts_patterns = TokenStream2::from(ts_patterns);
     let ts_types = TokenStream2::from(ts_types);
-    let ret = if ret.is_empty() { quote!{ () } } else { TokenStream2::from(ret) };
+    let ret = if ret.is_empty() {
+        quote! { () }
+    } else {
+        TokenStream2::from(ret)
+    };
 
     let imports = make_imports();
 
@@ -109,7 +131,8 @@ fn make_build_fn(
 
             (prove_closure, verify_closure)
         }
-    }.into()
+    }
+    .into()
 }
 
 fn make_preprocess_fn(
@@ -123,7 +146,11 @@ fn make_preprocess_fn(
     let types = types.iter().map(|t| TokenStream2::from(t.clone()));
     let ts_patterns = TokenStream2::from(ts_patterns);
     let ts_types = TokenStream2::from(ts_types);
-    let ret = if ret.is_empty() { quote!{ () } } else { TokenStream2::from(ret) };
+    let ret = if ret.is_empty() {
+        quote! { () }
+    } else {
+        TokenStream2::from(ret)
+    };
 
     let imports = make_imports();
 
@@ -159,7 +186,8 @@ fn make_preprocess_fn(
 
             (program, preprocessing)
         }
-    }.into()
+    }
+    .into()
 }
 
 fn make_imports() -> TokenStream2 {
diff --git a/zkvms/nexus/guest/src/main.rs b/zkvms/nexus/guest/src/main.rs
index bb2e0c8..fd7c1d5 100644
--- a/zkvms/nexus/guest/src/main.rs
+++ b/zkvms/nexus/guest/src/main.rs
@@ -1,9 +1,9 @@
 #![cfg_attr(target_arch = "riscv32", no_std, no_main, allow(unused_imports))]
 
-use nexus_rt::{ postcard, println, read_private_input, write_output };
+use nexus_rt::{postcard, println, read_private_input, write_output};
 
 extern crate alloc;
-use alloc::{ vec::*, collections::* };
+use alloc::{collections::*, vec::*};
 use wrapper_macro::make_wrapper;
 
 #[nexus_rt::main]
diff --git a/zkvms/nexus/host/src/main.rs b/zkvms/nexus/host/src/main.rs
index deef6b6..1a3f05a 100644
--- a/zkvms/nexus/host/src/main.rs
+++ b/zkvms/nexus/host/src/main.rs
@@ -1,9 +1,12 @@
-use zkvms_host_io::{Input, Output, read_args, benchmarkable, RunType::{ Execute, Prove, Verify }};
 use nexus_sdk::{
     compile::CompileOpts,
     nova::seq::{Generate, Nova, PP},
     Local, Prover, Verifiable,
 };
+use zkvms_host_io::{
+    benchmarkable, read_args, Input, Output,
+    RunType::{Execute, Prove, Verify},
+};
 
 fn main() {
     let run_info = read_args();
@@ -18,7 +21,7 @@ fn main() {
 
     match run_info.run_type {
         Execute => unreachable!(),
-        Prove => benchmarkable!{
+        Prove => benchmarkable! {
             // Nova<T> doesn't derive Clone
             println!("Loading guest...");
             let prover: Nova<Local> = Nova::new_from_file(&elf_path).expect("failed to load guest program");
@@ -40,7 +43,8 @@ fn main() {
         Verify => {
             // Nova<T> doesn't derive Clone
             println!("Loading guest...");
-            let prover: Nova<Local> = Nova::new_from_file(&elf_path).expect("failed to load guest program");
+            let prover: Nova<Local> =
+                Nova::new_from_file(&elf_path).expect("failed to load guest program");
 
             println!("Proving execution of vm...");
             let proof = prover
@@ -50,9 +54,9 @@ fn main() {
             println!(
                 " output is {:?}!",
                 proof
-                .output::<Output>()
-                .expect("failed to deserialize output")
-                );
+                    .output::<Output>()
+                    .expect("failed to deserialize output")
+            );
 
             println!(">>>>> Logging\n{}<<<<<", proof.logs().join(""));
 
@@ -60,6 +64,6 @@ fn main() {
                 print!("Verifying execution...");
                 proof.verify(&pp).expect("failed to verify proof");
             }
-        },
+        }
     }
 }
diff --git a/zkvms/nexus/wrapper_macro/src/lib.rs b/zkvms/nexus/wrapper_macro/src/lib.rs
index fd3a20d..324ace8 100644
--- a/zkvms/nexus/wrapper_macro/src/lib.rs
+++ b/zkvms/nexus/wrapper_macro/src/lib.rs
@@ -2,7 +2,7 @@ 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 };
+use crate::parse_fn::{args_divide_grouped, args_divide_public, args_split, split_fn};
 
 /// Creates a body, which reads all inputs, stores them in variables, then
 /// writes the ones, defined as public in `default_public_input.toml` to the
@@ -37,13 +37,21 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
     let (ts_patterns, ts_types) = args_divide_grouped(&args);
 
     let mut out = TokenStream::new();
-    out.extend(format!("let {} = read_private_input::<{}>().unwrap();", ts_patterns, ts_types).parse::<TokenStream>());
-
-    let public_inputs = toml::from_str::<toml::Table>(
-            include_str!(concat!(env!("INPUTS_DIR"), "/default_public_input.toml"))
+    out.extend(
+        format!(
+            "let {} = read_private_input::<{}>().unwrap();",
+            ts_patterns, ts_types
         )
-        .unwrap();
-    let (public_patterns, public_types) = args_divide_public(&args, &public_inputs.keys().collect()).0;
+        .parse::<TokenStream>(),
+    );
+
+    let public_inputs = toml::from_str::<toml::Table>(include_str!(concat!(
+        env!("INPUTS_DIR"),
+        "/default_public_input.toml"
+    )))
+    .unwrap();
+    let (public_patterns, public_types) =
+        args_divide_public(&args, &public_inputs.keys().collect()).0;
     let public_patterns: Vec<(TokenStream, TokenStream)> = public_patterns
         .into_iter()
         .zip(public_types.into_iter())
@@ -52,7 +60,9 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
         out.extend(format!("write_output::<{}>(&{});", ptype, pattern).parse::<TokenStream>());
     }
 
-    out.extend(format!("write_output::<{}>(&zkp::{}{});", ret, name, ts_patterns).parse::<TokenStream>());
+    out.extend(
+        format!("write_output::<{}>(&zkp::{}{});", ret, name, ts_patterns).parse::<TokenStream>(),
+    );
 
     let mut block = TokenStream::new();
     block.extend(format!("{{ {} }}", out).parse::<TokenStream>());
diff --git a/zkvms/risc0/guest/src/main.rs b/zkvms/risc0/guest/src/main.rs
index 2097259..796c663 100644
--- a/zkvms/risc0/guest/src/main.rs
+++ b/zkvms/risc0/guest/src/main.rs
@@ -1,6 +1,6 @@
-use wrapper_macro::make_wrapper;
-use risc0_zkvm::guest::env::{ read, commit };
+use risc0_zkvm::guest::env::{commit, read};
 use std::collections::*;
+use wrapper_macro::make_wrapper;
 
 fn main() {
     zkp::entrypoint_expr!()
diff --git a/zkvms/risc0/host/src/main.rs b/zkvms/risc0/host/src/main.rs
index c214c4e..e61692b 100644
--- a/zkvms/risc0/host/src/main.rs
+++ b/zkvms/risc0/host/src/main.rs
@@ -1,7 +1,10 @@
-use zkvms_host_io::{Input, Output, foreach_input_field, benchmarkable, read_args, RunType::{ Execute, Prove, Verify }};
-use risc0_zkvm::{default_prover, default_executor, ExecutorEnv, Receipt};
-use risc0_zkp::core::digest::Digest;
 use hex::FromHex;
+use risc0_zkp::core::digest::Digest;
+use risc0_zkvm::{default_executor, default_prover, ExecutorEnv, Receipt};
+use zkvms_host_io::{
+    benchmarkable, foreach_input_field, read_args, Input, Output,
+    RunType::{Execute, Prove, Verify},
+};
 
 // https://github.com/risc0/risc0/blob/881e512732eca72849b2d0e263a1242aba3158af/risc0/build/src/lib.rs#L280-L284
 static HELLO_GUEST_ELF: &[u8] = include_bytes!("./guest");
@@ -11,7 +14,7 @@ static HELLO_GUEST_ID: &str = env!("GUEST_ID");
 
 fn build_env(input: &Input) -> ExecutorEnv {
     let mut builder = ExecutorEnv::builder();
-    foreach_input_field!{
+    foreach_input_field! {
         builder.write(&input.yield).unwrap();
     }
     builder.build().unwrap()
@@ -25,10 +28,7 @@ fn prove(env: ExecutorEnv) -> Receipt {
 }
 
 fn journal(receipt: Receipt) -> Output {
-    receipt
-        .journal
-        .decode()
-        .unwrap()
+    receipt.journal.decode().unwrap()
 }
 
 fn main() {
@@ -56,7 +56,7 @@ fn main() {
             let receipt = prove(env);
             println!("Output from journal: {:?}", journal(receipt));
         },
-        Verify => benchmarkable!{
+        Verify => benchmarkable! {
             // https://github.com/risc0/risc0/blob/881e512732eca72849b2d0e263a1242aba3158af/risc0/build/src/lib.rs#L197-L199
             let guest_id: Digest = Digest::from_hex(HELLO_GUEST_ID).unwrap();
 
diff --git a/zkvms/risc0/wrapper_macro/src/lib.rs b/zkvms/risc0/wrapper_macro/src/lib.rs
index 24eddd4..7fa328b 100644
--- a/zkvms/risc0/wrapper_macro/src/lib.rs
+++ b/zkvms/risc0/wrapper_macro/src/lib.rs
@@ -2,7 +2,7 @@ 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 };
+use crate::parse_fn::{args_divide_grouped, args_divide_public, args_split, split_fn};
 
 /// Create a body, which reads all inputs, stores them in variables, then
 /// commits the ones, defined as public in `default_public_input.toml` to the
@@ -40,11 +40,14 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
         out.extend(format!("let {} = read();", arg).parse::<TokenStream>());
     }
 
-    let public_inputs = toml::from_str::<toml::Table>(
-            include_str!(concat!(env!("INPUTS_DIR"), "/default_public_input.toml"))
-        )
-        .unwrap();
-    let public_patterns = args_divide_public(&args, &public_inputs.keys().collect()).0.0;
+    let public_inputs = toml::from_str::<toml::Table>(include_str!(concat!(
+        env!("INPUTS_DIR"),
+        "/default_public_input.toml"
+    )))
+    .unwrap();
+    let public_patterns = args_divide_public(&args, &public_inputs.keys().collect())
+        .0
+         .0;
     for pattern in public_patterns.iter() {
         out.extend(format!("commit(&{});", pattern).parse::<TokenStream>());
     }
diff --git a/zkvms/sp1/guest/src/main.rs b/zkvms/sp1/guest/src/main.rs
index 0ca4618..079e0ce 100644
--- a/zkvms/sp1/guest/src/main.rs
+++ b/zkvms/sp1/guest/src/main.rs
@@ -1,9 +1,9 @@
 #![no_main]
 
-use wrapper_macro::make_wrapper;
 use sp1_zkvm::io::read;
 use sp1_zkvm::lib::io::commit;
 use std::collections::*;
+use wrapper_macro::make_wrapper;
 
 sp1_zkvm::entrypoint!(main);
 
diff --git a/zkvms/sp1/host/src/main.rs b/zkvms/sp1/host/src/main.rs
index 50e9d1a..6d19000 100644
--- a/zkvms/sp1/host/src/main.rs
+++ b/zkvms/sp1/host/src/main.rs
@@ -1,12 +1,15 @@
-use zkvms_host_io::{Input, foreach_input_field, benchmarkable, read_args, RunType::{ Execute, Prove, Verify }};
-use sp1_sdk::{ProverClient, EnvProver, SP1Stdin, SP1ProofWithPublicValues, SP1VerifyingKey};
+use sp1_sdk::{EnvProver, ProverClient, SP1ProofWithPublicValues, SP1Stdin, SP1VerifyingKey};
+use zkvms_host_io::{
+    benchmarkable, foreach_input_field, read_args, Input,
+    RunType::{Execute, Prove, Verify},
+};
 
 /// The ELF (executable and linkable format) file for the Succinct RISC-V zkVM.
 pub const FIBONACCI_ELF: &[u8] = include_bytes!("./guest");
 
 fn build_stdin(input: &Input) -> SP1Stdin {
     let mut stdin = SP1Stdin::new();
-    foreach_input_field!{
+    foreach_input_field! {
         stdin.write(&input.yield);
     }
     stdin
@@ -29,14 +32,14 @@ fn main() {
     let client = ProverClient::new();
 
     match run_info.run_type {
-        Execute => benchmarkable!{
+        Execute => benchmarkable! {
             let (output, report) = client.execute(FIBONACCI_ELF, &stdin).run().unwrap();
 
             println!("Program executed successfully.");
             println!("{:?}", output);
             println!("Number of cycles: {}", report.total_instruction_count());
         },
-        Prove => benchmarkable!{
+        Prove => benchmarkable! {
             let _ = prove(&client, stdin.clone());
             println!("Successfully generated proof!");
         },
@@ -44,10 +47,10 @@ fn main() {
             let (proof, vk) = prove(&client, stdin.clone());
             println!("Successfully generated proof!");
 
-            benchmarkable!{
+            benchmarkable! {
                 client.verify(&proof, &vk).expect("failed to verify proof");
                 println!("Successfully verified proof!");
             }
-        },
+        }
     }
 }
diff --git a/zkvms/sp1/wrapper_macro/src/lib.rs b/zkvms/sp1/wrapper_macro/src/lib.rs
index e8393b2..14dcfad 100644
--- a/zkvms/sp1/wrapper_macro/src/lib.rs
+++ b/zkvms/sp1/wrapper_macro/src/lib.rs
@@ -2,7 +2,7 @@ use proc_macro::TokenStream;
 
 #[path = "../../../../guests_macro/src/parse_fn.rs"]
 mod parse_fn;
-use crate::parse_fn::{ split_fn, args_split, args_divide_grouped };
+use crate::parse_fn::{args_divide_grouped, args_split, split_fn};
 
 /// Create a body, which reads all inputs, stores them in variables, then
 /// commits the ones, defined as public in `default_public_input.toml` to the
@@ -40,10 +40,11 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
         out.extend(format!("let {} = read();", arg).parse::<TokenStream>());
     }
 
-    let public_inputs = toml::from_str::<toml::Table>(
-            include_str!(concat!(env!("INPUTS_DIR"), "/default_public_input.toml"))
-        )
-        .unwrap();
+    let public_inputs = toml::from_str::<toml::Table>(include_str!(concat!(
+        env!("INPUTS_DIR"),
+        "/default_public_input.toml"
+    )))
+    .unwrap();
     for input in public_inputs.keys() {
         out.extend(format!("commit(&{});", input).parse::<TokenStream>());
     }
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
diff --git a/zkvms/zkwasm/guest/src/lib.rs b/zkvms/zkwasm/guest/src/lib.rs
index 219c3a4..5bb69f7 100644
--- a/zkvms/zkwasm/guest/src/lib.rs
+++ b/zkvms/zkwasm/guest/src/lib.rs
@@ -1,5 +1,5 @@
 use wasm_bindgen::prelude::wasm_bindgen;
-use wrapper_macro::{ make_wrapper, read };
+use wrapper_macro::{make_wrapper, read};
 // https://github.com/DelphinusLab/zkWasm-rust/blob/main/src/lib.rs
 use zkwasm_rust_sdk::{require, wasm_input, wasm_output};
 
@@ -15,11 +15,15 @@ fn read_public() -> u64 {
 }
 
 fn assert(cond: bool) {
-    unsafe { require(cond); }
+    unsafe {
+        require(cond);
+    }
 }
 
 fn write(value: u64) {
-    unsafe { wasm_output(value); }
+    unsafe {
+        wasm_output(value);
+    }
 }
 
 #[wasm_bindgen]
diff --git a/zkvms/zkwasm/host/src/main.rs b/zkvms/zkwasm/host/src/main.rs
index 7ada9e0..817def5 100644
--- a/zkvms/zkwasm/host/src/main.rs
+++ b/zkvms/zkwasm/host/src/main.rs
@@ -1,6 +1,11 @@
-use zkvms_host_io::{PublicInput, PrivateInput, foreach_public_input_field, foreach_private_input_field, benchmarkable, read_args, RunType::{Execute, Prove, Verify}, RunWith};
 use std::io::{self, Write};
 use std::process::{Command, Stdio};
+use zkvms_host_io::{
+    benchmarkable, foreach_private_input_field, foreach_public_input_field, read_args,
+    PrivateInput, PublicInput,
+    RunType::{Execute, Prove, Verify},
+    RunWith,
+};
 
 static PUBLIC_INPUT_PATH: &str = "public_input.bin";
 static PRIVATE_INPUT_PATH: &str = "private_input.bin";
@@ -12,13 +17,8 @@ static PRIVATE_INPUT_PATH: &str = "private_input.bin";
 /// If `flat` is "[[0,1], [2,3,4], []]"
 /// Output will be "3[2[0,1], 3[2,3,4], 0[]]"
 fn get_with_sizes(flat: &str) -> String {
-    let mut values = flat
-        .split('[')
-        .map(|x| x.trim())
-        .skip(1);
-    let current = values
-        .next()
-        .unwrap_or(flat);
+    let mut values = flat.split('[').map(|x| x.trim()).skip(1);
+    let current = values.next().unwrap_or(flat);
 
     // 1D collection or not a collection
     if current != "" {
@@ -30,26 +30,21 @@ fn get_with_sizes(flat: &str) -> String {
             .map(|x| (x == ',') as usize)
             .sum::<usize>();
 
-        (if size > 1 { size.to_string() } else { String::new() })
-            + "["
+        (if size > 1 {
+            size.to_string()
+        } else {
+            String::new()
+        }) + "["
             + current
-            + &values
-                .map(|x| "[".to_string() + x)
-                .collect::<String>()
+            + &values.map(|x| "[".to_string() + x).collect::<String>()
     }
     // ND collection
     else {
-        let size: usize = values
-            .clone()
-            .count();
+        let size: usize = values.clone().count();
 
-        let subcollections = values
-            .map(|x| get_with_sizes(x))
-            .collect::<String>();
+        let subcollections = values.map(|x| get_with_sizes(x)).collect::<String>();
 
-        size.to_string()
-            + "["
-            + &subcollections
+        size.to_string() + "[" + &subcollections
     }
 }
 
@@ -66,7 +61,7 @@ macro_rules! build_input {
     ($input:expr , $path:ident , $type:ident) => {
         |run_info: &RunWith| {
             let mut ret: Vec<u64> = Vec::new();
-            $type!{
+            $type! {
                 // Simplify input string
                 let flat = format!("{:?}", $input.yield)
                     .replace("false", "0")
@@ -118,9 +113,12 @@ macro_rules! build_input {
 fn zkwasm_command(subcmd: &str) -> Command {
     let mut command = Command::new("zkwasm-cli");
     command
-        .arg("--params").arg("./params")
-        .arg("prog").arg(subcmd)
-        .arg("--wasm").arg(env!("GUEST_PATH"));
+        .arg("--params")
+        .arg("./params")
+        .arg("prog")
+        .arg(subcmd)
+        .arg("--wasm")
+        .arg(env!("GUEST_PATH"));
     command
 }
 
@@ -131,52 +129,40 @@ fn run(cmd: &mut Command) {
 fn main() {
     let run_info = read_args();
 
-    let k = run_info
-        .env_or(
-            "ZKWASM_K",
-            "19",
-        );
+    let k = run_info.env_or("ZKWASM_K", "19");
 
-    let scheme = run_info
-        .env_or(
-            "ZKWASM_SCHEME",
-            "shplonk",
-        );
+    let scheme = run_info.env_or("ZKWASM_SCHEME", "shplonk");
 
     run(zkwasm_command("setup")
-        .arg("-k").arg(k)
-        .arg("--scheme").arg(scheme));
+        .arg("-k")
+        .arg(k)
+        .arg("--scheme")
+        .arg(scheme));
 
     let public_input = build_input!(
         run_info.public_input,
         PUBLIC_INPUT_PATH,
-        foreach_public_input_field)(&run_info);
+        foreach_public_input_field
+    )(&run_info);
 
     let private_input = build_input!(
         run_info.private_input,
         PRIVATE_INPUT_PATH,
-        foreach_private_input_field)(&run_info);
+        foreach_private_input_field
+    )(&run_info);
 
-    let output = run_info
-        .env_or(
-            "ZKWASM_OUTPUT",
-            "./output",
-        );
+    let output = run_info.env_or("ZKWASM_OUTPUT", "./output");
 
-    let params = run_info
-        .env_or(
-            "ZKWASM_PARAMS",
-            "./params",
-        );
+    let params = run_info.env_or("ZKWASM_PARAMS", "./params");
 
     match run_info.run_type {
-        Execute => benchmarkable!{
+        Execute => benchmarkable! {
             run(zkwasm_command("dry-run")
                 .arg("--public").arg(public_input.clone())
                 .arg("--private").arg(private_input.clone())
                 .arg("--output").arg(output.clone()));
         },
-        Prove => benchmarkable!{
+        Prove => benchmarkable! {
             run(zkwasm_command("prove")
                 .arg("--public").arg(public_input.clone())
                 .arg("--private").arg(private_input.clone())
@@ -184,16 +170,19 @@ fn main() {
         },
         Verify => {
             run(zkwasm_command("prove")
-                .arg("--public").arg(public_input)
-                .arg("--private").arg(private_input)
-                .arg("--output").arg(output.clone()));
-
-            benchmarkable!{
+                .arg("--public")
+                .arg(public_input)
+                .arg("--private")
+                .arg(private_input)
+                .arg("--output")
+                .arg(output.clone()));
+
+            benchmarkable! {
                 run(Command::new("zkwasm-cli")
                     .arg("--params").arg(params.clone())
                     .arg("prog").arg("verify")
                     .arg("--output").arg(output.clone()));
             }
-        },
+        }
     }
 }
diff --git a/zkvms/zkwasm/wrapper_macro/src/lib.rs b/zkvms/zkwasm/wrapper_macro/src/lib.rs
index 8bdb581..288eddb 100644
--- a/zkvms/zkwasm/wrapper_macro/src/lib.rs
+++ b/zkvms/zkwasm/wrapper_macro/src/lib.rs
@@ -1,8 +1,8 @@
-use proc_macro::{ TokenStream, TokenTree, Ident };
+use proc_macro::{Ident, TokenStream, TokenTree};
 
 #[path = "../../../../guests_macro/src/parse_fn.rs"]
 mod parse_fn;
-use crate::parse_fn::{ split_fn, args_divide_grouped, args_divide_public, group_streams };
+use crate::parse_fn::{args_divide_grouped, args_divide_public, group_streams, split_fn};
 use toml::Table;
 
 /// Extends an out TokenStream with `let` directives for all patterns (and
@@ -11,12 +11,21 @@ use toml::Table;
 /// Each `let` binding calls the read! macro (defined in zkWasm wrapper_macro
 /// crate), feeding it an autogenerated "type note", which is then used to
 /// "deserialize" the input.
-fn insert_reads(out: &mut TokenStream, patterns: &Vec<TokenStream>, types: &Vec<TokenStream>, readfn: &str) {
+fn insert_reads(
+    out: &mut TokenStream,
+    patterns: &Vec<TokenStream>,
+    types: &Vec<TokenStream>,
+    readfn: &str,
+) {
     for i in 0..patterns.len() {
-        let type_note: String = format!("{}", types[i])
-            .replace('<', "[")
-            .replace('>', "]");
-        out.extend(format!("let {} : {} = read!({} {});", patterns[i], types[i], readfn, type_note).parse::<TokenStream>());
+        let type_note: String = format!("{}", types[i]).replace('<', "[").replace('>', "]");
+        out.extend(
+            format!(
+                "let {} : {} = read!({} {});",
+                patterns[i], types[i], readfn, type_note
+            )
+            .parse::<TokenStream>(),
+        );
     }
 }
 
@@ -50,11 +59,13 @@ fn insert_reads(out: &mut TokenStream, patterns: &Vec<TokenStream>, types: &Vec<
 pub fn make_wrapper(item: TokenStream) -> TokenStream {
     let (name, args, ret) = split_fn(&item);
 
-    let public_inputs = toml::from_str::<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::<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 mut out = TokenStream::new();
 
@@ -63,10 +74,16 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
 
     let (ts_patterns, _) = args_divide_grouped(&args);
 
-    out.extend(format!("
+    out.extend(
+        format!(
+            "
         let result = zkp::{}{};
         write(result as u64);
-    ", name, ts_patterns).parse::<TokenStream>());
+    ",
+            name, ts_patterns
+        )
+        .parse::<TokenStream>(),
+    );
 
     let mut block = TokenStream::new();
     block.extend(format!("{{ {} }}", out).parse::<TokenStream>());
@@ -74,25 +91,38 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
 }
 
 fn return_primitive(readfn: &TokenTree, typ: &Ident) -> TokenStream {
-    format!("
+    format!(
+        "
         ({readfn}() as {typ})
-    ").parse().unwrap()
+    "
+    )
+    .parse()
+    .unwrap()
 }
 
 fn return_bool(readfn: &TokenTree) -> TokenStream {
-    format!("
+    format!(
+        "
         ({readfn}() != 0)
-    ").parse().unwrap()
+    "
+    )
+    .parse()
+    .unwrap()
 }
 
 fn return_char(readfn: &TokenTree) -> TokenStream {
-    format!("
+    format!(
+        "
         (({readfn}() as u8) as char)
-    ").parse().unwrap()
+    "
+    )
+    .parse()
+    .unwrap()
 }
 
 fn return_string(readfn: &TokenTree) -> TokenStream {
-    format!("
+    format!(
+        "
         {{
              let mut ret = Vec::new();
              let size = read!({readfn} usize);
@@ -101,11 +131,15 @@ fn return_string(readfn: &TokenTree) -> TokenStream {
              }}
              ret.into_iter().collect()
         }}
-    ").parse().unwrap()
+    "
+    )
+    .parse()
+    .unwrap()
 }
 
 fn return_array(readfn: &TokenTree, inner: &TokenStream) -> TokenStream {
-    format!("
+    format!(
+        "
         {{
              let mut ret = Vec::new();
              let size = read!({readfn} usize);
@@ -114,11 +148,20 @@ fn return_array(readfn: &TokenTree, inner: &TokenStream) -> TokenStream {
              }}
              ret.try_into().unwrap()
         }}
-    ").parse().unwrap()
+    "
+    )
+    .parse()
+    .unwrap()
 }
 
-fn return_cont(readfn: &TokenTree, container: &Ident, pushfn: &str, inner: &TokenStream) -> TokenStream {
-    format!("
+fn return_cont(
+    readfn: &TokenTree,
+    container: &Ident,
+    pushfn: &str,
+    inner: &TokenStream,
+) -> TokenStream {
+    format!(
+        "
         {{
              let mut ret = {container}::new();
              let size = read!({readfn} usize);
@@ -127,7 +170,10 @@ fn return_cont(readfn: &TokenTree, container: &Ident, pushfn: &str, inner: &Toke
              }}
              ret
         }}
-    ").parse().unwrap()
+    "
+    )
+    .parse()
+    .unwrap()
 }
 
 fn return_hashmap(readfn: &TokenTree, container: &Ident, inner: &TokenStream) -> TokenStream {
@@ -135,7 +181,8 @@ fn return_hashmap(readfn: &TokenTree, container: &Ident, inner: &TokenStream) ->
     let key_type = inner.next().unwrap();
     inner.next().unwrap();
     let value_type = inner.next().unwrap();
-    format!(r#"
+    format!(
+        r#"
         {{
              let mut ret = {container}::new();
              let size = read!({readfn} usize);
@@ -144,7 +191,10 @@ fn return_hashmap(readfn: &TokenTree, container: &Ident, inner: &TokenStream) ->
              }}
              ret
         }}
-    "#).parse().unwrap()
+    "#
+    )
+    .parse()
+    .unwrap()
 }
 
 fn return_tuple(readfn: &TokenTree, inner: &TokenStream) -> TokenStream {
@@ -152,12 +202,16 @@ fn return_tuple(readfn: &TokenTree, inner: &TokenStream) -> TokenStream {
     for subtype in inner.clone().into_iter() {
         value += &format!("read!({readfn} {subtype}), ");
     }
-    format!("
+    format!(
+        "
         {{
              let _ = read!({readfn} usize);
              ( {value} )
         }}
-    ").parse().unwrap()
+    "
+    )
+    .parse()
+    .unwrap()
 }
 
 /// Creates a body which returns a value of the type, defined as a "type note"
@@ -181,41 +235,32 @@ pub fn read(item: TokenStream) -> TokenStream {
         // Primitive or STD Container
         TokenTree::Ident(ident) => {
             match ident.to_string().as_str() {
-                "u8" | "u16" | "u32" | "u64" | "u128" | "usize" |
-                "i8" | "i16" | "i32" | "i64" | "i128" | "isize" |
-                "f32" | "f64" =>
-                    return return_primitive(&readfn, &ident),
-                "char" =>
-                    return return_char(&readfn),
-                "bool" =>
-                    return return_bool(&readfn),
-                "String" =>
-                    return return_string(&readfn),
-                _ => {},
+                "u8" | "u16" | "u32" | "u64" | "u128" | "usize" | "i8" | "i16" | "i32" | "i64"
+                | "i128" | "isize" | "f32" | "f64" => return return_primitive(&readfn, &ident),
+                "char" => return return_char(&readfn),
+                "bool" => return return_bool(&readfn),
+                "String" => return return_string(&readfn),
+                _ => {}
             }
 
-            let mut group = parts.next()
+            let mut group = parts
+                .next()
                 .expect(format!("No group after \"{ident}\" while parsing \"{item}\"!").as_str());
             if let TokenTree::Group(inner_group) = group {
                 let rest = inner_group.stream();
 
                 match ident.to_string().as_str() {
                     // https://doc.rust-lang.org/std/collections/
-                    "Vec" | "BinaryHeap" =>
-                        return_cont(&readfn, &ident, "push", &rest),
-                    "VecDeque" | "LinkedList" =>
-                        return_cont(&readfn, &ident, "push_back", &rest),
-                    "HashSet" | "BTreeSet" =>
-                        return_cont(&readfn, &ident, "insert", &rest),
-                    "HashMap" | "BTreeMap" =>
-                        return_hashmap(&readfn, &ident, &rest),
+                    "Vec" | "BinaryHeap" => return_cont(&readfn, &ident, "push", &rest),
+                    "VecDeque" | "LinkedList" => return_cont(&readfn, &ident, "push_back", &rest),
+                    "HashSet" | "BTreeSet" => return_cont(&readfn, &ident, "insert", &rest),
+                    "HashMap" | "BTreeMap" => return_hashmap(&readfn, &ident, &rest),
                     _ => todo!("Unsupported container {ident}"),
                 }
-            }
-            else {
+            } else {
                 unreachable!("{group} is not a TokenTree::Group!");
             }
-        },
+        }
         // Array or tuple
         TokenTree::Group(group) => {
             let mut group = group.stream().into_iter();
@@ -224,19 +269,19 @@ pub fn read(item: TokenStream) -> TokenStream {
                 match current {
                     TokenTree::Punct(punct) => match punct.as_char() {
                         // Array
-                        ';' =>
-                            return return_array(&readfn, &inner),
+                        ';' => return return_array(&readfn, &inner),
                         // Tuple
                         ',' => continue,
                         _ => unreachable!("Group contains unexpected \"{punct}\""),
                     },
-                    TokenTree::Ident(_) | TokenTree::Group(_) =>
-                        inner.extend([current].into_iter()),
+                    TokenTree::Ident(_) | TokenTree::Group(_) => {
+                        inner.extend([current].into_iter())
+                    }
                     _ => unreachable!(),
                 }
             }
             return_tuple(&readfn, &inner)
-        },
+        }
         _ => unreachable!(),
     }
 }