From 5b82ac769339938570c0d1f7230afc53732993b4 Mon Sep 17 00:00:00 2001 From: Kamen Mladenov Date: Thu, 27 Feb 2025 11:35:32 +0200 Subject: chore: Rust fmt --- zkvms/zkwasm/guest/src/lib.rs | 10 ++- zkvms/zkwasm/host/src/main.rs | 105 ++++++++++------------ zkvms/zkwasm/wrapper_macro/src/lib.rs | 163 ++++++++++++++++++++++------------ 3 files changed, 158 insertions(+), 120 deletions(-) (limited to 'zkvms/zkwasm') 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::(); - (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::() + + &values.map(|x| "[".to_string() + x).collect::() } // 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::(); + let subcollections = values.map(|x| get_with_sizes(x)).collect::(); - 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 = 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, types: &Vec, readfn: &str) { +fn insert_reads( + out: &mut TokenStream, + patterns: &Vec, + types: &Vec, + 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::()); + let type_note: String = format!("{}", types[i]).replace('<', "[").replace('>', "]"); + out.extend( + format!( + "let {} : {} = read!({} {});", + patterns[i], types[i], readfn, type_note + ) + .parse::(), + ); } } @@ -50,11 +59,13 @@ fn insert_reads(out: &mut TokenStream, patterns: &Vec, types: &Vec< pub fn make_wrapper(item: TokenStream) -> TokenStream { let (name, args, ret) = split_fn(&item); - let public_inputs = toml::from_str::( - 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::
(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::()); + ", + name, ts_patterns + ) + .parse::(), + ); let mut block = TokenStream::new(); block.extend(format!("{{ {} }}", out).parse::()); @@ -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!(), } } -- cgit v1.2.3