chore: cargo fmt

16 files changed, 142 insertions, 62 deletions

diff --git a/guests_macro/src/parse_fn.rs b/guests_macro/src/parse_fn.rs
index 3d1bc4c..8d0ade4 100644
--- a/guests_macro/src/parse_fn.rs
+++ b/guests_macro/src/parse_fn.rs
@@ -36,10 +36,15 @@ impl FunctionDefinition {
             Self::args_divide_public(&patterns, &types, &public_inputs.keys().collect());
 
         FunctionDefinition {
-            name, args, return_type,
-            patterns, types,
-            public_patterns, public_types,
-            private_patterns, private_types,
+            name,
+            args,
+            return_type,
+            patterns,
+            types,
+            public_patterns,
+            public_types,
+            private_patterns,
+            private_types,
         }
     }
 
diff --git a/zkvms/jolt/host/src/main.rs b/zkvms/jolt/host/src/main.rs
index 8bb3c86..4e74e89 100644
--- a/zkvms/jolt/host/src/main.rs
+++ b/zkvms/jolt/host/src/main.rs
@@ -1,7 +1,6 @@
 use zkvms_host_io::{
-    benchmarkable, read_args,
+    benchmarkable, output_proof_size, read_args,
     RunType::{Execute, Prove, Verify},
-    output_proof_size,
 };
 
 pub fn main() {
diff --git a/zkvms/nexus/host/src/main.rs b/zkvms/nexus/host/src/main.rs
index 68593fc..95eafe2 100644
--- a/zkvms/nexus/host/src/main.rs
+++ b/zkvms/nexus/host/src/main.rs
@@ -1,8 +1,7 @@
 use nexus_sdk::{stwo::seq::Stwo, Local, Prover, Verifiable, Viewable};
 use zkvms_host_io::{
-    benchmarkable, read_args, Input, Return,
+    benchmarkable, output_proof_size, read_args, Input, Return,
     RunType::{Execute, Prove, Verify},
-    output_proof_size,
 };
 
 fn main() {
diff --git a/zkvms/nexus/wrapper_macro/src/lib.rs b/zkvms/nexus/wrapper_macro/src/lib.rs
index 69d1de2..aa072fd 100644
--- a/zkvms/nexus/wrapper_macro/src/lib.rs
+++ b/zkvms/nexus/wrapper_macro/src/lib.rs
@@ -35,13 +35,29 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
     let fd = FunctionDefinition::new(&item);
 
     let mut out = TokenStream::new();
-    out.extend(format!("let ({}) = read_public_input::<({})>().unwrap();", fd.grouped_public_patterns(), fd.grouped_public_types()).parse::<TokenStream>());
-    out.extend(format!("let ({}) = read_private_input::<({})>().unwrap();", fd.grouped_private_patterns(), fd.grouped_private_types()).parse::<TokenStream>());
+    out.extend(
+        format!(
+            "let ({}) = read_public_input::<({})>().unwrap();",
+            fd.grouped_public_patterns(),
+            fd.grouped_public_types()
+        )
+        .parse::<TokenStream>(),
+    );
+    out.extend(
+        format!(
+            "let ({}) = read_private_input::<({})>().unwrap();",
+            fd.grouped_private_patterns(),
+            fd.grouped_private_types()
+        )
+        .parse::<TokenStream>(),
+    );
 
     out.extend(
         format!(
             "write_public_output::<{}>(&zkp::{}({}));",
-            fd.return_type, fd.name, fd.grouped_patterns()
+            fd.return_type,
+            fd.name,
+            fd.grouped_patterns()
         )
         .parse::<TokenStream>(),
     );
diff --git a/zkvms/risc0/host/src/main.rs b/zkvms/risc0/host/src/main.rs
index 78fd164..f010115 100644
--- a/zkvms/risc0/host/src/main.rs
+++ b/zkvms/risc0/host/src/main.rs
@@ -2,9 +2,8 @@ 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,
+    benchmarkable, foreach_input_field, output_proof_size, read_args, Input, Output,
     RunType::{Execute, Prove, Verify},
-    output_proof_size,
 };
 
 // https://github.com/risc0/risc0/blob/881e512732eca72849b2d0e263a1242aba3158af/risc0/build/src/lib.rs#L280-L284
diff --git a/zkvms/risc0/wrapper_macro/src/lib.rs b/zkvms/risc0/wrapper_macro/src/lib.rs
index c43f5c1..42b8ca0 100644
--- a/zkvms/risc0/wrapper_macro/src/lib.rs
+++ b/zkvms/risc0/wrapper_macro/src/lib.rs
@@ -51,7 +51,9 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
         .collect::<String>();
     out.extend(commits.parse::<TokenStream>());
 
-    out.extend(format!("commit(&zkp::{}({}));", fd.name, fd.grouped_patterns()).parse::<TokenStream>());
+    out.extend(
+        format!("commit(&zkp::{}({}));", fd.name, fd.grouped_patterns()).parse::<TokenStream>(),
+    );
 
     let mut block = TokenStream::new();
     block.extend(format!("{{ {} }}", out).parse::<TokenStream>());
diff --git a/zkvms/sp1/host/src/main.rs b/zkvms/sp1/host/src/main.rs
index a395247..5403a53 100644
--- a/zkvms/sp1/host/src/main.rs
+++ b/zkvms/sp1/host/src/main.rs
@@ -1,8 +1,7 @@
 use sp1_sdk::{EnvProver, ProverClient, SP1ProofWithPublicValues, SP1Stdin, SP1VerifyingKey};
 use zkvms_host_io::{
-    benchmarkable, foreach_input_field, read_args, Input,
+    benchmarkable, foreach_input_field, output_proof_size, read_args, Input,
     RunType::{Execute, Prove, Verify},
-    output_proof_size,
 };
 
 /// The ELF (executable and linkable format) file for the Succinct RISC-V zkVM.
diff --git a/zkvms/sp1/wrapper_macro/src/lib.rs b/zkvms/sp1/wrapper_macro/src/lib.rs
index 53965c2..070a09b 100644
--- a/zkvms/sp1/wrapper_macro/src/lib.rs
+++ b/zkvms/sp1/wrapper_macro/src/lib.rs
@@ -51,7 +51,9 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
         .collect::<String>();
     out.extend(commits.parse::<TokenStream>());
 
-    out.extend(format!("commit(&zkp::{}({}));", fd.name, fd.grouped_patterns()).parse::<TokenStream>());
+    out.extend(
+        format!("commit(&zkp::{}({}));", fd.name, fd.grouped_patterns()).parse::<TokenStream>(),
+    );
 
     let mut block = TokenStream::new();
     block.extend(format!("{{ {} }}", out).parse::<TokenStream>());
diff --git a/zkvms/zkm/guest/src/main.rs b/zkvms/zkm/guest/src/main.rs
index 2831bdf..4559e25 100644
--- a/zkvms/zkm/guest/src/main.rs
+++ b/zkvms/zkm/guest/src/main.rs
@@ -4,7 +4,7 @@
 use wrapper_macro::make_wrapper;
 
 extern crate alloc;
-use alloc::{collections::*, vec::*, string::*};
+use alloc::{collections::*, string::*, 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 1640b30..100e5b1 100644
--- a/zkvms/zkm/host/src/main.rs
+++ b/zkvms/zkm/host/src/main.rs
@@ -7,9 +7,8 @@ use zkm_sdk::{
 };
 
 use zkvms_host_io::{
-    benchmarkable, read_args,
+    benchmarkable, output_proof_size, read_args,
     RunType::{Execute, Prove, Verify},
-    output_proof_size,
 };
 
 async fn get_proof(
diff --git a/zkvms/zkm/wrapper_macro/src/lib.rs b/zkvms/zkm/wrapper_macro/src/lib.rs
index 6a88602..fde5fa3 100644
--- a/zkvms/zkm/wrapper_macro/src/lib.rs
+++ b/zkvms/zkm/wrapper_macro/src/lib.rs
@@ -33,10 +33,32 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
 
     let mut out = TokenStream::new();
     // NOTE: The first read returns public data, the second returns private
-    out.extend(format!("let ({}) : ({}) = read();", fd.grouped_public_patterns(), fd.grouped_public_types()).parse::<TokenStream>());
-    out.extend(format!("let ({}) : ({}) = read();", fd.grouped_private_patterns(), fd.grouped_private_types()).parse::<TokenStream>());
+    out.extend(
+        format!(
+            "let ({}) : ({}) = read();",
+            fd.grouped_public_patterns(),
+            fd.grouped_public_types()
+        )
+        .parse::<TokenStream>(),
+    );
+    out.extend(
+        format!(
+            "let ({}) : ({}) = read();",
+            fd.grouped_private_patterns(),
+            fd.grouped_private_types()
+        )
+        .parse::<TokenStream>(),
+    );
 
-    out.extend(format!("commit::<{}>(&zkp::{}({}));", fd.return_type, fd.name, fd.grouped_patterns()).parse::<TokenStream>());
+    out.extend(
+        format!(
+            "commit::<{}>(&zkp::{}({}));",
+            fd.return_type,
+            fd.name,
+            fd.grouped_patterns()
+        )
+        .parse::<TokenStream>(),
+    );
 
     let mut block = TokenStream::new();
     block.extend(format!("{{ {} }}", out).parse::<TokenStream>());
diff --git a/zkvms/zkwasm/host/src/main.rs b/zkvms/zkwasm/host/src/main.rs
index 6a23504..ea8dcf5 100644
--- a/zkvms/zkwasm/host/src/main.rs
+++ b/zkvms/zkwasm/host/src/main.rs
@@ -1,11 +1,10 @@
 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,
+    benchmarkable, foreach_private_input_field, foreach_public_input_field, output_proof_size_raw,
+    read_args, PrivateInput, PublicInput,
     RunType::{Execute, Prove, Verify},
     RunWith,
-    output_proof_size_raw,
 };
 
 static PUBLIC_INPUT_PATH: &str = "public_input.bin";
@@ -108,7 +107,9 @@ fn main() {
                 .arg("--output")
                 .arg(output.clone()));
 
-            let proofSize = std::fs::metadata(output.clone() + "/prog.0.transcript.data").unwrap().len();
+            let proofSize = std::fs::metadata(output.clone() + "/prog.0.transcript.data")
+                .unwrap()
+                .len();
             output_proof_size_raw(proofSize as usize);
 
             benchmarkable! {
diff --git a/zkvms/zkwasm/wrapper_macro/src/lib.rs b/zkvms/zkwasm/wrapper_macro/src/lib.rs
index 68a78ae..690cf5e 100644
--- a/zkvms/zkwasm/wrapper_macro/src/lib.rs
+++ b/zkvms/zkwasm/wrapper_macro/src/lib.rs
@@ -61,8 +61,18 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
 
     let mut out = TokenStream::new();
 
-    insert_reads(&mut out, fd.public_patterns(), fd.public_types(), "read_public");
-    insert_reads(&mut out, fd.private_patterns(), fd.private_types(), "read_private");
+    insert_reads(
+        &mut out,
+        fd.public_patterns(),
+        fd.public_types(),
+        "read_public",
+    );
+    insert_reads(
+        &mut out,
+        fd.private_patterns(),
+        fd.private_types(),
+        "read_private",
+    );
 
     out.extend(
         format!(
@@ -73,7 +83,8 @@ pub fn make_wrapper(item: TokenStream) -> TokenStream {
             write(val);
         }}
     ",
-            fd.name, fd.grouped_patterns()
+            fd.name,
+            fd.grouped_patterns()
         )
         .parse::<TokenStream>(),
     );
diff --git a/zkvms_guest_io/src/main.rs b/zkvms_guest_io/src/main.rs
index 4d9b378..4dfd1ae 100644
--- a/zkvms_guest_io/src/main.rs
+++ b/zkvms_guest_io/src/main.rs
@@ -1,11 +1,11 @@
 use clap::Parser;
-use std::process::{Command, Stdio};
+use itertools::Itertools;
 use json::{object, parse, JsonValue, Null};
-use std::io::{Error, Write};
-use std::fs::{read_to_string, OpenOptions};
 use smbioslib::*;
+use std::fs::{read_to_string, OpenOptions};
+use std::io::{Error, Write};
+use std::process::{Command, Stdio};
 use sysinfo::System;
-use itertools::Itertools;
 
 /// A CLI tool for running and benchmarking a guest program inside all
 /// supported zkVMs.
@@ -41,7 +41,7 @@ fn run_command(zkvm_guest_command: &str, operation: &str) -> Result<std::process
         .args(["--no-container", "--output", COMMAND_LOG_PATH, "--"])
         .args([zkvm_guest_command, operation])
         .arg("--benchmark")
-        .args([ "--metrics-output", METRICS_TEMP_OUTPUT_PATH ])
+        .args(["--metrics-output", METRICS_TEMP_OUTPUT_PATH])
         .stdout(Stdio::piped())
         .output()
 }
@@ -79,7 +79,11 @@ fn main() {
     // Always available information
     let sys = System::new_all();
 
-    let cpus = sys.cpus().into_iter().unique_by(|c| c.brand()).collect::<Vec<_>>();
+    let cpus = sys
+        .cpus()
+        .into_iter()
+        .unique_by(|c| c.brand())
+        .collect::<Vec<_>>();
     for cpu in cpus {
         let mut hcpu = JsonValue::new_object();
 
@@ -99,16 +103,17 @@ fn main() {
     // Either login through another TTY as root, or use `machinectl shell root@`
     if let Ok(sys) = table_load_from_device() {
         // Fix CPU core counts
-        let cpus = sys.filter(|cpu: &SMBiosProcessorInformation| true).collect::<Vec<SMBiosProcessorInformation>>();
+        let cpus = sys
+            .filter(|cpu: &SMBiosProcessorInformation| true)
+            .collect::<Vec<SMBiosProcessorInformation>>();
         for mut hcpu in runs["hardware"]["cpu"].members_mut() {
-            if let Some(cpu) = cpus.iter().find(|cpu|
+            if let Some(cpu) = cpus.iter().find(|cpu| {
                 if let Some(ver) = cpu.processor_version().ok() {
                     ver.trim() == hcpu["model"].to_string().trim()
-                }
-                else {
+                } else {
                     false
                 }
-            ) {
+            }) {
                 if let Some(CoreCount::Count(cores)) = cpu.core_count() {
                     hcpu["cores"] = cores.into();
                 }
@@ -168,7 +173,8 @@ fn main() {
                 println!("Command failed!");
             }
 
-            let stdout = String::from_utf8(output.stdout).expect("failed to convert stdout to String");
+            let stdout =
+                String::from_utf8(output.stdout).expect("failed to convert stdout to String");
             println!("{stdout}");
 
             if !output.stderr.is_empty() {
@@ -192,15 +198,14 @@ fn main() {
                 continue;
             }
 
-            let raw_data = &read_to_string(METRICS_TEMP_OUTPUT_PATH)
-                .ok()
-                .unwrap();
+            let raw_data = &read_to_string(METRICS_TEMP_OUTPUT_PATH).ok().unwrap();
             run[operation] = json::parse(raw_data).unwrap();
-            run[operation]["memory"] = get_runexec_value(&stdout, "memory", 'B').parse::<u64>().unwrap().into();
+            run[operation]["memory"] = get_runexec_value(&stdout, "memory", 'B')
+                .parse::<u64>()
+                .unwrap()
+                .into();
 
-            let proofSize = &read_to_string(PROOF_SIZE_FILE_PATH)
-                .ok()
-                .unwrap();
+            let proofSize = &read_to_string(PROOF_SIZE_FILE_PATH).ok().unwrap();
             run[operation]["proofSize"] = proofSize.parse::<u64>().unwrap().into();
         }
 
diff --git a/zkvms_host_io/input_macros/src/lib.rs b/zkvms_host_io/input_macros/src/lib.rs
index 7984d96..229d4e4 100644
--- a/zkvms_host_io/input_macros/src/lib.rs
+++ b/zkvms_host_io/input_macros/src/lib.rs
@@ -66,8 +66,14 @@ static DERIVES: &str = "#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deseria
 pub fn generate_output_type_input_struct(_: TokenStream) -> TokenStream {
     let fd = new_fd();
 
-    let sep = if fd.public_types().is_empty() { "" } else { ", " };
-    let output_type = format!("pub type Output = ({} {} {});", fd.grouped_public_types(), sep, fd.return_type).to_string();
+    let sep = if fd.types().is_empty() { "" } else { ", " };
+    let output_type = format!(
+        "pub type Output = ({} {} {});",
+        fd.grouped_public_types(),
+        sep,
+        fd.return_type
+    )
+    .to_string();
 
     let return_type = format!("pub type Return = {};", fd.return_type).to_string();
 
@@ -102,7 +108,8 @@ pub fn generate_output_type_input_struct(_: TokenStream) -> TokenStream {
         .map(|x| format!("input.{x},"))
         .collect::<String>();
     let types = fd.grouped_types();
-    let struct_def = &format!("
+    let struct_def = &format!(
+        "
         {DERIVES} pub struct Input {{
             {attrs}
         }}
@@ -111,7 +118,9 @@ pub fn generate_output_type_input_struct(_: TokenStream) -> TokenStream {
                 ({convertion})
             }}
         }}
-    ").to_string();
+    "
+    )
+    .to_string();
 
     (output_type + &return_type + &public_input_type + &private_input_type + &struct_def)
         .parse::<TokenStream>()
@@ -159,7 +168,8 @@ pub fn foreach_private_input_field(item: TokenStream) -> TokenStream {
 /// parameters.
 #[proc_macro]
 pub fn benchmarkable(item: TokenStream) -> TokenStream {
-    format!(r#"
+    format!(
+        r#"
         {{
              use std::time::Instant;
 
@@ -182,5 +192,8 @@ pub fn benchmarkable(item: TokenStream) -> TokenStream {
                  zkvms_host_io::emit_benchmark_results(run_info, starts, ends);
              }}
         }}
-    "#).parse().unwrap()
+    "#
+    )
+    .parse()
+    .unwrap()
 }
diff --git a/zkvms_host_io/src/lib.rs b/zkvms_host_io/src/lib.rs
index a3249a0..584a883 100644
--- a/zkvms_host_io/src/lib.rs
+++ b/zkvms_host_io/src/lib.rs
@@ -159,14 +159,15 @@ pub fn output_proof_size<T>(proof: &T) {
 }
 
 pub fn output_proof_size_raw(size: usize) {
-    std::fs::write(PROOF_SIZE_FILE_PATH, size.to_string()).expect(&format!("Couldn't write proof size to \"{PROOF_SIZE_FILE_PATH}\"!"));
+    std::fs::write(PROOF_SIZE_FILE_PATH, size.to_string()).expect(&format!(
+        "Couldn't write proof size to \"{PROOF_SIZE_FILE_PATH}\"!"
+    ));
 }
 
 fn mean(xs: &Vec<f32>) -> f32 {
     if xs.len() == 1 {
         xs[0]
-    }
-    else {
+    } else {
         statistical::mean(&xs)
     }
 }
@@ -174,8 +175,7 @@ fn mean(xs: &Vec<f32>) -> f32 {
 fn stddev(xs: &Vec<f32>) -> f32 {
     if xs.len() == 1 {
         0.0
-    }
-    else {
+    } else {
         statistical::standard_deviation(&xs, None)
     }
 }
@@ -199,8 +199,16 @@ pub fn emit_benchmark_results(run_info: RunWith, starts: Vec<Instant>, ends: Vec
 
     run["mean"] = mean(&durations).into();
     run["deviation"] = stddev(&durations).into();
-    run["min"] = (*durations.iter().min_by(|a,b| a.partial_cmp(b).unwrap()).unwrap()).into();
-    run["max"] = (*durations.iter().max_by(|a,b| a.partial_cmp(b).unwrap()).unwrap()).into();
+    run["min"] = (*durations
+        .iter()
+        .min_by(|a, b| a.partial_cmp(b).unwrap())
+        .unwrap())
+    .into();
+    run["max"] = (*durations
+        .iter()
+        .max_by(|a, b| a.partial_cmp(b).unwrap())
+        .unwrap())
+    .into();
 
     run["memory"] = Null;
     run["proofSize"] = Null;