From bc1209e890748d77984ddedc7567e554e8e6f728 Mon Sep 17 00:00:00 2001 From: dark64 Date: Wed, 3 Feb 2021 13:38:44 +0100 Subject: [PATCH 01/22] use random seed in bellman --- Cargo.lock | 28 +++- zokrates_core/Cargo.toml | 1 + .../src/proof_system/bellman/groth16.rs | 3 +- zokrates_core/src/proof_system/bellman/mod.rs | 17 ++- zokrates_js/Cargo.lock | 129 ++++++++++++++++-- zokrates_js/package-lock.json | 2 +- 6 files changed, 156 insertions(+), 24 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index b66717a2..20ecd421 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -904,7 +904,20 @@ checksum = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6" dependencies = [ "cfg-if 0.1.10", "libc", - "wasi", + "wasi 0.9.0+wasi-snapshot-preview1", +] + +[[package]] +name = "getrandom" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8" +dependencies = [ + "cfg-if 1.0.0", + "js-sys", + "libc", + "wasi 0.10.2+wasi-snapshot-preview1", + "wasm-bindgen", ] [[package]] @@ -1431,7 +1444,7 @@ version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" dependencies = [ - "getrandom", + "getrandom 0.1.15", "libc", "rand_chacha", "rand_core 0.5.1", @@ -1469,7 +1482,7 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" dependencies = [ - "getrandom", + "getrandom 0.1.15", ] [[package]] @@ -1502,7 +1515,7 @@ version = "0.3.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "de0737333e7a9502c789a36d7c7fa6092a49895d4faa31ca5df163857ded2e9d" dependencies = [ - "getrandom", + "getrandom 0.1.15", "redox_syscall", "rust-argon2", ] @@ -1991,6 +2004,12 @@ version = "0.9.0+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" +[[package]] +name = "wasi" +version = "0.10.2+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6" + [[package]] name = "wasm-bindgen" version = "0.2.69" @@ -2198,6 +2217,7 @@ dependencies = [ "cmake", "csv", "ff_ce 0.9.0", + "getrandom 0.2.2", "git2", "hex", "lazy_static", diff --git a/zokrates_core/Cargo.toml b/zokrates_core/Cargo.toml index 3b9485f3..c6286004 100644 --- a/zokrates_core/Cargo.toml +++ b/zokrates_core/Cargo.toml @@ -32,6 +32,7 @@ zokrates_field = { version = "0.3.0", path = "../zokrates_field", default-featur zokrates_pest_ast = { version = "0.1.0", path = "../zokrates_pest_ast" } zokrates_common = { path = "../zokrates_common" } zokrates_embed = { path = "../zokrates_embed" } +getrandom = { version = "0.2", features = ["js"] } rand_0_4 = { version = "0.4", package = "rand" } rand_0_7 = { version = "0.7", package = "rand" } csv = "1" diff --git a/zokrates_core/src/proof_system/bellman/groth16.rs b/zokrates_core/src/proof_system/bellman/groth16.rs index 8db9823c..b8aeb830 100644 --- a/zokrates_core/src/proof_system/bellman/groth16.rs +++ b/zokrates_core/src/proof_system/bellman/groth16.rs @@ -133,11 +133,10 @@ mod serialization { mod tests { use zokrates_field::Bn128Field; + use super::*; use crate::flat_absy::FlatVariable; use crate::ir::{Function, Interpreter, Prog, Statement}; - use super::*; - #[test] fn verify() { let program: Prog = Prog { diff --git a/zokrates_core/src/proof_system/bellman/mod.rs b/zokrates_core/src/proof_system/bellman/mod.rs index df6869de..bdef4064 100644 --- a/zokrates_core/src/proof_system/bellman/mod.rs +++ b/zokrates_core/src/proof_system/bellman/mod.rs @@ -162,8 +162,19 @@ impl Prog { } impl Computation { + fn get_random_seed(&self) -> Result<[u32; 8], getrandom::Error> { + let mut seed = [0u8; 32]; + getrandom::getrandom(&mut seed)?; + + use std::mem::transmute; + let seed: [u32; 8] = unsafe { transmute(seed) }; + Ok(seed) + } + pub fn prove(self, params: &Parameters) -> Proof { - let rng = &mut ChaChaRng::new_unseeded(); + use rand_0_4::SeedableRng; + let seed = self.get_random_seed().unwrap(); + let rng = &mut ChaChaRng::from_seed(seed.as_ref()); let proof = create_random_proof(self.clone(), params, rng).unwrap(); @@ -186,7 +197,9 @@ impl Computation { } pub fn setup(self) -> Parameters { - let rng = &mut ChaChaRng::new_unseeded(); + use rand_0_4::SeedableRng; + let seed = self.get_random_seed().unwrap(); + let rng = &mut ChaChaRng::from_seed(seed.as_ref()); // run setup phase generate_random_parameters(self, rng).unwrap() } diff --git a/zokrates_js/Cargo.lock b/zokrates_js/Cargo.lock index f0aad642..1ebfb22b 100644 --- a/zokrates_js/Cargo.lock +++ b/zokrates_js/Cargo.lock @@ -24,6 +24,15 @@ dependencies = [ "memchr", ] +[[package]] +name = "arrayvec" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd9fd44efafa8690358b7408d253adf110036b88f55672a933f01d616ad9b1b9" +dependencies = [ + "nodrop", +] + [[package]] name = "autocfg" version = "1.0.0" @@ -37,7 +46,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "46254cf2fdcdf1badb5934448c1bcbe046a56537b3987d96c51a7afc5d03f293" dependencies = [ "addr2line", - "cfg-if", + "cfg-if 0.1.10", "libc", "miniz_oxide", "object", @@ -52,7 +61,7 @@ checksum = "a5ca1343d8690bb4d62e0665116bd4f109e33a642f86908ed107d226a402b0ef" dependencies = [ "bit-vec", "byteorder", - "cfg-if", + "cfg-if 0.1.10", "futures", "num_cpus", "pairing_ce", @@ -87,6 +96,17 @@ version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f0dc55f2d8a1a85650ac47858bb001b4c0dd73d79e3c455a842925e68d29cd3" +[[package]] +name = "blake2-rfc_bellman_edition" +version = "0.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdc60350286c7c3db13b98e91dbe5c8b6830a6821bc20af5b0c310ce94d74915" +dependencies = [ + "arrayvec", + "byteorder", + "constant_time_eq", +] + [[package]] name = "block-buffer" version = "0.7.3" @@ -144,16 +164,34 @@ version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + [[package]] name = "console_error_panic_hook" version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b8d976903543e0c48546a91908f21588a680a8c8f984df9a5d69feccb2b2a211" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "wasm-bindgen", ] +[[package]] +name = "constant_time_eq" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc" + +[[package]] +name = "crunchy" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" + [[package]] name = "csv" version = "1.1.3" @@ -367,9 +405,22 @@ version = "0.1.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "libc", - "wasi", + "wasi 0.9.0+wasi-snapshot-preview1", +] + +[[package]] +name = "getrandom" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8" +dependencies = [ + "cfg-if 1.0.0", + "js-sys", + "libc", + "wasi 0.10.2+wasi-snapshot-preview1", + "wasm-bindgen", ] [[package]] @@ -435,7 +486,7 @@ version = "0.4.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", ] [[package]] @@ -459,6 +510,12 @@ dependencies = [ "adler", ] +[[package]] +name = "nodrop" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb" + [[package]] name = "num" version = "0.1.42" @@ -703,7 +760,7 @@ version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" dependencies = [ - "getrandom", + "getrandom 0.1.15", "libc", "rand_chacha", "rand_core 0.5.1", @@ -741,7 +798,7 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" dependencies = [ - "getrandom", + "getrandom 0.1.15", ] [[package]] @@ -811,6 +868,23 @@ version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e" +[[package]] +name = "sapling-crypto_ce" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c4ff5309ec3e4bd800ad4ab3f71e9b76e9ea81c9f0eda6efa16008afbe440b3" +dependencies = [ + "bellman_ce", + "blake2-rfc_bellman_edition", + "byteorder", + "digest", + "rand 0.4.6", + "serde", + "serde_derive", + "sha2", + "tiny-keccak", +] + [[package]] name = "serde" version = "1.0.114" @@ -924,6 +998,15 @@ dependencies = [ "lazy_static", ] +[[package]] +name = "tiny-keccak" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237" +dependencies = [ + "crunchy", +] + [[package]] name = "typed-arena" version = "1.7.0" @@ -978,13 +1061,19 @@ version = "0.9.0+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" +[[package]] +name = "wasi" +version = "0.10.2+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6" + [[package]] name = "wasm-bindgen" version = "0.2.65" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f3edbcc9536ab7eababcc6d2374a0b7bfe13a2b6d562c5e07f370456b1a8f33d" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "serde", "serde_json", "wasm-bindgen-macro", @@ -1068,7 +1157,7 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" [[package]] name = "zokrates_abi" -version = "0.1.2" +version = "0.1.3" dependencies = [ "serde", "serde_derive", @@ -1083,13 +1172,14 @@ version = "0.1.0" [[package]] name = "zokrates_core" -version = "0.5.2" +version = "0.5.3" dependencies = [ "bellman_ce", "bincode 0.8.0", - "cfg-if", + "cfg-if 0.1.10", "csv", "ff_ce 0.9.0", + "getrandom 0.2.2", "hex", "lazy_static", "num", @@ -1103,10 +1193,19 @@ dependencies = [ "serde_json", "typed-arena", "zokrates_common", + "zokrates_embed", "zokrates_field", "zokrates_pest_ast", ] +[[package]] +name = "zokrates_embed" +version = "0.1.1" +dependencies = [ + "bellman_ce", + "sapling-crypto_ce", +] + [[package]] name = "zokrates_field" version = "0.3.7" @@ -1125,7 +1224,7 @@ dependencies = [ [[package]] name = "zokrates_js" -version = "1.0.26" +version = "1.0.27" dependencies = [ "bincode 1.3.1", "console_error_panic_hook", @@ -1141,7 +1240,7 @@ dependencies = [ [[package]] name = "zokrates_parser" -version = "0.1.5" +version = "0.1.6" dependencies = [ "pest", "pest_derive", @@ -1149,7 +1248,7 @@ dependencies = [ [[package]] name = "zokrates_pest_ast" -version = "0.1.4" +version = "0.1.5" dependencies = [ "from-pest", "lazy_static", diff --git a/zokrates_js/package-lock.json b/zokrates_js/package-lock.json index 013ec5e5..34c2ba3a 100644 --- a/zokrates_js/package-lock.json +++ b/zokrates_js/package-lock.json @@ -1,6 +1,6 @@ { "name": "zokrates-js", - "version": "1.0.26", + "version": "1.0.27", "lockfileVersion": 1, "requires": true, "dependencies": { From 11a81792fafe0e3afbfac2076d3ea31514f14c55 Mon Sep 17 00:00:00 2001 From: dark64 Date: Thu, 11 Feb 2021 13:41:19 +0100 Subject: [PATCH 02/22] improve flattening of field eq boolean expression --- zokrates_core/src/flatten/mod.rs | 130 +++++++++++++++++++++++++++---- 1 file changed, 117 insertions(+), 13 deletions(-) diff --git a/zokrates_core/src/flatten/mod.rs b/zokrates_core/src/flatten/mod.rs index 8d77a9f0..d60baaf2 100644 --- a/zokrates_core/src/flatten/mod.rs +++ b/zokrates_core/src/flatten/mod.rs @@ -2016,21 +2016,62 @@ impl<'ast, T: Field> Flattener<'ast, T> { } } ZirStatement::Assertion(e) => { - // naive approach: flatten the boolean to a single field element and constrain it to 1 + match e { + BooleanExpression::FieldEq(lhs, rhs) => { + let mut lhs_flattened = + self.flatten_field_expression(symbols, statements_flattened, *lhs); + let mut rhs_flattened = + self.flatten_field_expression(symbols, statements_flattened, *rhs); - let e = self.flatten_boolean_expression(symbols, statements_flattened, e); + lhs_flattened = match lhs_flattened { + FlatExpression::Number(_) | FlatExpression::Identifier(_) => { + lhs_flattened + } + _ => { + let sym = self.use_sym(); + statements_flattened + .push(FlatStatement::Definition(sym, lhs_flattened)); + FlatExpression::Identifier(sym) + } + }; - if e.is_linear() { - statements_flattened.push(FlatStatement::Condition( - e, - FlatExpression::Number(T::from(1)), - )); - } else { - // swap so that left side is linear - statements_flattened.push(FlatStatement::Condition( - FlatExpression::Number(T::from(1)), - e, - )); + rhs_flattened = match rhs_flattened { + FlatExpression::Number(_) | FlatExpression::Identifier(_) => { + rhs_flattened + } + _ => { + let sym = self.use_sym(); + statements_flattened + .push(FlatStatement::Definition(sym, rhs_flattened)); + FlatExpression::Identifier(sym) + } + }; + + statements_flattened.push(FlatStatement::Condition( + FlatExpression::Mult( + box lhs_flattened, + box FlatExpression::Number(T::from(1)), + ), + rhs_flattened, + )); + } + _ => { + // naive approach: flatten the boolean to a single field element and constrain it to 1 + let e = self.flatten_boolean_expression(symbols, statements_flattened, e); + + if e.is_linear() { + statements_flattened.push(FlatStatement::Condition( + e, + FlatExpression::Number(T::from(1)), + )); + } else { + // swap so that left side is linear + statements_flattened.push(FlatStatement::Condition( + FlatExpression::Number(T::from(1)), + e, + )); + } + } } } ZirStatement::MultipleDefinition(vars, rhs) => { @@ -2246,6 +2287,69 @@ mod tests { use crate::zir::types::Type; use zokrates_field::Bn128Field; + #[test] + fn assertion_field_eq() { + let function = ZirFunction { + arguments: vec![], + statements: vec![ + ZirStatement::Definition( + Variable::field_element("a"), + FieldElementExpression::Number(Bn128Field::from(42)).into(), + ), + ZirStatement::Definition( + Variable::field_element("b"), + FieldElementExpression::Number(Bn128Field::from(42)).into(), + ), + ZirStatement::Assertion(BooleanExpression::FieldEq( + box FieldElementExpression::Add( + box FieldElementExpression::Identifier("a".into()), + box FieldElementExpression::Number(Bn128Field::from(1)).into(), + ), + box FieldElementExpression::Identifier("b".into()), + )), + ], + signature: Signature { + inputs: vec![], + outputs: vec![], + }, + }; + + let config = CompileConfig::default(); + let mut flattener = Flattener::new(&config); + + let flat = flattener.flatten_function(&HashMap::new(), function); + + let expected = FlatFunction { + arguments: vec![], + statements: vec![ + FlatStatement::Definition( + FlatVariable::new(0), + FlatExpression::Number(Bn128Field::from(42)), + ), + FlatStatement::Definition( + FlatVariable::new(1), + FlatExpression::Number(Bn128Field::from(42)), + ), + FlatStatement::Definition( + FlatVariable::new(2), + FlatExpression::Add( + box FlatExpression::Identifier(FlatVariable::new(0)), + box FlatExpression::Number(Bn128Field::from(1)), + ), + ), + FlatStatement::Condition( + FlatExpression::Mult( + box FlatExpression::Identifier(FlatVariable::new(2)), + box FlatExpression::Number(Bn128Field::from(1)), + ), + FlatExpression::Identifier(FlatVariable::new(1)), + ), + ], + }; + + assert_eq!(flat, expected); + } + #[test] fn powers_zero() { // def main(): From c74f4ccd173d649b021797a6d797e78e8b1d4159 Mon Sep 17 00:00:00 2001 From: dark64 Date: Thu, 11 Feb 2021 20:40:00 +0100 Subject: [PATCH 03/22] wip --- zokrates_core/src/flatten/mod.rs | 40 ++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/zokrates_core/src/flatten/mod.rs b/zokrates_core/src/flatten/mod.rs index d60baaf2..1f84090c 100644 --- a/zokrates_core/src/flatten/mod.rs +++ b/zokrates_core/src/flatten/mod.rs @@ -2055,6 +2055,46 @@ impl<'ast, T: Field> Flattener<'ast, T> { rhs_flattened, )); } + BooleanExpression::UintEq(lhs, rhs) => { + let mut lhs_flattened = self + .flatten_uint_expression(symbols, statements_flattened, *lhs) + .get_field_unchecked(); + let mut rhs_flattened = self + .flatten_uint_expression(symbols, statements_flattened, *rhs) + .get_field_unchecked(); + + lhs_flattened = match lhs_flattened { + FlatExpression::Number(_) | FlatExpression::Identifier(_) => { + lhs_flattened + } + _ => { + let sym = self.use_sym(); + statements_flattened + .push(FlatStatement::Definition(sym, lhs_flattened)); + FlatExpression::Identifier(sym) + } + }; + + rhs_flattened = match rhs_flattened { + FlatExpression::Number(_) | FlatExpression::Identifier(_) => { + rhs_flattened + } + _ => { + let sym = self.use_sym(); + statements_flattened + .push(FlatStatement::Definition(sym, rhs_flattened)); + FlatExpression::Identifier(sym) + } + }; + + statements_flattened.push(FlatStatement::Condition( + FlatExpression::Mult( + box lhs_flattened, + box FlatExpression::Number(T::from(1)), + ), + rhs_flattened, + )); + } _ => { // naive approach: flatten the boolean to a single field element and constrain it to 1 let e = self.flatten_boolean_expression(symbols, statements_flattened, e); From 4c42087e311f7c960349739197bcb101ae62671b Mon Sep 17 00:00:00 2001 From: dark64 Date: Mon, 15 Feb 2021 14:46:27 +0100 Subject: [PATCH 04/22] improve flattening of complex type assertions --- zokrates_core/src/flatten/mod.rs | 179 ++++++++++++++++++------------- 1 file changed, 107 insertions(+), 72 deletions(-) diff --git a/zokrates_core/src/flatten/mod.rs b/zokrates_core/src/flatten/mod.rs index 1f84090c..f1529328 100644 --- a/zokrates_core/src/flatten/mod.rs +++ b/zokrates_core/src/flatten/mod.rs @@ -2017,83 +2017,39 @@ impl<'ast, T: Field> Flattener<'ast, T> { } ZirStatement::Assertion(e) => { match e { - BooleanExpression::FieldEq(lhs, rhs) => { - let mut lhs_flattened = - self.flatten_field_expression(symbols, statements_flattened, *lhs); - let mut rhs_flattened = - self.flatten_field_expression(symbols, statements_flattened, *rhs); - - lhs_flattened = match lhs_flattened { - FlatExpression::Number(_) | FlatExpression::Identifier(_) => { - lhs_flattened - } - _ => { - let sym = self.use_sym(); - statements_flattened - .push(FlatStatement::Definition(sym, lhs_flattened)); - FlatExpression::Identifier(sym) - } - }; - - rhs_flattened = match rhs_flattened { - FlatExpression::Number(_) | FlatExpression::Identifier(_) => { - rhs_flattened - } - _ => { - let sym = self.use_sym(); - statements_flattened - .push(FlatStatement::Definition(sym, rhs_flattened)); - FlatExpression::Identifier(sym) - } - }; - - statements_flattened.push(FlatStatement::Condition( - FlatExpression::Mult( - box lhs_flattened, - box FlatExpression::Number(T::from(1)), - ), - rhs_flattened, - )); + BooleanExpression::And(..) => { + let mut iter = self.unwrap_and_chain(e).into_iter(); + while let Some(inner) = iter.next() { + self.flatten_statement( + symbols, + statements_flattened, + ZirStatement::Assertion(inner), + ) + } } - BooleanExpression::UintEq(lhs, rhs) => { - let mut lhs_flattened = self - .flatten_uint_expression(symbols, statements_flattened, *lhs) + BooleanExpression::FieldEq(box lhs, box rhs) => { + let lhs = self.flatten_field_expression(symbols, statements_flattened, lhs); + let rhs = self.flatten_field_expression(symbols, statements_flattened, rhs); + + self.flatten_assertion(statements_flattened, lhs, rhs) + } + BooleanExpression::UintEq(box lhs, box rhs) => { + let lhs = self + .flatten_uint_expression(symbols, statements_flattened, lhs) .get_field_unchecked(); - let mut rhs_flattened = self - .flatten_uint_expression(symbols, statements_flattened, *rhs) + let rhs = self + .flatten_uint_expression(symbols, statements_flattened, rhs) .get_field_unchecked(); - lhs_flattened = match lhs_flattened { - FlatExpression::Number(_) | FlatExpression::Identifier(_) => { - lhs_flattened - } - _ => { - let sym = self.use_sym(); - statements_flattened - .push(FlatStatement::Definition(sym, lhs_flattened)); - FlatExpression::Identifier(sym) - } - }; + self.flatten_assertion(statements_flattened, lhs, rhs) + } + BooleanExpression::BoolEq(box lhs, box rhs) => { + let lhs = + self.flatten_boolean_expression(symbols, statements_flattened, lhs); + let rhs = + self.flatten_boolean_expression(symbols, statements_flattened, rhs); - rhs_flattened = match rhs_flattened { - FlatExpression::Number(_) | FlatExpression::Identifier(_) => { - rhs_flattened - } - _ => { - let sym = self.use_sym(); - statements_flattened - .push(FlatStatement::Definition(sym, rhs_flattened)); - FlatExpression::Identifier(sym) - } - }; - - statements_flattened.push(FlatStatement::Condition( - FlatExpression::Mult( - box lhs_flattened, - box FlatExpression::Number(T::from(1)), - ), - rhs_flattened, - )); + self.flatten_assertion(statements_flattened, lhs, rhs) } _ => { // naive approach: flatten the boolean to a single field element and constrain it to 1 @@ -2164,6 +2120,24 @@ impl<'ast, T: Field> Flattener<'ast, T> { } } + /// Unwraps a boolean & (and) expression chain to a flat vector of boolean expressions + /// + /// # Arguments + /// * `e` - `BooleanExpression` to be flattened + fn unwrap_and_chain( + &mut self, + e: BooleanExpression<'ast, T>, + ) -> Vec> { + match e { + BooleanExpression::And(box lhs, box rhs) => { + let mut inner = self.unwrap_and_chain(lhs); + inner.push(rhs); + inner + } + _ => vec![e], + } + } + /// Flattens a function /// /// # Arguments @@ -2228,6 +2202,36 @@ impl<'ast, T: Field> Flattener<'ast, T> { } } + fn flatten_assertion( + &mut self, + statements_flattened: &mut FlatStatements, + lhs: FlatExpression, + rhs: FlatExpression, + ) { + let lhs_flattened = match lhs { + FlatExpression::Number(_) | FlatExpression::Identifier(_) => lhs, + _ => { + let sym = self.use_sym(); + statements_flattened.push(FlatStatement::Definition(sym, lhs)); + FlatExpression::Identifier(sym) + } + }; + + let rhs_flattened = match rhs { + FlatExpression::Number(_) | FlatExpression::Identifier(_) => rhs, + _ => { + let sym = self.use_sym(); + statements_flattened.push(FlatStatement::Definition(sym, rhs)); + FlatExpression::Identifier(sym) + } + }; + + statements_flattened.push(FlatStatement::Condition( + FlatExpression::Mult(box lhs_flattened, box FlatExpression::Number(T::from(1))), + rhs_flattened, + )); + } + /// Returns a fresh FlatVariable for a given Variable /// # Arguments /// @@ -2327,6 +2331,37 @@ mod tests { use crate::zir::types::Type; use zokrates_field::Bn128Field; + #[test] + fn assertion_bool_eq() { + let function = ZirFunction:: { + arguments: vec![], + statements: vec![ + ZirStatement::Definition( + Variable::boolean("a".into()), + BooleanExpression::Value(true).into(), + ), + ZirStatement::Definition( + Variable::boolean("b".into()), + BooleanExpression::Value(true).into(), + ), + ZirStatement::Assertion(BooleanExpression::BoolEq( + box BooleanExpression::Identifier("a".into()), + box BooleanExpression::Identifier("b".into()), + )), + ], + signature: Signature { + inputs: vec![], + outputs: vec![], + }, + }; + + let config = CompileConfig::default(); + let mut flattener = Flattener::new(&config); + + let flat = flattener.flatten_function(&HashMap::new(), function); + println!("{}", flat); + } + #[test] fn assertion_field_eq() { let function = ZirFunction { From d8c6c154cc68caa03302151777ac13193b061f4a Mon Sep 17 00:00:00 2001 From: dark64 Date: Mon, 15 Feb 2021 14:48:11 +0100 Subject: [PATCH 05/22] fix test --- zokrates_core/src/flatten/mod.rs | 24 +++++++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/zokrates_core/src/flatten/mod.rs b/zokrates_core/src/flatten/mod.rs index f1529328..71cb3972 100644 --- a/zokrates_core/src/flatten/mod.rs +++ b/zokrates_core/src/flatten/mod.rs @@ -2359,7 +2359,29 @@ mod tests { let mut flattener = Flattener::new(&config); let flat = flattener.flatten_function(&HashMap::new(), function); - println!("{}", flat); + + let expected = FlatFunction { + arguments: vec![], + statements: vec![ + FlatStatement::Definition( + FlatVariable::new(0), + FlatExpression::Number(Bn128Field::from(1)), + ), + FlatStatement::Definition( + FlatVariable::new(1), + FlatExpression::Number(Bn128Field::from(1)), + ), + FlatStatement::Condition( + FlatExpression::Mult( + box FlatExpression::Identifier(FlatVariable::new(0)), + box FlatExpression::Number(Bn128Field::from(1)), + ), + FlatExpression::Identifier(FlatVariable::new(1)), + ), + ], + }; + + assert_eq!(flat, expected); } #[test] From 289c04f7c946ace67599a0b1fc60baf37f2deba2 Mon Sep 17 00:00:00 2001 From: dark64 Date: Tue, 16 Feb 2021 18:30:38 +0100 Subject: [PATCH 06/22] add uint eq assertion test --- zokrates_core/src/flatten/mod.rs | 56 ++++++++++++++++++++++++++++++-- 1 file changed, 54 insertions(+), 2 deletions(-) diff --git a/zokrates_core/src/flatten/mod.rs b/zokrates_core/src/flatten/mod.rs index 71cb3972..f031a07e 100644 --- a/zokrates_core/src/flatten/mod.rs +++ b/zokrates_core/src/flatten/mod.rs @@ -2359,7 +2359,6 @@ mod tests { let mut flattener = Flattener::new(&config); let flat = flattener.flatten_function(&HashMap::new(), function); - let expected = FlatFunction { arguments: vec![], statements: vec![ @@ -2415,7 +2414,6 @@ mod tests { let mut flattener = Flattener::new(&config); let flat = flattener.flatten_function(&HashMap::new(), function); - let expected = FlatFunction { arguments: vec![], statements: vec![ @@ -2447,6 +2445,60 @@ mod tests { assert_eq!(flat, expected); } + #[test] + fn assertion_uint_eq() { + let metadata = UMetadata { + max: 0xffffffff_u32.into(), + should_reduce: ShouldReduce::False, + }; + let function = ZirFunction:: { + arguments: vec![], + statements: vec![ + ZirStatement::Definition( + Variable::uint("a".into(), 32), + ZirExpression::Uint( + UExpressionInner::Value(42) + .annotate(32) + .metadata(metadata.clone()), + ), + ), + ZirStatement::Assertion(BooleanExpression::UintEq( + box UExpressionInner::Identifier("a".into()) + .annotate(32) + .metadata(metadata.clone()), + box UExpressionInner::Value(42).annotate(32).metadata(metadata), + )), + ], + signature: Signature { + inputs: vec![], + outputs: vec![], + }, + }; + + let config = CompileConfig::default(); + let mut flattener = Flattener::new(&config); + + let flat = flattener.flatten_function(&HashMap::new(), function); + let expected = FlatFunction { + arguments: vec![], + statements: vec![ + FlatStatement::Definition( + FlatVariable::new(0), + FlatExpression::Number(Bn128Field::from(42)), + ), + FlatStatement::Condition( + FlatExpression::Mult( + box FlatExpression::Identifier(FlatVariable::new(0)), + box FlatExpression::Number(Bn128Field::from(1)), + ), + FlatExpression::Number(Bn128Field::from(42)), + ), + ], + }; + + assert_eq!(flat, expected); + } + #[test] fn powers_zero() { // def main(): From 7295c91af590effb25e9df129db34e2d65e15ca8 Mon Sep 17 00:00:00 2001 From: dark64 Date: Tue, 23 Feb 2021 17:22:25 +0100 Subject: [PATCH 07/22] implement into_iter for boolean expression --- zokrates_core/src/flatten/mod.rs | 33 +++++++------------------------- zokrates_core/src/zir/mod.rs | 33 ++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 26 deletions(-) diff --git a/zokrates_core/src/flatten/mod.rs b/zokrates_core/src/flatten/mod.rs index f031a07e..76ad3528 100644 --- a/zokrates_core/src/flatten/mod.rs +++ b/zokrates_core/src/flatten/mod.rs @@ -2018,12 +2018,11 @@ impl<'ast, T: Field> Flattener<'ast, T> { ZirStatement::Assertion(e) => { match e { BooleanExpression::And(..) => { - let mut iter = self.unwrap_and_chain(e).into_iter(); - while let Some(inner) = iter.next() { + for boolean in e.into_iter() { self.flatten_statement( symbols, statements_flattened, - ZirStatement::Assertion(inner), + ZirStatement::Assertion(boolean), ) } } @@ -2031,7 +2030,7 @@ impl<'ast, T: Field> Flattener<'ast, T> { let lhs = self.flatten_field_expression(symbols, statements_flattened, lhs); let rhs = self.flatten_field_expression(symbols, statements_flattened, rhs); - self.flatten_assertion(statements_flattened, lhs, rhs) + self.flatten_equality(statements_flattened, lhs, rhs) } BooleanExpression::UintEq(box lhs, box rhs) => { let lhs = self @@ -2041,7 +2040,7 @@ impl<'ast, T: Field> Flattener<'ast, T> { .flatten_uint_expression(symbols, statements_flattened, rhs) .get_field_unchecked(); - self.flatten_assertion(statements_flattened, lhs, rhs) + self.flatten_equality(statements_flattened, lhs, rhs) } BooleanExpression::BoolEq(box lhs, box rhs) => { let lhs = @@ -2049,7 +2048,7 @@ impl<'ast, T: Field> Flattener<'ast, T> { let rhs = self.flatten_boolean_expression(symbols, statements_flattened, rhs); - self.flatten_assertion(statements_flattened, lhs, rhs) + self.flatten_equality(statements_flattened, lhs, rhs) } _ => { // naive approach: flatten the boolean to a single field element and constrain it to 1 @@ -2120,24 +2119,6 @@ impl<'ast, T: Field> Flattener<'ast, T> { } } - /// Unwraps a boolean & (and) expression chain to a flat vector of boolean expressions - /// - /// # Arguments - /// * `e` - `BooleanExpression` to be flattened - fn unwrap_and_chain( - &mut self, - e: BooleanExpression<'ast, T>, - ) -> Vec> { - match e { - BooleanExpression::And(box lhs, box rhs) => { - let mut inner = self.unwrap_and_chain(lhs); - inner.push(rhs); - inner - } - _ => vec![e], - } - } - /// Flattens a function /// /// # Arguments @@ -2202,7 +2183,7 @@ impl<'ast, T: Field> Flattener<'ast, T> { } } - fn flatten_assertion( + fn flatten_equality( &mut self, statements_flattened: &mut FlatStatements, lhs: FlatExpression, @@ -2449,7 +2430,7 @@ mod tests { fn assertion_uint_eq() { let metadata = UMetadata { max: 0xffffffff_u32.into(), - should_reduce: ShouldReduce::False, + should_reduce: ShouldReduce::True, }; let function = ZirFunction:: { arguments: vec![], diff --git a/zokrates_core/src/zir/mod.rs b/zokrates_core/src/zir/mod.rs index 73199e3a..79eaa8b4 100644 --- a/zokrates_core/src/zir/mod.rs +++ b/zokrates_core/src/zir/mod.rs @@ -422,6 +422,39 @@ pub enum BooleanExpression<'ast, T> { ), } +pub struct ConjunctionIterator { + current: Vec, +} + +impl<'ast, T> Iterator for ConjunctionIterator> { + type Item = BooleanExpression<'ast, T>; + + fn next(&mut self) -> Option { + self.current + .pop() + .map(|n| match n { + BooleanExpression::And(box left, box right) => { + self.current.push(left); + self.current.push(right); + self.next() + } + n => Some(n), + }) + .flatten() + } +} + +impl<'ast, T> IntoIterator for BooleanExpression<'ast, T> { + type Item = BooleanExpression<'ast, T>; + type IntoIter = ConjunctionIterator; + + fn into_iter(self) -> Self::IntoIter { + ConjunctionIterator { + current: vec![self], + } + } +} + // Downcasts impl<'ast, T> TryFrom> for FieldElementExpression<'ast, T> { type Error = (); From d380820c476a873600f45234e11594ea090a49c4 Mon Sep 17 00:00:00 2001 From: dark64 Date: Wed, 24 Feb 2021 22:06:44 +0100 Subject: [PATCH 08/22] refactor --- zokrates_core/src/flatten/mod.rs | 79 ++++++++++++------- .../tests/tests/assert_one.json | 4 +- 2 files changed, 51 insertions(+), 32 deletions(-) diff --git a/zokrates_core/src/flatten/mod.rs b/zokrates_core/src/flatten/mod.rs index 76ad3528..1cc093d3 100644 --- a/zokrates_core/src/flatten/mod.rs +++ b/zokrates_core/src/flatten/mod.rs @@ -2183,34 +2183,57 @@ impl<'ast, T: Field> Flattener<'ast, T> { } } + /// Flattens an equality expression + /// + /// # Arguments + /// + /// * `statements_flattened` - `FlatStatements` Vector where new flattened statements can be added. + /// * `lhs` - `FlatExpression` Left-hand side of the equality expression. + /// * `rhs` - `FlatExpression` Right-hand side of the equality expression. fn flatten_equality( &mut self, statements_flattened: &mut FlatStatements, lhs: FlatExpression, rhs: FlatExpression, ) { - let lhs_flattened = match lhs { - FlatExpression::Number(_) | FlatExpression::Identifier(_) => lhs, - _ => { + let (lhs, rhs) = match (lhs, rhs) { + (FlatExpression::Mult(box x, box y), z) | (z, FlatExpression::Mult(box x, box y)) => ( + self.identify_expression(z, statements_flattened), + FlatExpression::Mult( + box self.identify_expression(x, statements_flattened), + box self.identify_expression(y, statements_flattened), + ), + ), + (x, z) => ( + self.identify_expression(z, statements_flattened), + FlatExpression::Mult( + box self.identify_expression(x, statements_flattened), + box FlatExpression::Number(T::from(1)), + ), + ), + }; + statements_flattened.push(FlatStatement::Condition(lhs, rhs)); + } + + /// Identifies a non-linear expression by assigning it to a new identifier. + /// + /// # Arguments + /// + /// * `e` - `FlatExpression` Expression to be assigned to an identifier. + /// * `statements_flattened` - `FlatStatements` Vector where new flattened statements can be added. + fn identify_expression( + &mut self, + e: FlatExpression, + statements_flattened: &mut FlatStatements, + ) -> FlatExpression { + match e.is_linear() { + true => e, + false => { let sym = self.use_sym(); - statements_flattened.push(FlatStatement::Definition(sym, lhs)); + statements_flattened.push(FlatStatement::Definition(sym, e)); FlatExpression::Identifier(sym) } - }; - - let rhs_flattened = match rhs { - FlatExpression::Number(_) | FlatExpression::Identifier(_) => rhs, - _ => { - let sym = self.use_sym(); - statements_flattened.push(FlatStatement::Definition(sym, rhs)); - FlatExpression::Identifier(sym) - } - }; - - statements_flattened.push(FlatStatement::Condition( - FlatExpression::Mult(box lhs_flattened, box FlatExpression::Number(T::from(1))), - rhs_flattened, - )); + } } /// Returns a fresh FlatVariable for a given Variable @@ -2352,11 +2375,11 @@ mod tests { FlatExpression::Number(Bn128Field::from(1)), ), FlatStatement::Condition( + FlatExpression::Identifier(FlatVariable::new(1)), FlatExpression::Mult( box FlatExpression::Identifier(FlatVariable::new(0)), box FlatExpression::Number(Bn128Field::from(1)), ), - FlatExpression::Identifier(FlatVariable::new(1)), ), ], }; @@ -2406,19 +2429,15 @@ mod tests { FlatVariable::new(1), FlatExpression::Number(Bn128Field::from(42)), ), - FlatStatement::Definition( - FlatVariable::new(2), - FlatExpression::Add( - box FlatExpression::Identifier(FlatVariable::new(0)), - box FlatExpression::Number(Bn128Field::from(1)), - ), - ), FlatStatement::Condition( + FlatExpression::Identifier(FlatVariable::new(1)), FlatExpression::Mult( - box FlatExpression::Identifier(FlatVariable::new(2)), + box FlatExpression::Add( + box FlatExpression::Identifier(FlatVariable::new(0)), + box FlatExpression::Number(Bn128Field::from(1)), + ), box FlatExpression::Number(Bn128Field::from(1)), ), - FlatExpression::Identifier(FlatVariable::new(1)), ), ], }; @@ -2468,11 +2487,11 @@ mod tests { FlatExpression::Number(Bn128Field::from(42)), ), FlatStatement::Condition( + FlatExpression::Number(Bn128Field::from(42)), FlatExpression::Mult( box FlatExpression::Identifier(FlatVariable::new(0)), box FlatExpression::Number(Bn128Field::from(1)), ), - FlatExpression::Number(Bn128Field::from(42)), ), ], }; diff --git a/zokrates_core_test/tests/tests/assert_one.json b/zokrates_core_test/tests/tests/assert_one.json index 0b09dccd..d0a55371 100644 --- a/zokrates_core_test/tests/tests/assert_one.json +++ b/zokrates_core_test/tests/tests/assert_one.json @@ -9,8 +9,8 @@ "output": { "Err": { "UnsatisfiedConstraint": { - "left": "1", - "right": "0" + "left": "0", + "right": "1" } } } From 05c2cabba23f30644d3c8d79063e8a2989d335da Mon Sep 17 00:00:00 2001 From: dark64 Date: Thu, 25 Feb 2021 20:25:25 +0100 Subject: [PATCH 09/22] add tests --- zokrates_core/src/flatten/mod.rs | 359 +++++++++++++++++++++++++++++-- zokrates_core/src/zir/mod.rs | 7 +- 2 files changed, 346 insertions(+), 20 deletions(-) diff --git a/zokrates_core/src/flatten/mod.rs b/zokrates_core/src/flatten/mod.rs index 1cc093d3..f3a746ff 100644 --- a/zokrates_core/src/flatten/mod.rs +++ b/zokrates_core/src/flatten/mod.rs @@ -2018,7 +2018,7 @@ impl<'ast, T: Field> Flattener<'ast, T> { ZirStatement::Assertion(e) => { match e { BooleanExpression::And(..) => { - for boolean in e.into_iter() { + for boolean in e.into_conjunction_iterator() { self.flatten_statement( symbols, statements_flattened, @@ -2337,20 +2337,29 @@ mod tests { #[test] fn assertion_bool_eq() { + // def main(): + // bool x = true + // bool y = true + // assert(x == y) + + // def main(): + // _0 = 1 + // _1 = 1 + // _1 == (_0 * 1) let function = ZirFunction:: { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::boolean("a".into()), + Variable::boolean("x".into()), BooleanExpression::Value(true).into(), ), ZirStatement::Definition( - Variable::boolean("b".into()), + Variable::boolean("y".into()), BooleanExpression::Value(true).into(), ), ZirStatement::Assertion(BooleanExpression::BoolEq( - box BooleanExpression::Identifier("a".into()), - box BooleanExpression::Identifier("b".into()), + box BooleanExpression::Identifier("x".into()), + box BooleanExpression::Identifier("y".into()), )), ], signature: Signature { @@ -2389,23 +2398,32 @@ mod tests { #[test] fn assertion_field_eq() { + // def main(): + // field x = 1 + // field y = 2 + // assert(x + 1 == y) + + // def main(): + // _0 = 42 + // _1 = 42 + // _1 == ((_0 + 1) * 1) let function = ZirFunction { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::field_element("a"), - FieldElementExpression::Number(Bn128Field::from(42)).into(), + Variable::field_element("x"), + FieldElementExpression::Number(Bn128Field::from(1)).into(), ), ZirStatement::Definition( - Variable::field_element("b"), - FieldElementExpression::Number(Bn128Field::from(42)).into(), + Variable::field_element("y"), + FieldElementExpression::Number(Bn128Field::from(2)).into(), ), ZirStatement::Assertion(BooleanExpression::FieldEq( box FieldElementExpression::Add( - box FieldElementExpression::Identifier("a".into()), + box FieldElementExpression::Identifier("x".into()), box FieldElementExpression::Number(Bn128Field::from(1)).into(), ), - box FieldElementExpression::Identifier("b".into()), + box FieldElementExpression::Identifier("y".into()), )), ], signature: Signature { @@ -2423,11 +2441,11 @@ mod tests { statements: vec![ FlatStatement::Definition( FlatVariable::new(0), - FlatExpression::Number(Bn128Field::from(42)), + FlatExpression::Number(Bn128Field::from(1)), ), FlatStatement::Definition( FlatVariable::new(1), - FlatExpression::Number(Bn128Field::from(42)), + FlatExpression::Number(Bn128Field::from(2)), ), FlatStatement::Condition( FlatExpression::Identifier(FlatVariable::new(1)), @@ -2447,6 +2465,13 @@ mod tests { #[test] fn assertion_uint_eq() { + // def main(): + // u32 x = 42 + // assert(x == 42) + + // def main(): + // _0 = 42 + // 42 == (_0 * 1) let metadata = UMetadata { max: 0xffffffff_u32.into(), should_reduce: ShouldReduce::True, @@ -2455,7 +2480,7 @@ mod tests { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::uint("a".into(), 32), + Variable::uint("x".into(), 32), ZirExpression::Uint( UExpressionInner::Value(42) .annotate(32) @@ -2463,7 +2488,7 @@ mod tests { ), ), ZirStatement::Assertion(BooleanExpression::UintEq( - box UExpressionInner::Identifier("a".into()) + box UExpressionInner::Identifier("x".into()) .annotate(32) .metadata(metadata.clone()), box UExpressionInner::Value(42).annotate(32).metadata(metadata), @@ -2499,6 +2524,310 @@ mod tests { assert_eq!(flat, expected); } + #[test] + fn assertion_ident_eq_ident() { + // def main(): + // field x = 2 + // field y = 2 + // assert(x == y) + + // def main(): + // _0 = 2 + // _1 = 2 + // _1 == (_0 * 1) + let function = ZirFunction { + arguments: vec![], + statements: vec![ + ZirStatement::Definition( + Variable::field_element("x"), + FieldElementExpression::Number(Bn128Field::from(2)).into(), + ), + ZirStatement::Definition( + Variable::field_element("y"), + FieldElementExpression::Number(Bn128Field::from(2)).into(), + ), + ZirStatement::Assertion(BooleanExpression::FieldEq( + box FieldElementExpression::Identifier("x".into()), + box FieldElementExpression::Identifier("y".into()), + )), + ], + signature: Signature { + inputs: vec![], + outputs: vec![], + }, + }; + + let config = CompileConfig::default(); + let mut flattener = Flattener::new(&config); + + let flat = flattener.flatten_function(&HashMap::new(), function); + let expected = FlatFunction { + arguments: vec![], + statements: vec![ + FlatStatement::Definition( + FlatVariable::new(0), + FlatExpression::Number(Bn128Field::from(2)), + ), + FlatStatement::Definition( + FlatVariable::new(1), + FlatExpression::Number(Bn128Field::from(2)), + ), + FlatStatement::Condition( + FlatExpression::Identifier(FlatVariable::new(1)), + FlatExpression::Mult( + box FlatExpression::Identifier(FlatVariable::new(0)), + box FlatExpression::Number(Bn128Field::from(1)), + ), + ), + ], + }; + + assert_eq!(flat, expected); + } + + #[test] + fn assertion_mult_eq_ident() { + // def main(): + // field x = 2 + // field y = 2 + // field z = 4 + // assert(x * y == z) + + // def main(): + // _0 = 2 + // _1 = 2 + // _2 = 4 + // _2 == (_0 * _1) + let function = ZirFunction { + arguments: vec![], + statements: vec![ + ZirStatement::Definition( + Variable::field_element("x"), + FieldElementExpression::Number(Bn128Field::from(2)).into(), + ), + ZirStatement::Definition( + Variable::field_element("y"), + FieldElementExpression::Number(Bn128Field::from(2)).into(), + ), + ZirStatement::Definition( + Variable::field_element("z"), + FieldElementExpression::Number(Bn128Field::from(4)).into(), + ), + ZirStatement::Assertion(BooleanExpression::FieldEq( + box FieldElementExpression::Mult( + box FieldElementExpression::Identifier("x".into()), + box FieldElementExpression::Identifier("y".into()), + ), + box FieldElementExpression::Identifier("z".into()), + )), + ], + signature: Signature { + inputs: vec![], + outputs: vec![], + }, + }; + + let config = CompileConfig::default(); + let mut flattener = Flattener::new(&config); + + let flat = flattener.flatten_function(&HashMap::new(), function); + let expected = FlatFunction { + arguments: vec![], + statements: vec![ + FlatStatement::Definition( + FlatVariable::new(0), + FlatExpression::Number(Bn128Field::from(2)), + ), + FlatStatement::Definition( + FlatVariable::new(1), + FlatExpression::Number(Bn128Field::from(2)), + ), + FlatStatement::Definition( + FlatVariable::new(2), + FlatExpression::Number(Bn128Field::from(4)), + ), + FlatStatement::Condition( + FlatExpression::Identifier(FlatVariable::new(2)), + FlatExpression::Mult( + box FlatExpression::Identifier(FlatVariable::new(0)), + box FlatExpression::Identifier(FlatVariable::new(1)), + ), + ), + ], + }; + + assert_eq!(flat, expected); + } + + #[test] + fn assertion_ident_eq_mult() { + // def main(): + // field x = 2 + // field y = 2 + // field z = 4 + // assert(z == x * y) + + // def main(): + // _0 = 2 + // _1 = 2 + // _2 = 4 + // _2 == (_0 * _1) + let function = ZirFunction { + arguments: vec![], + statements: vec![ + ZirStatement::Definition( + Variable::field_element("x"), + FieldElementExpression::Number(Bn128Field::from(2)).into(), + ), + ZirStatement::Definition( + Variable::field_element("y"), + FieldElementExpression::Number(Bn128Field::from(2)).into(), + ), + ZirStatement::Definition( + Variable::field_element("z"), + FieldElementExpression::Number(Bn128Field::from(4)).into(), + ), + ZirStatement::Assertion(BooleanExpression::FieldEq( + box FieldElementExpression::Identifier("z".into()), + box FieldElementExpression::Mult( + box FieldElementExpression::Identifier("x".into()), + box FieldElementExpression::Identifier("y".into()), + ), + )), + ], + signature: Signature { + inputs: vec![], + outputs: vec![], + }, + }; + + let config = CompileConfig::default(); + let mut flattener = Flattener::new(&config); + + let flat = flattener.flatten_function(&HashMap::new(), function); + let expected = FlatFunction { + arguments: vec![], + statements: vec![ + FlatStatement::Definition( + FlatVariable::new(0), + FlatExpression::Number(Bn128Field::from(2)), + ), + FlatStatement::Definition( + FlatVariable::new(1), + FlatExpression::Number(Bn128Field::from(2)), + ), + FlatStatement::Definition( + FlatVariable::new(2), + FlatExpression::Number(Bn128Field::from(4)), + ), + FlatStatement::Condition( + FlatExpression::Identifier(FlatVariable::new(2)), + FlatExpression::Mult( + box FlatExpression::Identifier(FlatVariable::new(0)), + box FlatExpression::Identifier(FlatVariable::new(1)), + ), + ), + ], + }; + + assert_eq!(flat, expected); + } + + #[test] + fn assertion_mult_eq_mult() { + // def main(): + // field x = 4 + // field y = 4 + // field z = 8 + // field t = 2 + // assert(x * y == z * t) + + // def main(): + // _0 = 4 + // _1 = 4 + // _2 = 8 + // _3 = 2 + // _4 = (_2 * _3) + // _4 == (_0 * _1) + let function = ZirFunction { + arguments: vec![], + statements: vec![ + ZirStatement::Definition( + Variable::field_element("x"), + FieldElementExpression::Number(Bn128Field::from(4)).into(), + ), + ZirStatement::Definition( + Variable::field_element("y"), + FieldElementExpression::Number(Bn128Field::from(4)).into(), + ), + ZirStatement::Definition( + Variable::field_element("z"), + FieldElementExpression::Number(Bn128Field::from(8)).into(), + ), + ZirStatement::Definition( + Variable::field_element("t"), + FieldElementExpression::Number(Bn128Field::from(2)).into(), + ), + ZirStatement::Assertion(BooleanExpression::FieldEq( + box FieldElementExpression::Mult( + box FieldElementExpression::Identifier("x".into()), + box FieldElementExpression::Identifier("y".into()), + ), + box FieldElementExpression::Mult( + box FieldElementExpression::Identifier("z".into()), + box FieldElementExpression::Identifier("t".into()), + ), + )), + ], + signature: Signature { + inputs: vec![], + outputs: vec![], + }, + }; + + let config = CompileConfig::default(); + let mut flattener = Flattener::new(&config); + + let flat = flattener.flatten_function(&HashMap::new(), function); + let expected = FlatFunction { + arguments: vec![], + statements: vec![ + FlatStatement::Definition( + FlatVariable::new(0), + FlatExpression::Number(Bn128Field::from(4)), + ), + FlatStatement::Definition( + FlatVariable::new(1), + FlatExpression::Number(Bn128Field::from(4)), + ), + FlatStatement::Definition( + FlatVariable::new(2), + FlatExpression::Number(Bn128Field::from(8)), + ), + FlatStatement::Definition( + FlatVariable::new(3), + FlatExpression::Number(Bn128Field::from(2)), + ), + FlatStatement::Definition( + FlatVariable::new(4), + FlatExpression::Mult( + box FlatExpression::Identifier(FlatVariable::new(2)), + box FlatExpression::Identifier(FlatVariable::new(3)), + ), + ), + FlatStatement::Condition( + FlatExpression::Identifier(FlatVariable::new(4)), + FlatExpression::Mult( + box FlatExpression::Identifier(FlatVariable::new(0)), + box FlatExpression::Identifier(FlatVariable::new(1)), + ), + ), + ], + }; + + assert_eq!(flat, expected); + } + #[test] fn powers_zero() { // def main(): diff --git a/zokrates_core/src/zir/mod.rs b/zokrates_core/src/zir/mod.rs index 79eaa8b4..6464951e 100644 --- a/zokrates_core/src/zir/mod.rs +++ b/zokrates_core/src/zir/mod.rs @@ -444,11 +444,8 @@ impl<'ast, T> Iterator for ConjunctionIterator> { } } -impl<'ast, T> IntoIterator for BooleanExpression<'ast, T> { - type Item = BooleanExpression<'ast, T>; - type IntoIter = ConjunctionIterator; - - fn into_iter(self) -> Self::IntoIter { +impl<'ast, T> BooleanExpression<'ast, T> { + pub fn into_conjunction_iterator(self) -> ConjunctionIterator { ConjunctionIterator { current: vec![self], } From 25ec7d0699e8f2cb11642c50c906d4d64ec889ea Mon Sep 17 00:00:00 2001 From: dark64 Date: Mon, 1 Mar 2021 09:58:26 +0100 Subject: [PATCH 10/22] leave a comment for the unsafe code --- zokrates_core/src/proof_system/bellman/mod.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/zokrates_core/src/proof_system/bellman/mod.rs b/zokrates_core/src/proof_system/bellman/mod.rs index bdef4064..0368fad6 100644 --- a/zokrates_core/src/proof_system/bellman/mod.rs +++ b/zokrates_core/src/proof_system/bellman/mod.rs @@ -167,6 +167,9 @@ impl Computation { getrandom::getrandom(&mut seed)?; use std::mem::transmute; + // This is safe because we are just reinterpreting the bytes (u8[32] -> u32[8]), + // byte order or the actual content does not matter here as this is used + // as a random seed for the rng. let seed: [u32; 8] = unsafe { transmute(seed) }; Ok(seed) } From f30bd5319f403443f9bae1a3d3107c517a2c6028 Mon Sep 17 00:00:00 2001 From: dark64 Date: Tue, 2 Mar 2021 18:01:34 +0100 Subject: [PATCH 11/22] replace program input type from JsValue to u8 slice ref --- zokrates_js/src/lib.rs | 27 +++++++++++---------------- zokrates_js/tests/tests.js | 17 +++++++++-------- zokrates_js/wrapper.js | 7 ++++--- 3 files changed, 24 insertions(+), 27 deletions(-) diff --git a/zokrates_js/src/lib.rs b/zokrates_js/src/lib.rs index 904c04fe..41af7fdd 100644 --- a/zokrates_js/src/lib.rs +++ b/zokrates_js/src/lib.rs @@ -36,8 +36,8 @@ pub struct ComputationResult { } #[inline] -fn deserialize_program(value: &Vec) -> Result, JsValue> { - deserialize(&value) +fn deserialize_program(value: &[u8]) -> Result, JsValue> { + deserialize(value) .map_err(|err| JsValue::from_str(&format!("Could not deserialize program: {}", err))) } @@ -125,11 +125,9 @@ pub fn compile( } #[wasm_bindgen] -pub fn compute_witness(artifacts: JsValue, args: JsValue) -> Result { - let result: CompilationResult = artifacts.into_serde().unwrap(); - let program_flattened = deserialize_program(&result.program)?; - - let abi: Abi = serde_json::from_str(result.abi.as_str()) +pub fn compute_witness(program: &[u8], abi: JsValue, args: JsValue) -> Result { + let program_flattened = deserialize_program(program)?; + let abi: Abi = serde_json::from_str(abi.as_string().unwrap().as_str()) .map_err(|err| JsValue::from_str(&format!("Could not deserialize abi: {}", err)))?; let signature: Signature = abi.signature(); @@ -157,9 +155,8 @@ pub fn compute_witness(artifacts: JsValue, args: JsValue) -> Result Result { - let input: Vec = program.into_serde().unwrap(); - let program_flattened = deserialize_program(&input)?; +pub fn setup(program: &[u8]) -> Result { + let program_flattened = deserialize_program(program)?; let keypair = >::setup(program_flattened); Ok(JsValue::from_serde(&keypair).unwrap()) } @@ -178,19 +175,17 @@ pub fn export_solidity_verifier(vk: JsValue, abi_version: JsValue) -> Result Result { - let input: Vec = program.into_serde().unwrap(); - let program_flattened = deserialize_program(&input)?; - +pub fn generate_proof(program: &[u8], witness: JsValue, pk: &[u8]) -> Result { + let program_flattened = deserialize_program(program)?; let str_witness = witness.as_string().unwrap(); + let ir_witness: ir::Witness = ir::Witness::read(str_witness.as_bytes()) .map_err(|err| JsValue::from_str(&format!("Could not read witness: {}", err)))?; - let proving_key: Vec = pk.into_serde().unwrap(); let proof = >::generate_proof( program_flattened, ir_witness, - proving_key, + pk.to_vec(), ); Ok(JsValue::from_serde(&proof).unwrap()) diff --git a/zokrates_js/tests/tests.js b/zokrates_js/tests/tests.js index 2064f003..46966239 100644 --- a/zokrates_js/tests/tests.js +++ b/zokrates_js/tests/tests.js @@ -18,11 +18,11 @@ describe('tests', function() { assert.ok(artifacts !== undefined); }) }); - + it('should throw on invalid code', function() { assert.throws(() => this.zokrates.compile(":-)")); }); - + it('should resolve stdlib module', function() { const stdlib = require('../stdlib.json'); assert.doesNotThrow(() => { @@ -30,7 +30,7 @@ describe('tests', function() { this.zokrates.compile(code); }); }); - + it('should resolve user module', function() { assert.doesNotThrow(() => { const code = 'import "test" as test\ndef main() -> field: return test()'; @@ -59,10 +59,10 @@ describe('tests', function() { assert.doesNotThrow(() => { const code = 'def main(private field a) -> field: return a * a'; const artifacts = this.zokrates.compile(code); - + const result = this.zokrates.computeWitness(artifacts, ["2"]); const output = JSON.parse(result.output); - + assert.deepEqual(output, ["4"]); }); }); @@ -71,7 +71,7 @@ describe('tests', function() { assert.throws(() => { const code = 'def main(private field a) -> field: return a * a'; const artifacts = this.zokrates.compile(code); - + this.zokrates.computeWitness(artifacts, ["1", "2"]); }); }); @@ -80,7 +80,7 @@ describe('tests', function() { assert.throws(() => { const code = 'def main(private field a) -> field: return a * a'; const artifacts = this.zokrates.compile(code); - + this.zokrates.computeWitness(artifacts, [true]); }); }); @@ -91,7 +91,7 @@ describe('tests', function() { assert.doesNotThrow(() => { const code = 'def main(private field a) -> field: return a * a'; const artifacts = this.zokrates.compile(code); - + this.zokrates.setup(artifacts.program); }); }); @@ -137,6 +137,7 @@ describe('tests', function() { assert(this.zokrates.verify(keypair.vk, proof) == true); }) }); + it('should fail', function() { assert.doesNotThrow(() => { const code = 'def main(private field a) -> field: return a * a'; diff --git a/zokrates_js/wrapper.js b/zokrates_js/wrapper.js index 30fe44ef..da3899ac 100644 --- a/zokrates_js/wrapper.js +++ b/zokrates_js/wrapper.js @@ -46,7 +46,7 @@ module.exports = (dep) => { }; const { program, abi } = zokrates.compile(source, location, callback, createConfig(config)); return { - program: Array.from(program), + program: new Uint8Array(program), abi } }, @@ -54,11 +54,12 @@ module.exports = (dep) => { const { vk, pk } = zokrates.setup(program); return { vk, - pk: Array.from(pk) + pk: new Uint8Array(pk) }; }, computeWitness: (artifacts, args) => { - return zokrates.compute_witness(artifacts, JSON.stringify(Array.from(args))); + const { program, abi } = artifacts; + return zokrates.compute_witness(program, abi, JSON.stringify(Array.from(args))); }, exportSolidityVerifier: (verificationKey, abiVersion) => { return zokrates.export_solidity_verifier(verificationKey, abiVersion); From a40cea801dad1dee4c7e3e6a0e1126f0054a874f Mon Sep 17 00:00:00 2001 From: dark64 Date: Tue, 2 Mar 2021 18:05:20 +0100 Subject: [PATCH 12/22] 1.0.28 --- zokrates_js/package-lock.json | 2 +- zokrates_js/package.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/zokrates_js/package-lock.json b/zokrates_js/package-lock.json index ecc263cd..089394fa 100644 --- a/zokrates_js/package-lock.json +++ b/zokrates_js/package-lock.json @@ -1,6 +1,6 @@ { "name": "zokrates-js", - "version": "1.0.27", + "version": "1.0.28", "lockfileVersion": 1, "requires": true, "dependencies": { diff --git a/zokrates_js/package.json b/zokrates_js/package.json index 337b1618..6765f16f 100644 --- a/zokrates_js/package.json +++ b/zokrates_js/package.json @@ -2,7 +2,7 @@ "name": "zokrates-js", "main": "index.js", "author": "Darko Macesic ", - "version": "1.0.27", + "version": "1.0.28", "keywords": [ "zokrates", "wasm-bindgen", From 2c4a0c59f8fec2be4b692a53dddfc1d94be64aed Mon Sep 17 00:00:00 2001 From: Alexey Tsvetkov Date: Tue, 9 Mar 2021 15:19:07 +0300 Subject: [PATCH 13/22] Use write_all to write the whole pk in cli_setup() --- zokrates_cli/src/ops/setup.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/zokrates_cli/src/ops/setup.rs b/zokrates_cli/src/ops/setup.rs index 693b7819..d52f514f 100644 --- a/zokrates_cli/src/ops/setup.rs +++ b/zokrates_cli/src/ops/setup.rs @@ -152,7 +152,7 @@ fn cli_setup, B: Backend>( let mut vk_file = File::create(vk_path) .map_err(|why| format!("couldn't create {}: {}", vk_path.display(), why))?; vk_file - .write( + .write_all( serde_json::to_string_pretty(&keypair.vk) .unwrap() .as_bytes(), @@ -163,7 +163,7 @@ fn cli_setup, B: Backend>( let mut pk_file = File::create(pk_path) .map_err(|why| format!("couldn't create {}: {}", pk_path.display(), why))?; pk_file - .write(keypair.pk.as_ref()) + .write_all(keypair.pk.as_ref()) .map_err(|why| format!("couldn't write to {}: {}", pk_path.display(), why))?; println!("Setup completed."); From 4c5aa898e014c7cf2cdde154790832c92da29937 Mon Sep 17 00:00:00 2001 From: schaeff Date: Wed, 10 Mar 2021 11:28:21 +0100 Subject: [PATCH 14/22] fix panic warning --- zokrates_core/src/static_analysis/mod.rs | 2 +- .../src/static_analysis/unconstrained_vars.rs | 16 +++++++--------- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/zokrates_core/src/static_analysis/mod.rs b/zokrates_core/src/static_analysis/mod.rs index 1f245890..83fb69ca 100644 --- a/zokrates_core/src/static_analysis/mod.rs +++ b/zokrates_core/src/static_analysis/mod.rs @@ -40,7 +40,7 @@ pub trait Analyse { impl<'ast, T: Field> TypedProgram<'ast, T> { pub fn analyse(self) -> ZirProgram<'ast, T> { // propagated unrolling - let r = PropagatedUnroller::unroll(self).unwrap_or_else(|e| panic!(e)); + let r = PropagatedUnroller::unroll(self).unwrap_or_else(|e| panic!("{}", e)); // return binding let r = ReturnBinder::bind(r); diff --git a/zokrates_core/src/static_analysis/unconstrained_vars.rs b/zokrates_core/src/static_analysis/unconstrained_vars.rs index 64e7b625..2bcbbd05 100644 --- a/zokrates_core/src/static_analysis/unconstrained_vars.rs +++ b/zokrates_core/src/static_analysis/unconstrained_vars.rs @@ -28,15 +28,13 @@ impl UnconstrainedVariableDetector { // we should probably handle this case instead of asserting at some point assert!( instance.variables.is_empty(), - format!( - "Unconstrained variables are not allowed (found {} occurrence{})", - instance.variables.len(), - if instance.variables.len() == 1 { - "" - } else { - "s" - } - ) + "Unconstrained variables are not allowed (found {} occurrence{})", + instance.variables.len(), + if instance.variables.len() == 1 { + "" + } else { + "s" + } ); p } From f435a2958d12a0a3c90501da6f3ae2c4ad7bd517 Mon Sep 17 00:00:00 2001 From: schaeff Date: Wed, 10 Mar 2021 11:33:22 +0100 Subject: [PATCH 15/22] remove parse_to --- zokrates_parser/src/lib.rs | 424 ++++++++++++++++++------------------- 1 file changed, 212 insertions(+), 212 deletions(-) diff --git a/zokrates_parser/src/lib.rs b/zokrates_parser/src/lib.rs index 9d1f0cee..82d205ec 100644 --- a/zokrates_parser/src/lib.rs +++ b/zokrates_parser/src/lib.rs @@ -53,224 +53,224 @@ mod tests { mod rules { use super::*; - #[test] - fn parse_valid_identifier() { - parses_to! { - parser: ZoKratesParser, - input: "valididentifier_01", - rule: Rule::identifier, - tokens: [ - identifier(0, 18) - ] - }; - } + // #[test] + // fn parse_valid_identifier() { + // parses_to! { + // parser: ZoKratesParser, + // input: "valididentifier_01", + // rule: Rule::identifier, + // tokens: [ + // identifier(0, 18) + // ] + // }; + // } - #[test] - fn parse_parameter_list() { - parses_to! { - parser: ZoKratesParser, - input: "def foo(field a) -> (field, field): return 1 - ", - rule: Rule::function_definition, - tokens: [ - function_definition(0, 45, [ - identifier(4, 7), - // parameter_list is not created (silent rule) - parameter(8, 15, [ - ty(8, 13, [ - ty_basic(8, 13, [ - ty_field(8, 13) - ]) - ]), - identifier(14, 15) - ]), - // type_list is not created (silent rule) - ty(21, 26, [ - ty_basic(21, 26, [ - ty_field(21, 26) - ]) - ]), - ty(28, 33, [ - ty_basic(28, 33, [ - ty_field(28, 33) - ]) - ]), - statement(36, 45, [ - return_statement(36, 44, [ - expression(43, 44, [ - term(43, 44, [ - primary_expression(43, 44, [ - constant(43, 44, [ - decimal_number(43, 44) - ]) - ]) - ]) - ]) - ]) - ]) - ]) - ] - }; - } + // #[test] + // fn parse_parameter_list() { + // parses_to! { + // parser: ZoKratesParser, + // input: "def foo(field a) -> (field, field): return 1 + // ", + // rule: Rule::function_definition, + // tokens: [ + // function_definition(0, 45, [ + // identifier(4, 7), + // // parameter_list is not created (silent rule) + // parameter(8, 15, [ + // ty(8, 13, [ + // ty_basic(8, 13, [ + // ty_field(8, 13) + // ]) + // ]), + // identifier(14, 15) + // ]), + // // type_list is not created (silent rule) + // ty(21, 26, [ + // ty_basic(21, 26, [ + // ty_field(21, 26) + // ]) + // ]), + // ty(28, 33, [ + // ty_basic(28, 33, [ + // ty_field(28, 33) + // ]) + // ]), + // statement(36, 45, [ + // return_statement(36, 44, [ + // expression(43, 44, [ + // term(43, 44, [ + // primary_expression(43, 44, [ + // constant(43, 44, [ + // decimal_number(43, 44) + // ]) + // ]) + // ]) + // ]) + // ]) + // ]) + // ]) + // ] + // }; + // } - #[test] - fn parse_single_def_to_multi() { - parses_to! { - parser: ZoKratesParser, - input: r#"a = foo() - "#, - rule: Rule::statement, - tokens: [ - statement(0, 22, [ - definition_statement(0, 9, [ - optionally_typed_assignee(0, 2, [ - assignee(0, 2, [ - identifier(0, 1) - ]) - ]), - expression(4, 9, [ - term(4, 9, [ - postfix_expression(4, 9, [ - identifier(4, 7), - access(7, 9, [ - call_access(7, 9) - ]) - ]) - ]) - ]), - ]) - ]) - ] - }; - } + // #[test] + // fn parse_single_def_to_multi() { + // parses_to! { + // parser: ZoKratesParser, + // input: r#"a = foo() + // "#, + // rule: Rule::statement, + // tokens: [ + // statement(0, 22, [ + // definition_statement(0, 9, [ + // optionally_typed_assignee(0, 2, [ + // assignee(0, 2, [ + // identifier(0, 1) + // ]) + // ]), + // expression(4, 9, [ + // term(4, 9, [ + // postfix_expression(4, 9, [ + // identifier(4, 7), + // access(7, 9, [ + // call_access(7, 9) + // ]) + // ]) + // ]) + // ]), + // ]) + // ]) + // ] + // }; + // } - #[test] - fn parse_field_def_to_multi() { - parses_to! { - parser: ZoKratesParser, - input: r#"field a = foo() - "#, - rule: Rule::statement, - tokens: [ - statement(0, 28, [ - definition_statement(0, 15, [ - optionally_typed_assignee(0, 8, [ - ty(0, 5, [ - ty_basic(0, 5, [ - ty_field(0, 5) - ]) - ]), - assignee(6, 8, [ - identifier(6, 7) - ]) - ]), - expression(10, 15, [ - term(10, 15, [ - postfix_expression(10, 15, [ - identifier(10, 13), - access(13, 15, [ - call_access(13, 15) - ]) - ]) - ]) - ]), - ]) - ]) - ] - }; - } + // #[test] + // fn parse_field_def_to_multi() { + // parses_to! { + // parser: ZoKratesParser, + // input: r#"field a = foo() + // "#, + // rule: Rule::statement, + // tokens: [ + // statement(0, 28, [ + // definition_statement(0, 15, [ + // optionally_typed_assignee(0, 8, [ + // ty(0, 5, [ + // ty_basic(0, 5, [ + // ty_field(0, 5) + // ]) + // ]), + // assignee(6, 8, [ + // identifier(6, 7) + // ]) + // ]), + // expression(10, 15, [ + // term(10, 15, [ + // postfix_expression(10, 15, [ + // identifier(10, 13), + // access(13, 15, [ + // call_access(13, 15) + // ]) + // ]) + // ]) + // ]), + // ]) + // ]) + // ] + // }; + // } - #[test] - fn parse_u8_def_to_multi() { - parses_to! { - parser: ZoKratesParser, - input: r#"u32 a = foo() - "#, - rule: Rule::statement, - tokens: [ - statement(0, 26, [ - definition_statement(0, 13, [ - optionally_typed_assignee(0, 6, [ - ty(0, 3, [ - ty_basic(0, 3, [ - ty_u32(0, 3) - ]) - ]), - assignee(4, 6, [ - identifier(4, 5) - ]) - ]), - expression(8, 13, [ - term(8, 13, [ - postfix_expression(8, 13, [ - identifier(8, 11), - access(11, 13, [ - call_access(11, 13) - ]) - ]) - ]) - ]), - ]) - ]) - ] - }; - } + // #[test] + // fn parse_u8_def_to_multi() { + // parses_to! { + // parser: ZoKratesParser, + // input: r#"u32 a = foo() + // "#, + // rule: Rule::statement, + // tokens: [ + // statement(0, 26, [ + // definition_statement(0, 13, [ + // optionally_typed_assignee(0, 6, [ + // ty(0, 3, [ + // ty_basic(0, 3, [ + // ty_u32(0, 3) + // ]) + // ]), + // assignee(4, 6, [ + // identifier(4, 5) + // ]) + // ]), + // expression(8, 13, [ + // term(8, 13, [ + // postfix_expression(8, 13, [ + // identifier(8, 11), + // access(11, 13, [ + // call_access(11, 13) + // ]) + // ]) + // ]) + // ]), + // ]) + // ]) + // ] + // }; + // } - #[test] - fn parse_invalid_identifier() { - fails_with! { - parser: ZoKratesParser, - input: "0_invalididentifier", - rule: Rule::identifier, - positives: vec![Rule::identifier], - negatives: vec![], - pos: 0 - }; - } + // #[test] + // fn parse_invalid_identifier() { + // fails_with! { + // parser: ZoKratesParser, + // input: "0_invalididentifier", + // rule: Rule::identifier, + // positives: vec![Rule::identifier], + // negatives: vec![], + // pos: 0 + // }; + // } - #[test] - fn parse_struct_def() { - parses_to! { - parser: ZoKratesParser, - input: "struct Foo { field foo\n field[2] bar } - ", - rule: Rule::ty_struct_definition, - tokens: [ - ty_struct_definition(0, 39, [ - identifier(7, 10), - struct_field(13, 22, [ - ty(13, 18, [ - ty_basic(13, 18, [ - ty_field(13, 18) - ]) - ]), - identifier(19, 22) - ]), - struct_field(24, 36, [ - ty(24, 33, [ - ty_array(24, 33, [ - ty_basic_or_struct(24, 29, [ - ty_basic(24, 29, [ - ty_field(24, 29) - ]) - ]), - expression(30, 31, [ - term(30, 31, [ - primary_expression(30, 31, [ - constant(30, 31, [ - decimal_number(30, 31) - ]) - ]) - ]) - ]) - ]) - ]), - identifier(33, 36) - ]) - ]) - ] - }; - } + // #[test] + // fn parse_struct_def() { + // parses_to! { + // parser: ZoKratesParser, + // input: "struct Foo { field foo\n field[2] bar } + // ", + // rule: Rule::ty_struct_definition, + // tokens: [ + // ty_struct_definition(0, 39, [ + // identifier(7, 10), + // struct_field(13, 22, [ + // ty(13, 18, [ + // ty_basic(13, 18, [ + // ty_field(13, 18) + // ]) + // ]), + // identifier(19, 22) + // ]), + // struct_field(24, 36, [ + // ty(24, 33, [ + // ty_array(24, 33, [ + // ty_basic_or_struct(24, 29, [ + // ty_basic(24, 29, [ + // ty_field(24, 29) + // ]) + // ]), + // expression(30, 31, [ + // term(30, 31, [ + // primary_expression(30, 31, [ + // constant(30, 31, [ + // decimal_number(30, 31) + // ]) + // ]) + // ]) + // ]) + // ]) + // ]), + // identifier(33, 36) + // ]) + // ]) + // ] + // }; + // } #[test] fn parse_invalid_identifier_because_keyword() { From 24bdebb5246d7242f6872b33321f608cdf3eaca2 Mon Sep 17 00:00:00 2001 From: schaeff Date: Fri, 19 Mar 2021 13:35:30 +0100 Subject: [PATCH 16/22] bump versions --- Cargo.lock | 14 ++++++++------ zokrates_cli/Cargo.toml | 2 +- zokrates_core/Cargo.toml | 2 +- zokrates_core_test/Cargo.toml | 2 +- zokrates_field/Cargo.toml | 2 +- zokrates_js/Cargo.toml | 2 +- zokrates_js/package.json | 2 +- zokrates_stdlib/Cargo.toml | 2 +- zokrates_test/Cargo.toml | 2 +- 9 files changed, 16 insertions(+), 14 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 20ecd421..784a83ae 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1,5 +1,7 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. +version = 3 + [[package]] name = "addr2line" version = "0.14.0" @@ -2175,7 +2177,7 @@ dependencies = [ [[package]] name = "zokrates_cli" -version = "0.6.3" +version = "0.6.4" dependencies = [ "assert_cli", "bincode", @@ -2200,7 +2202,7 @@ version = "0.1.0" [[package]] name = "zokrates_core" -version = "0.5.3" +version = "0.5.4" dependencies = [ "ark-bls12-377", "ark-bn254", @@ -2241,7 +2243,7 @@ dependencies = [ [[package]] name = "zokrates_core_test" -version = "0.1.4" +version = "0.1.5" dependencies = [ "zokrates_test", "zokrates_test_derive", @@ -2257,7 +2259,7 @@ dependencies = [ [[package]] name = "zokrates_field" -version = "0.3.7" +version = "0.3.8" dependencies = [ "ark-bls12-377", "ark-bn254", @@ -2308,7 +2310,7 @@ dependencies = [ [[package]] name = "zokrates_stdlib" -version = "0.1.7" +version = "0.1.8" dependencies = [ "fs_extra", "zokrates_test", @@ -2317,7 +2319,7 @@ dependencies = [ [[package]] name = "zokrates_test" -version = "0.1.4" +version = "0.1.5" dependencies = [ "serde", "serde_derive", diff --git a/zokrates_cli/Cargo.toml b/zokrates_cli/Cargo.toml index 1a1750cc..eba1f77d 100644 --- a/zokrates_cli/Cargo.toml +++ b/zokrates_cli/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "zokrates_cli" -version = "0.6.3" +version = "0.6.4" authors = ["Jacob Eberhardt ", "Dennis Kuhnert ", "Thibaut Schaeffer "] repository = "https://github.com/JacobEberhardt/ZoKrates.git" edition = "2018" diff --git a/zokrates_core/Cargo.toml b/zokrates_core/Cargo.toml index c6286004..51dd5aed 100644 --- a/zokrates_core/Cargo.toml +++ b/zokrates_core/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "zokrates_core" -version = "0.5.3" +version = "0.5.4" edition = "2018" authors = ["Jacob Eberhardt ", "Dennis Kuhnert "] repository = "https://github.com/JacobEberhardt/ZoKrates" diff --git a/zokrates_core_test/Cargo.toml b/zokrates_core_test/Cargo.toml index 51f22d40..c8db7078 100644 --- a/zokrates_core_test/Cargo.toml +++ b/zokrates_core_test/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "zokrates_core_test" -version = "0.1.4" +version = "0.1.5" authors = ["schaeff "] edition = "2018" diff --git a/zokrates_field/Cargo.toml b/zokrates_field/Cargo.toml index 76d72521..87b956ae 100644 --- a/zokrates_field/Cargo.toml +++ b/zokrates_field/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "zokrates_field" -version = "0.3.7" +version = "0.3.8" authors = ["Thibaut Schaeffer ", "Guillaume Ballet "] edition = "2018" diff --git a/zokrates_js/Cargo.toml b/zokrates_js/Cargo.toml index 8aa884fb..8add49d4 100644 --- a/zokrates_js/Cargo.toml +++ b/zokrates_js/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "zokrates_js" -version = "1.0.27" +version = "1.0.28" authors = ["Darko Macesic"] edition = "2018" diff --git a/zokrates_js/package.json b/zokrates_js/package.json index 6765f16f..294ccf46 100644 --- a/zokrates_js/package.json +++ b/zokrates_js/package.json @@ -2,7 +2,7 @@ "name": "zokrates-js", "main": "index.js", "author": "Darko Macesic ", - "version": "1.0.28", + "version": "1.0.29", "keywords": [ "zokrates", "wasm-bindgen", diff --git a/zokrates_stdlib/Cargo.toml b/zokrates_stdlib/Cargo.toml index 09e9a6b6..3aa0ac99 100644 --- a/zokrates_stdlib/Cargo.toml +++ b/zokrates_stdlib/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "zokrates_stdlib" -version = "0.1.7" +version = "0.1.8" authors = ["Stefan Deml ", "schaeff "] edition = "2018" diff --git a/zokrates_test/Cargo.toml b/zokrates_test/Cargo.toml index c9189193..ef9ea39a 100644 --- a/zokrates_test/Cargo.toml +++ b/zokrates_test/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "zokrates_test" -version = "0.1.4" +version = "0.1.5" authors = ["schaeff "] edition = "2018" From 7ee999ae9b4f127854c7d5c34976ade0c31bb80a Mon Sep 17 00:00:00 2001 From: schaeff Date: Fri, 19 Mar 2021 19:05:06 +0100 Subject: [PATCH 17/22] dummy --- zokrates_stdlib/Cargo.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/zokrates_stdlib/Cargo.toml b/zokrates_stdlib/Cargo.toml index 3aa0ac99..88857f46 100644 --- a/zokrates_stdlib/Cargo.toml +++ b/zokrates_stdlib/Cargo.toml @@ -11,3 +11,4 @@ zokrates_test = { version = "0.1", path = "../zokrates_test" } fs_extra = "1.1.0" zokrates_test_derive = { version = "0.0", path = "../zokrates_test_derive" } + From 75beface35dff501923f0c97fec6c70bcd87194c Mon Sep 17 00:00:00 2001 From: schaeff Date: Fri, 19 Mar 2021 19:05:20 +0100 Subject: [PATCH 18/22] dummy --- zokrates_stdlib/Cargo.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/zokrates_stdlib/Cargo.toml b/zokrates_stdlib/Cargo.toml index 88857f46..3aa0ac99 100644 --- a/zokrates_stdlib/Cargo.toml +++ b/zokrates_stdlib/Cargo.toml @@ -11,4 +11,3 @@ zokrates_test = { version = "0.1", path = "../zokrates_test" } fs_extra = "1.1.0" zokrates_test_derive = { version = "0.0", path = "../zokrates_test_derive" } - From 31a096fec88d4146deda56d5d24d1478012912ca Mon Sep 17 00:00:00 2001 From: schaeff Date: Fri, 19 Mar 2021 19:17:59 +0100 Subject: [PATCH 19/22] align versions --- zokrates_js/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zokrates_js/package.json b/zokrates_js/package.json index 294ccf46..6765f16f 100644 --- a/zokrates_js/package.json +++ b/zokrates_js/package.json @@ -2,7 +2,7 @@ "name": "zokrates-js", "main": "index.js", "author": "Darko Macesic ", - "version": "1.0.29", + "version": "1.0.28", "keywords": [ "zokrates", "wasm-bindgen", From eabc97f83e05b29076cbf82fa11932a27646760e Mon Sep 17 00:00:00 2001 From: schaeff Date: Fri, 19 Mar 2021 21:12:48 +0100 Subject: [PATCH 20/22] dummy --- zokrates_js/package.json | 1 + 1 file changed, 1 insertion(+) diff --git a/zokrates_js/package.json b/zokrates_js/package.json index 6765f16f..2ac42dac 100644 --- a/zokrates_js/package.json +++ b/zokrates_js/package.json @@ -49,3 +49,4 @@ }, "dependencies": {} } + From c705a466c096d69e8ddea979c87aeb1d4308e57f Mon Sep 17 00:00:00 2001 From: schaeff Date: Fri, 19 Mar 2021 21:13:01 +0100 Subject: [PATCH 21/22] dummy --- zokrates_js/package.json | 1 - 1 file changed, 1 deletion(-) diff --git a/zokrates_js/package.json b/zokrates_js/package.json index 2ac42dac..6765f16f 100644 --- a/zokrates_js/package.json +++ b/zokrates_js/package.json @@ -49,4 +49,3 @@ }, "dependencies": {} } - From 659ced3bb1b39414b3efd185e69db0e3d8a34eec Mon Sep 17 00:00:00 2001 From: schaeff Date: Fri, 19 Mar 2021 21:44:54 +0100 Subject: [PATCH 22/22] force tag creation --- scripts/release.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/release.sh b/scripts/release.sh index 65db1318..18e7be15 100755 --- a/scripts/release.sh +++ b/scripts/release.sh @@ -29,7 +29,7 @@ echo "Published zokrates/zokrates:$TAG" # Release on Github git tag -f latest -git tag $TAG +git tag -f $TAG git push origin -f latest git push origin $TAG