chore: Rust fmt

3 files changed, 158 insertions, 120 deletions

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!(),
     }
 }