chore: Rust fmt

23 files changed, 459 insertions, 320 deletions

diff --git a/guests/graph_coloring/src/lib.rs b/guests/graph_coloring/src/lib.rs
index a0cdd3a..2fd0050 100644
--- a/guests/graph_coloring/src/lib.rs
+++ b/guests/graph_coloring/src/lib.rs
@@ -6,11 +6,7 @@ extern crate alloc;
 use alloc::vec::Vec;
 
 #[guests_macro::proving_entrypoint]
-pub fn main(
-    graph: Vec<Vec<bool>>,
-    colors: u32,
-    coloring: Vec<[u32; 2]>,
-) -> bool {
+pub fn main(graph: Vec<Vec<bool>>, colors: u32, coloring: Vec<[u32; 2]>) -> bool {
     // Does it use the correct amount of colors?
     let mut max_color = coloring[0][1];
     for nc in &coloring {
@@ -25,7 +21,7 @@ pub fn main(
     for i in 0..graph.len() {
         for j in 0..graph.len() {
             // graph[i][j] -> coloring[i] != coloring[j]
-            ret = ret & (! graph[i][j] | (coloring[i][1] != coloring[j][1]));
+            ret = ret & (!graph[i][j] | (coloring[i][1] != coloring[j][1]));
         }
     }
 
diff --git a/guests_macro/src/lib.rs b/guests_macro/src/lib.rs
index 30bfec7..2a35292 100644
--- a/guests_macro/src/lib.rs
+++ b/guests_macro/src/lib.rs
@@ -1,5 +1,5 @@
-use std::{ fs::File, io::Write };
 use proc_macro::TokenStream;
+use std::{fs::File, io::Write};
 mod parse_fn;
 
 /// Create an `entrypoint_expr` macro inside the guest program. This will be
@@ -45,11 +45,17 @@ pub fn proving_entrypoint(_: TokenStream, mut item: TokenStream) -> TokenStream
     writeln!(output, "{}", &format!("{args}").replace('\n', " "));
     write!(output, "{}", &format!("{ret}").replace('\n', " "));
 
-    item.extend(format!("#[macro_export]
+    item.extend(
+        format!(
+            "#[macro_export]
         macro_rules! entrypoint_expr {{
             () => {{
                 make_wrapper!{{{}{} -> {}}}
             }};
-        }}", name, args, ret).parse::<TokenStream>());
+        }}",
+            name, args, ret
+        )
+        .parse::<TokenStream>(),
+    );
     item
 }
diff --git a/guests_macro/src/parse_fn.rs b/guests_macro/src/parse_fn.rs
index 87b0073..2db81fa 100644
--- a/guests_macro/src/parse_fn.rs
+++ b/guests_macro/src/parse_fn.rs
@@ -5,7 +5,7 @@
 //! Therefore, it should be used in ZKVM wrapper_macro crates, via a [mod path
 //! attribute](https://doc.rust-lang.org/reference/items/modules.html#the-path-attribute).
 
-use proc_macro::{ TokenStream, TokenTree, Delimiter, Spacing, Group };
+use proc_macro::{Delimiter, Group, Spacing, TokenStream, TokenTree};
 
 /// Split function definition into triplet of name, arguments and output types.
 ///
@@ -16,7 +16,7 @@ pub fn split_fn(item: &TokenStream) -> (TokenStream, TokenStream, TokenStream) {
 
     let mut name = TokenStream::new();
     let mut args = TokenStream::new();
-    let mut ret  = TokenStream::new();
+    let mut ret = TokenStream::new();
     let mut out: &mut TokenStream = &mut name;
 
     for tt in item {
@@ -27,7 +27,7 @@ pub fn split_fn(item: &TokenStream) -> (TokenStream, TokenStream, TokenStream) {
                 if ident.to_string() == "fn" || ident.to_string() == "pub" {
                     continue;
                 }
-            },
+            }
             TokenTree::Punct(ref punct) => {
                 if punct.as_char() == '-' {
                     out = &mut ret;
@@ -36,15 +36,15 @@ pub fn split_fn(item: &TokenStream) -> (TokenStream, TokenStream, TokenStream) {
                 if punct.as_char() == '>' && out.is_empty() {
                     continue;
                 }
-            },
+            }
             TokenTree::Group(ref group) => {
                 if group.delimiter() == Delimiter::Brace {
                     break;
                 }
-                if ! out.is_empty() {
+                if !out.is_empty() {
                     out = &mut args;
                 }
-            },
+            }
             TokenTree::Literal(_) => unreachable!("Cannot have literal inside def!"),
         }
         out.extend([tt].into_iter());
@@ -62,8 +62,7 @@ pub fn args_split(item: &TokenStream) -> Vec<TokenStream> {
     let contents;
     if let TokenTree::Group(group) = item.clone().into_iter().next().unwrap() {
         contents = group.stream().into_iter();
-    }
-    else {
+    } else {
         unreachable!("Item passed to args_split is not a group: \"{item}\"");
     }
 
@@ -74,25 +73,27 @@ pub fn args_split(item: &TokenStream) -> Vec<TokenStream> {
     for tt in contents {
         match tt {
             TokenTree::Punct(ref punct) => match punct.as_char() {
-                    // < and > do **not** form TokenTree groups, however their
-                    // usage is like that of a group. Hence, we need extra
-                    // logic to skip them.
-                    '<' => angle_level += 1,
-                    '>' => angle_level -= 1,
-                    ',' => if angle_level == 0 {
+                // < and > do **not** form TokenTree groups, however their
+                // usage is like that of a group. Hence, we need extra
+                // logic to skip them.
+                '<' => angle_level += 1,
+                '>' => angle_level -= 1,
+                ',' => {
+                    if angle_level == 0 {
                         args.push(ts);
                         ts = TokenStream::new();
                         continue;
-                    },
-                    _ => {},
-                },
-            _ => {},
+                    }
+                }
+                _ => {}
+            },
+            _ => {}
         }
 
         ts.extend([tt].into_iter());
     }
 
-    if ! ts.is_empty() {
+    if !ts.is_empty() {
         args.push(ts);
     }
     args
@@ -105,7 +106,10 @@ pub fn args_split(item: &TokenStream) -> Vec<TokenStream> {
 ///
 /// **Input:**  "(p1 : t1, p2: t2, ...)", vec!["p3", "p4", ...]
 /// **Output:** vec!["p1 : t1", "p2: t2", ...], vec!["p3 : t3", "p4: t4", ...]
-pub fn args_split_public(item: &TokenStream, public: &Vec<&String>) -> (Vec<TokenStream>, Vec<TokenStream>) {
+pub fn args_split_public(
+    item: &TokenStream,
+    public: &Vec<&String>,
+) -> (Vec<TokenStream>, Vec<TokenStream>) {
     let all_args = args_split(item);
     let public_args: Vec<TokenStream> = all_args
         .clone()
@@ -114,7 +118,11 @@ pub fn args_split_public(item: &TokenStream, public: &Vec<&String>) -> (Vec<Toke
         .collect();
     let private_args: Vec<TokenStream> = all_args
         .into_iter()
-        .filter(|t| !public_args.iter().any(|pt| *t.to_string() == pt.to_string()))
+        .filter(|t| {
+            !public_args
+                .iter()
+                .any(|pt| *t.to_string() == pt.to_string())
+        })
         .collect();
     (public_args, private_args)
 }
@@ -128,8 +136,7 @@ pub fn args_divide(item: &TokenStream) -> (Vec<TokenStream>, Vec<TokenStream>) {
     let contents;
     if let TokenTree::Group(group) = item.clone().into_iter().next().unwrap() {
         contents = group.stream().into_iter();
-    }
-    else {
+    } else {
         unreachable!("Item passed to args_divide is not a group: \"{item}\"");
     }
 
@@ -145,8 +152,7 @@ pub fn args_divide(item: &TokenStream) -> (Vec<TokenStream>, Vec<TokenStream>) {
                 // Ignore "::"
                 if punct.spacing() == Spacing::Joint && punct.as_char() == ':' {
                     ignore_next = true;
-                }
-                else if !ignore_next {
+                } else if !ignore_next {
                     match punct.as_char() {
                         // < and > do **not** form TokenTree groups, however their
                         // usage is like that of a group. Hence, we need extra
@@ -157,20 +163,21 @@ pub fn args_divide(item: &TokenStream) -> (Vec<TokenStream>, Vec<TokenStream>) {
                             patterns.push(ts);
                             ts = TokenStream::new();
                             continue;
-                        },
-                        ',' => if angle_level == 0 {
-                            types.push(ts);
-                            ts = TokenStream::new();
-                            continue;
-                        },
-                        _ => {},
+                        }
+                        ',' => {
+                            if angle_level == 0 {
+                                types.push(ts);
+                                ts = TokenStream::new();
+                                continue;
+                            }
+                        }
+                        _ => {}
                     }
-                }
-                else {
+                } else {
                     ignore_next = false;
                 }
-            },
-            _ => {},
+            }
+            _ => {}
         }
 
         ts.extend([tt].into_iter());
@@ -187,7 +194,13 @@ pub fn args_divide(item: &TokenStream) -> (Vec<TokenStream>, Vec<TokenStream>) {
 ///
 /// **Input:**  "(p1 : t1, p2: t2, ...)", vec!["p3", "p4", ...]
 /// **Output:** (vec!["p1", "p2", ...], vec!["t1", "t2", ...]), (vec!["p3", "p4", ...], vec!["t3", "t4", ...])
-pub fn args_divide_public(item: &TokenStream, public: &Vec<&String>) -> ((Vec<TokenStream>, Vec<TokenStream>), (Vec<TokenStream>, Vec<TokenStream>)) {
+pub fn args_divide_public(
+    item: &TokenStream,
+    public: &Vec<&String>,
+) -> (
+    (Vec<TokenStream>, Vec<TokenStream>),
+    (Vec<TokenStream>, Vec<TokenStream>),
+) {
     let (patterns, types) = args_divide(item);
 
     let (public_patterns, public_types): (Vec<TokenStream>, Vec<TokenStream>) = patterns
@@ -200,9 +213,16 @@ pub fn args_divide_public(item: &TokenStream, public: &Vec<&String>) -> ((Vec<To
     let (private_patterns, private_types): (Vec<TokenStream>, Vec<TokenStream>) = patterns
         .into_iter()
         .zip(types.into_iter())
-        .filter(|(p, _)| !public_patterns.iter().any(|x| p.to_string() == x.to_string()))
+        .filter(|(p, _)| {
+            !public_patterns
+                .iter()
+                .any(|x| p.to_string() == x.to_string())
+        })
         .unzip();
-    ((public_patterns, public_types), (private_patterns, private_types))
+    (
+        (public_patterns, public_types),
+        (private_patterns, private_types),
+    )
 }
 
 /// Like `args_divide`, but group arguments and types (via `group_streams`).
@@ -220,10 +240,22 @@ pub fn args_divide_grouped(item: &TokenStream) -> (TokenStream, TokenStream) {
 /// **Output:** "(p1, p2, ...)"
 pub fn group_streams(patterns: &Vec<TokenStream>) -> TokenStream {
     let mut inner_ts = TokenStream::new();
-    inner_ts.extend(patterns.clone().into_iter().flat_map(|i| [",".parse().unwrap(), i]).skip(1));
+    inner_ts.extend(
+        patterns
+            .clone()
+            .into_iter()
+            .flat_map(|i| [",".parse().unwrap(), i])
+            .skip(1),
+    );
 
     let mut out = TokenStream::new();
-    out.extend([TokenTree::Group(Group::new(Delimiter::Parenthesis, inner_ts))].into_iter());
+    out.extend(
+        [TokenTree::Group(Group::new(
+            Delimiter::Parenthesis,
+            inner_ts,
+        ))]
+        .into_iter(),
+    );
 
     out
 }
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!(),
     }
 }
diff --git a/zkvms_host_io/input_macros/src/lib.rs b/zkvms_host_io/input_macros/src/lib.rs
index c3a34f7..60d3d48 100644
--- a/zkvms_host_io/input_macros/src/lib.rs
+++ b/zkvms_host_io/input_macros/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::{ args_split, args_split_public, args_divide, args_divide_public, group_streams };
+use crate::parse_fn::{
+    args_divide, args_divide_public, args_split, args_split_public, group_streams,
+};
 
 /// Parses the `guests/type.txt` type note, created from the guest
 /// Returns a tuple of the arguments group and the return type
@@ -10,7 +12,10 @@ fn get_types() -> (TokenStream, TokenStream) {
     let types: Vec<&str> = include_str!("../../../guests/type.txt")
         .split('\n')
         .collect();
-    (types[0].parse::<TokenStream>().unwrap(), types[1].parse::<TokenStream>().unwrap())
+    (
+        types[0].parse::<TokenStream>().unwrap(),
+        types[1].parse::<TokenStream>().unwrap(),
+    )
 }
 
 static DERIVES: &str = "#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]";
@@ -68,13 +73,14 @@ pub fn generate_output_type_input_struct(_: TokenStream) -> TokenStream {
     let (args, ret) = get_types();
     let (patterns, types) = args_divide(&args);
 
-    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();
     let public_types = args_divide_public(&args, &public_inputs.keys().collect())
         .0
-        .1
+         .1
         .iter()
         .map(|x| x.to_string() + ", ")
         .collect::<String>();
@@ -85,13 +91,18 @@ pub fn generate_output_type_input_struct(_: TokenStream) -> TokenStream {
         .iter()
         .map(|x| format!("pub {x},"))
         .collect::<String>();
-    let public_input_type = format!("{} pub struct PublicInput {{ {} }}", DERIVES, public_attrs).to_string();
+    let public_input_type =
+        format!("{} pub struct PublicInput {{ {} }}", DERIVES, public_attrs).to_string();
 
     let private_attrs = private_args
         .iter()
         .map(|x| format!("pub {x},"))
         .collect::<String>();
-    let private_input_type = format!("{} pub struct PrivateInput {{ {} }}", DERIVES, private_attrs).to_string();
+    let private_input_type = format!(
+        "{} pub struct PrivateInput {{ {} }}",
+        DERIVES, private_attrs
+    )
+    .to_string();
 
     let all_args = args_split(&args);
 
@@ -101,18 +112,22 @@ pub fn generate_output_type_input_struct(_: TokenStream) -> TokenStream {
     }
 
     let types = group_streams(&types);
-    struct_def += &format!("}}
+    struct_def += &format!(
+        "}}
         impl From<Input> for {types} {{
             fn from(input: Input) -> {types} {{
                 (
-    ");
+    "
+    );
 
     for field in patterns {
         struct_def += &format!("input.{field},");
     }
     struct_def += ") } }";
 
-    (output_type + &public_input_type + &private_input_type + &struct_def).parse::<TokenStream>().unwrap()
+    (output_type + &public_input_type + &private_input_type + &struct_def)
+        .parse::<TokenStream>()
+        .unwrap()
 }
 
 /// Repeats the given item as many times as fields there are, while replacing
@@ -145,11 +160,14 @@ pub fn foreach_input_field(item: TokenStream) -> TokenStream {
 pub fn foreach_public_input_field(item: TokenStream) -> TokenStream {
     let (args, _) = get_types();
 
-    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;
 
     foreach_field(item, public_patterns)
 }
@@ -161,11 +179,14 @@ pub fn foreach_public_input_field(item: TokenStream) -> TokenStream {
 pub fn foreach_private_input_field(item: TokenStream) -> TokenStream {
     let (args, _) = get_types();
 
-    let public_inputs = toml::from_str::<toml::Table>(
-            include_str!(concat!(env!("INPUTS_DIR"), "/default_public_input.toml"))
-        )
-        .unwrap();
-    let private_patterns = args_divide_public(&args, &public_inputs.keys().collect()).1.0;
+    let public_inputs = toml::from_str::<toml::Table>(include_str!(concat!(
+        env!("INPUTS_DIR"),
+        "/default_public_input.toml"
+    )))
+    .unwrap();
+    let private_patterns = args_divide_public(&args, &public_inputs.keys().collect())
+        .1
+         .0;
 
     foreach_field(item, private_patterns)
 }
diff --git a/zkvms_host_io/src/lib.rs b/zkvms_host_io/src/lib.rs
index 27099ef..b2049f5 100644
--- a/zkvms_host_io/src/lib.rs
+++ b/zkvms_host_io/src/lib.rs
@@ -1,12 +1,16 @@
 use clap::{Parser, ValueEnum};
-use num_traits::NumCast;
-use serde::{ Serialize, Deserialize };
 use env_file_reader::read_str;
-use std::{env, option::Option, fs::read_to_string, collections::*};
-pub use input_macros::{ foreach_input_field, foreach_public_input_field, foreach_private_input_field, benchmarkable };
+pub use input_macros::{
+    benchmarkable, foreach_input_field, foreach_private_input_field, foreach_public_input_field,
+};
+use num_traits::NumCast;
+use serde::{Deserialize, Serialize};
+use std::{collections::*, env, fs::read_to_string, option::Option};
 
-static DEFAULT_PUBLIC_INPUT: &str = include_str!(concat!(env!("INPUTS_DIR"), "/default_public_input.toml"));
-static DEFAULT_PRIVATE_INPUT: &str = include_str!(concat!(env!("INPUTS_DIR"), "/default_private_input.toml"));
+static DEFAULT_PUBLIC_INPUT: &str =
+    include_str!(concat!(env!("INPUTS_DIR"), "/default_public_input.toml"));
+static DEFAULT_PRIVATE_INPUT: &str =
+    include_str!(concat!(env!("INPUTS_DIR"), "/default_private_input.toml"));
 static DEFAULT_ENV: &str = include_str!(concat!(env!("INPUTS_DIR"), "/default.env"));
 
 /// A CLI tool for running and benchmarking guest programs inside a zkVM
@@ -79,15 +83,18 @@ impl RunWith {
     /// function is executed to convert the String value.
     ///
     /// The default environment is taken from the guest's `default.env`
-    pub fn env_then_or<T>(&self, variable_name: &str, then_apply: fn(String) -> Option<T>, else_const: T) -> T {
-        env::var(variable_name)
-            .ok()
-            .and_then(then_apply)
-            .unwrap_or(self
-                .default_env
+    pub fn env_then_or<T>(
+        &self,
+        variable_name: &str,
+        then_apply: fn(String) -> Option<T>,
+        else_const: T,
+    ) -> T {
+        env::var(variable_name).ok().and_then(then_apply).unwrap_or(
+            self.default_env
                 .get(variable_name)
                 .and_then(|x| then_apply(x.clone()))
-                .unwrap_or(else_const))
+                .unwrap_or(else_const),
+        )
     }
 
     /// Returns a value of the given name from the environment,
@@ -106,15 +113,15 @@ pub fn read_args() -> RunWith {
     let cli = Cli::parse();
 
     let public_contents: String = if cli.public_input.is_some() {
-            read_to_string(cli.public_input.unwrap()).unwrap()
-        } else {
-            DEFAULT_PUBLIC_INPUT.to_string()
-        };
+        read_to_string(cli.public_input.unwrap()).unwrap()
+    } else {
+        DEFAULT_PUBLIC_INPUT.to_string()
+    };
     let private_contents: String = if cli.private_input.is_some() {
-            read_to_string(cli.private_input.unwrap()).unwrap()
-        } else {
-            DEFAULT_PRIVATE_INPUT.to_string()
-        };
+        read_to_string(cli.private_input.unwrap()).unwrap()
+    } else {
+        DEFAULT_PRIVATE_INPUT.to_string()
+    };
     let input: Input = toml::from_str(&(public_contents.clone() + &private_contents)).unwrap();
     let public_input: PublicInput = toml::from_str(&public_contents).unwrap();
     let private_input: PrivateInput = toml::from_str(&private_contents).unwrap();