chore: Rust fmt

3 files changed, 31 insertions, 17 deletions

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>());