From ed04267a9a0b9c50fd19ec85a0b894eed040c638 Mon Sep 17 00:00:00 2001 From: schaeff Date: Fri, 13 May 2022 12:34:05 +0200 Subject: [PATCH] complete refactor --- Cargo.lock | 122 ++- Cargo.toml | 4 +- zokrates_abi/Cargo.toml | 2 +- zokrates_abi/src/lib.rs | 6 +- zokrates_ark/Cargo.toml | 24 + zokrates_ark/src/gm17.rs | 200 ++-- zokrates_ark/src/groth16.rs | 136 +-- zokrates_ark/src/lib.rs | 103 +- zokrates_ark/src/marlin.rs | 39 +- zokrates_ast/Cargo.toml | 8 +- zokrates_ast/src/common/embed.rs | 119 ++- zokrates_ast/src/common/error.rs | 9 + zokrates_ast/src/flat/folder.rs | 35 +- .../src/ir/check.rs | 12 +- zokrates_ast/src/ir/from_flat.rs | 36 +- zokrates_ast/src/ir/mod.rs | 3 +- zokrates_ast/src/ir/serialize.rs | 23 +- zokrates_ast/src/typed/mod.rs | 6 - zokrates_ast/src/typed/parameter.rs | 1 - zokrates_ast/src/typed/variable.rs | 5 - zokrates_ast/src/untyped/node.rs | 1 - zokrates_ast/src/zir/mod.rs | 6 + zokrates_ast/src/zir/uint.rs | 5 + zokrates_bellman/Cargo.toml | 28 + .../src}/groth16.rs | 27 +- .../mod.rs => zokrates_bellman/src/lib.rs | 29 +- zokrates_cli/Cargo.toml | 14 +- zokrates_cli/src/bin.rs | 5 +- zokrates_cli/src/ops/compute_witness.rs | 11 +- zokrates_cli/src/ops/export_verifier.rs | 2 +- zokrates_cli/src/ops/generate_proof.rs | 19 +- zokrates_cli/src/ops/generate_smtlib2.rs | 4 +- zokrates_cli/src/ops/inspect.rs | 3 +- zokrates_cli/src/ops/mpc/beacon.rs | 4 +- zokrates_cli/src/ops/mpc/contribute.rs | 4 +- zokrates_cli/src/ops/mpc/export.rs | 4 +- zokrates_cli/src/ops/mpc/init.rs | 7 +- zokrates_cli/src/ops/mpc/verify.rs | 7 +- zokrates_cli/src/ops/print_proof.rs | 4 +- zokrates_cli/src/ops/setup.rs | 19 +- zokrates_cli/src/ops/universal_setup.rs | 8 +- zokrates_cli/src/ops/verify.rs | 16 +- zokrates_cli/tests/integration.rs | 6 +- zokrates_core/Cargo.toml | 48 +- zokrates_core/src/compile.rs | 29 +- zokrates_core/src/flatten/mod.rs | 87 +- zokrates_core/src/flatten/utils.rs | 2 +- zokrates_core/src/imports.rs | 4 +- zokrates_core/src/lib.rs | 16 +- zokrates_core/src/optimizer/duplicate.rs | 2 +- zokrates_core/src/optimizer/redefinition.rs | 4 +- zokrates_core/src/semantics.rs | 157 +-- .../src/static_analysis/branch_isolator.rs | 2 +- .../static_analysis/condition_redefiner.rs | 4 +- .../constant_argument_checker.rs | 8 +- .../src/static_analysis/constant_inliner.rs | 973 ------------------ .../src/static_analysis/constant_resolver.rs | 6 +- .../src/static_analysis/flat_propagation.rs | 15 +- .../static_analysis/flatten_complex_types.rs | 490 +++++---- zokrates_core/src/static_analysis/mod.rs | 6 +- .../src/static_analysis/out_of_bounds.rs | 6 +- .../src/static_analysis/propagation.rs | 6 +- .../reducer/constants_reader.rs | 2 +- .../reducer/constants_writer.rs | 14 +- .../src/static_analysis/reducer/inline.rs | 14 +- .../src/static_analysis/reducer/mod.rs | 18 +- .../static_analysis/reducer/shallow_ssa.rs | 14 +- .../src/static_analysis/struct_concretizer.rs | 6 +- zokrates_core/src/static_analysis/trimmer.rs | 4 +- .../src/static_analysis/uint_optimizer.rs | 4 +- .../static_analysis/variable_write_remover.rs | 4 +- .../src/static_analysis/zir_propagation.rs | 22 +- zokrates_interpreter/Cargo.toml | 10 + zokrates_interpreter/src/lib.rs | 6 +- zokrates_libsnark/Cargo.toml | 15 + {zokrates_core => zokrates_libsnark}/build.rs | 6 - .../lib/ffi.cpp | 0 .../lib/ffi.hpp | 0 .../lib/gm17.cpp | 0 .../lib/gm17.hpp | 0 .../lib/pghr13.cpp | 0 .../lib/pghr13.hpp | 0 .../lib/util.tcc | 0 .../libsnark => zokrates_libsnark/src}/ffi.rs | 0 .../src}/gm17.rs | 0 .../mod.rs => zokrates_libsnark/src/lib.rs | 0 .../src}/pghr13.rs | 0 zokrates_proof_systems/Cargo.toml | 15 + .../src/lib.rs | 47 +- .../src}/scheme/gm17.rs | 24 +- .../src}/scheme/groth16.rs | 8 +- .../src}/scheme/marlin.rs | 10 +- .../src}/scheme/mod.rs | 0 .../src}/scheme/pghr13.rs | 6 +- .../src}/solidity.rs | 2 +- .../src}/to_token.rs | 29 +- zokrates_test/Cargo.toml | 9 + zokrates_test/src/lib.rs | 20 +- .../tests/out_of_range.rs | 6 +- .../tests/wasm.rs | 18 +- 100 files changed, 1146 insertions(+), 2178 deletions(-) rename zokrates_core/src/static_analysis/unconstrained_vars.rs => zokrates_ast/src/ir/check.rs (84%) create mode 100644 zokrates_bellman/Cargo.toml rename {zokrates_core/src/proof_system/bellman => zokrates_bellman/src}/groth16.rs (91%) rename zokrates_core/src/proof_system/bellman/mod.rs => zokrates_bellman/src/lib.rs (95%) delete mode 100644 zokrates_core/src/static_analysis/constant_inliner.rs create mode 100644 zokrates_libsnark/Cargo.toml rename {zokrates_core => zokrates_libsnark}/build.rs (96%) rename {zokrates_core => zokrates_libsnark}/lib/ffi.cpp (100%) rename {zokrates_core => zokrates_libsnark}/lib/ffi.hpp (100%) rename {zokrates_core => zokrates_libsnark}/lib/gm17.cpp (100%) rename {zokrates_core => zokrates_libsnark}/lib/gm17.hpp (100%) rename {zokrates_core => zokrates_libsnark}/lib/pghr13.cpp (100%) rename {zokrates_core => zokrates_libsnark}/lib/pghr13.hpp (100%) rename {zokrates_core => zokrates_libsnark}/lib/util.tcc (100%) rename {zokrates_core/src/proof_system/libsnark => zokrates_libsnark/src}/ffi.rs (100%) rename {zokrates_core/src/proof_system/libsnark => zokrates_libsnark/src}/gm17.rs (100%) rename zokrates_core/src/proof_system/libsnark/mod.rs => zokrates_libsnark/src/lib.rs (100%) rename {zokrates_core/src/proof_system/libsnark => zokrates_libsnark/src}/pghr13.rs (100%) create mode 100644 zokrates_proof_systems/Cargo.toml rename zokrates_core/src/proof_system/mod.rs => zokrates_proof_systems/src/lib.rs (80%) rename {zokrates_core/src/proof_system => zokrates_proof_systems/src}/scheme/gm17.rs (89%) rename {zokrates_core/src/proof_system => zokrates_proof_systems/src}/scheme/groth16.rs (96%) rename {zokrates_core/src/proof_system => zokrates_proof_systems/src}/scheme/marlin.rs (98%) rename {zokrates_core/src/proof_system => zokrates_proof_systems/src}/scheme/mod.rs (100%) rename {zokrates_core/src/proof_system => zokrates_proof_systems/src}/scheme/pghr13.rs (97%) rename {zokrates_core/src/proof_system => zokrates_proof_systems/src}/solidity.rs (99%) rename {zokrates_core/src/proof_system => zokrates_proof_systems/src}/to_token.rs (90%) rename {zokrates_core => zokrates_test}/tests/out_of_range.rs (97%) rename {zokrates_core => zokrates_test}/tests/wasm.rs (58%) diff --git a/Cargo.lock b/Cargo.lock index 3865c1d8..49b4bf2c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1065,17 +1065,6 @@ dependencies = [ "instant", ] -[[package]] -name = "ff_ce" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83c0a6a2c53b0bd6d8cae976816dc8a171e0554c03f304e3dac110473e0219fd" -dependencies = [ - "byteorder", - "hex 0.4.3", - "rand 0.4.6", -] - [[package]] name = "ff_ce" version = "0.10.3" @@ -1671,7 +1660,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bfc00d65b1d29e0a067a967fcea83d8db261c149f76a557ba73f0304f01cdfde" dependencies = [ "byteorder", - "ff_ce 0.10.3", + "ff_ce", "rand 0.4.6", ] @@ -2827,7 +2816,7 @@ dependencies = [ "serde", "serde_derive", "serde_json", - "zokrates_core", + "zokrates_ast", "zokrates_field", ] @@ -2835,24 +2824,62 @@ dependencies = [ name = "zokrates_ark" version = "0.1.0" dependencies = [ + "ark-bls12-377", + "ark-bn254", + "ark-bw6-761", + "ark-crypto-primitives", + "ark-ec", + "ark-ff", + "ark-gm17", + "ark-groth16", + "ark-marlin", + "ark-poly", + "ark-poly-commit", + "ark-relations", + "ark-serialize", + "digest 0.9.0", + "hex 0.4.3", + "rand 0.8.5", + "sha3 0.9.1", "zokrates_ast", "zokrates_field", + "zokrates_interpreter", + "zokrates_proof_systems", ] [[package]] name = "zokrates_ast" version = "0.1.0" dependencies = [ + "ark-bls12-377", "cfg-if 0.1.10", "csv", "num-bigint 0.2.6", + "pairing_ce", "serde", "serde_cbor", "serde_json", + "zokrates_embed", "zokrates_field", "zokrates_pest_ast", ] +[[package]] +name = "zokrates_bellman" +version = "0.1.0" +dependencies = [ + "bellman_ce", + "getrandom", + "hex 0.4.3", + "pairing_ce", + "phase2", + "rand 0.4.6", + "zokrates_ast", + "zokrates_field", + "zokrates_interpreter", + "zokrates_proof_systems", +] + [[package]] name = "zokrates_cli" version = "0.7.13" @@ -2881,10 +2908,16 @@ dependencies = [ "tempdir", "typed-arena", "zokrates_abi", + "zokrates_ark", + "zokrates_ast", + "zokrates_bellman", "zokrates_common", "zokrates_core", "zokrates_field", "zokrates_fs_resolver", + "zokrates_interpreter", + "zokrates_libsnark", + "zokrates_proof_systems", "zokrates_solidity_test", ] @@ -2896,46 +2929,17 @@ version = "0.1.0" name = "zokrates_core" version = "0.6.12" dependencies = [ - "ark-bls12-377", - "ark-bn254", - "ark-bw6-761", - "ark-crypto-primitives", - "ark-ec", - "ark-ff", - "ark-gm17", - "ark-groth16", - "ark-marlin", - "ark-poly", - "ark-poly-commit", - "ark-relations", - "ark-serialize", - "bellman_ce", - "cc", "cfg-if 0.1.10", - "cmake", "csv", - "digest 0.9.0", - "ethabi", - "ff_ce 0.9.0", - "getrandom", - "hex 0.4.3", "lazy_static", "log", "num 0.1.42", "num-bigint 0.2.6", - "pairing_ce", - "phase2", "pretty_assertions", - "primitive-types", - "rand 0.4.6", - "rand 0.8.5", "reduce", - "regex 0.2.11", "serde", "serde_json", - "sha3 0.9.1", "typed-arena", - "wasm-bindgen-test", "zokrates_ast", "zokrates_common", "zokrates_embed", @@ -3007,12 +3011,25 @@ dependencies = [ name = "zokrates_interpreter" version = "0.1.0" dependencies = [ + "ark-bls12-377", "num 0.1.42", "num-bigint 0.2.6", + "pairing_ce", + "serde", "zokrates_ast", + "zokrates_embed", "zokrates_field", ] +[[package]] +name = "zokrates_libsnark" +version = "0.1.0" +dependencies = [ + "cc", + "cmake", + "zokrates_proof_systems", +] + [[package]] name = "zokrates_parser" version = "0.2.6" @@ -3034,6 +3051,21 @@ dependencies = [ "zokrates_parser", ] +[[package]] +name = "zokrates_proof_systems" +version = "0.1.0" +dependencies = [ + "cfg-if 0.1.10", + "ethabi", + "hex 0.4.3", + "primitive-types", + "rand 0.4.6", + "regex 0.2.11", + "serde", + "zokrates_ast", + "zokrates_field", +] + [[package]] name = "zokrates_solidity_test" version = "0.1.0" @@ -3065,10 +3097,16 @@ dependencies = [ "serde_derive", "serde_json", "typed-arena", + "wasm-bindgen-test", "zokrates_abi", + "zokrates_ark", + "zokrates_ast", + "zokrates_common", "zokrates_core", "zokrates_field", "zokrates_fs_resolver", + "zokrates_interpreter", + "zokrates_proof_systems", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index b93fb355..15ceed38 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,6 +15,8 @@ members = [ "zokrates_ast", "zokrates_interpreter", "zokrates_embed", + "zokrates_bellman", + "zokrates_proof_systems", ] -exclude = ["zokrates_js"] \ No newline at end of file +exclude = ["zokrates_js", "zokrates_libsnark"] \ No newline at end of file diff --git a/zokrates_abi/Cargo.toml b/zokrates_abi/Cargo.toml index bacda59f..1fccb51c 100644 --- a/zokrates_abi/Cargo.toml +++ b/zokrates_abi/Cargo.toml @@ -6,7 +6,7 @@ edition = "2018" [dependencies] zokrates_field = { version = "0.5", path = "../zokrates_field", default-features = false } -zokrates_core = { version = "0.6", path = "../zokrates_core", default-features = false } +zokrates_ast = { version = "0.1", path = "../zokrates_ast", default-features = false } serde = "1.0" serde_derive = "1.0" serde_json = { version = "1.0", features = ["preserve_order"] } diff --git a/zokrates_abi/src/lib.rs b/zokrates_abi/src/lib.rs index 80e3005e..59b7f40c 100644 --- a/zokrates_abi/src/lib.rs +++ b/zokrates_abi/src/lib.rs @@ -15,7 +15,7 @@ impl Encode for Inputs { } use std::fmt; -use zokrates_core::typed_absy::types::{ConcreteType, UBitwidth}; +use zokrates_ast::typed::types::{ConcreteType, UBitwidth}; use zokrates_field::Field; @@ -380,9 +380,7 @@ pub fn parse_strict_json( #[cfg(test)] mod tests { use super::*; - use zokrates_core::typed_absy::types::{ - ConcreteStructMember, ConcreteStructType, ConcreteType, - }; + use zokrates_ast::typed::types::{ConcreteStructMember, ConcreteStructType, ConcreteType}; use zokrates_field::Bn128Field; #[test] diff --git a/zokrates_ark/Cargo.toml b/zokrates_ark/Cargo.toml index 2658fc61..6c538640 100644 --- a/zokrates_ark/Cargo.toml +++ b/zokrates_ark/Cargo.toml @@ -8,3 +8,27 @@ edition = "2021" [dependencies] zokrates_field = { version = "0.5", path = "../zokrates_field", default-features = false } zokrates_ast = { version = "0.1", path = "../zokrates_ast", default-features = false } +zokrates_proof_systems = { version = "0.1", path = "../zokrates_proof_systems", default-features = false } + +ark-ff = { version = "^0.3.0", default-features = false } +ark-ec = { version = "^0.3.0", default-features = false } +ark-bn254 = { version = "^0.3.0", features = ["curve"], default-features = false } +ark-bls12-377 = { version = "^0.3.0", features = ["curve"], default-features = false } +ark-bw6-761 = { version = "^0.3.0", default-features = false } +ark-gm17 = { version = "^0.3.0", default-features = false } +ark-groth16 = { version = "^0.3.0", default-features = false } +ark-serialize = { version = "^0.3.0", default-features = false } +ark-relations = { version = "^0.3.0", default-features = false } +ark-marlin = { git = "https://github.com/arkworks-rs/marlin", rev = "63cfd82", default-features = false } +ark-poly = { version = "^0.3.0", default-features = false } +ark-poly-commit = { version = "^0.3.0", default-features = false } +ark-crypto-primitives = { version = "^0.3.0", default-features = false } +sha3 = { version = "0.9" } +digest = { version = "0.9" } +rand_0_8 = { version = "0.8", package = "rand" } +hex = "0.4.2" + +[dev-dependencies] +zokrates_interpreter = { version = "0.1", path = "../zokrates_interpreter" } + + diff --git a/zokrates_ark/src/gm17.rs b/zokrates_ark/src/gm17.rs index 6ef10a92..114e3403 100644 --- a/zokrates_ark/src/gm17.rs +++ b/zokrates_ark/src/gm17.rs @@ -4,19 +4,18 @@ use ark_gm17::{ VerifyingKey, GM17 as ArkGM17, }; use ark_serialize::{CanonicalDeserialize, CanonicalSerialize}; -use zokrates_field::{ArkFieldExtensions, Bw6_761Field, Field}; +use zokrates_field::{ArkFieldExtensions, Field}; -use crate::proof_system::ark::Computation; -use crate::proof_system::ark::{parse_fr, parse_g1, parse_g2, parse_g2_fq}; -use crate::proof_system::ark::{serialization, Ark}; -use crate::proof_system::gm17::{ProofPoints, VerificationKey, GM17}; -use crate::proof_system::{Backend, NonUniversalBackend, Proof, SetupKeypair}; -use crate::proof_system::{NotBw6_761Field, Scheme}; -use ark_bw6_761::BW6_761; +use crate::Computation; +use crate::{parse_fr, parse_g1, parse_g2}; +use crate::{serialization, Ark}; use rand_0_8::{rngs::StdRng, SeedableRng}; use zokrates_ast::ir::{ProgIterator, Statement, Witness}; +use zokrates_proof_systems::gm17::{ProofPoints, VerificationKey, GM17}; +use zokrates_proof_systems::Scheme; +use zokrates_proof_systems::{Backend, NonUniversalBackend, Proof, SetupKeypair}; -impl NonUniversalBackend for Ark { +impl NonUniversalBackend for Ark { fn setup>>( program: ProgIterator, ) -> SetupKeypair<>::VerificationKey> { @@ -41,7 +40,7 @@ impl NonUniversalBackend Backend for Ark { +impl Backend for Ark { fn generate_proof>>( program: ProgIterator, witness: Witness, @@ -109,107 +108,108 @@ impl Backend for Ark { } } -impl NonUniversalBackend for Ark { - fn setup>>( - program: ProgIterator, - ) -> SetupKeypair<>::VerificationKey> { - let computation = Computation::without_witness(program); +// impl NonUniversalBackend for Ark { +// fn setup>>( +// program: ProgIterator, +// ) -> SetupKeypair<>::VerificationKey> { +// let computation = Computation::without_witness(program); - let rng = &mut StdRng::from_entropy(); - let (pk, vk) = ArkGM17::::circuit_specific_setup(computation, rng).unwrap(); +// let rng = &mut StdRng::from_entropy(); +// let (pk, vk) = ArkGM17::::circuit_specific_setup(computation, rng).unwrap(); - let mut pk_vec: Vec = Vec::new(); - pk.serialize_uncompressed(&mut pk_vec).unwrap(); +// let mut pk_vec: Vec = Vec::new(); +// pk.serialize_uncompressed(&mut pk_vec).unwrap(); - let vk = VerificationKey { - h: parse_g2_fq::(&vk.h_g2), - g_alpha: parse_g1::(&vk.g_alpha_g1), - h_beta: parse_g2_fq::(&vk.h_beta_g2), - g_gamma: parse_g1::(&vk.g_gamma_g1), - h_gamma: parse_g2_fq::(&vk.h_gamma_g2), - query: vk.query.iter().map(parse_g1::).collect(), - }; +// let vk = VerificationKey { +// h: parse_g2_fq::(&vk.h_g2), +// g_alpha: parse_g1::(&vk.g_alpha_g1), +// h_beta: parse_g2_fq::(&vk.h_beta_g2), +// g_gamma: parse_g1::(&vk.g_gamma_g1), +// h_gamma: parse_g2_fq::(&vk.h_gamma_g2), +// query: vk.query.iter().map(parse_g1::).collect(), +// }; - SetupKeypair::new(vk, pk_vec) - } -} +// SetupKeypair::new(vk, pk_vec) +// } +// } -impl Backend for Ark { - fn generate_proof>>( - program: ProgIterator, - witness: Witness, - proving_key: Vec, - ) -> Proof { - let computation = Computation::with_witness(program, witness); +// impl Backend for Ark { +// fn generate_proof>>( +// program: ProgIterator, +// witness: Witness, +// proving_key: Vec, +// ) -> Proof { +// let computation = Computation::with_witness(program, witness); - let inputs = computation - .public_inputs_values() - .iter() - .map(parse_fr::) - .collect::>(); +// let inputs = computation +// .public_inputs_values() +// .iter() +// .map(parse_fr::) +// .collect::>(); - let pk = - ProvingKey::<::ArkEngine>::deserialize_uncompressed( - &mut proving_key.as_slice(), - ) - .unwrap(); +// let pk = +// ProvingKey::<::ArkEngine>::deserialize_uncompressed( +// &mut proving_key.as_slice(), +// ) +// .unwrap(); - let rng = &mut StdRng::from_entropy(); - let proof = ArkGM17::::prove(&pk, computation, rng).unwrap(); +// let rng = &mut StdRng::from_entropy(); +// let proof = ArkGM17::::prove(&pk, computation, rng).unwrap(); - let proof_points = ProofPoints { - a: parse_g1::(&proof.a), - b: parse_g2_fq::(&proof.b), - c: parse_g1::(&proof.c), - }; +// let proof_points = ProofPoints { +// a: parse_g1::(&proof.a), +// b: parse_g2_fq::(&proof.b), +// c: parse_g1::(&proof.c), +// }; - Proof::new(proof_points, inputs) - } +// Proof::new(proof_points, inputs) +// } - fn verify( - vk: >::VerificationKey, - proof: Proof, - ) -> bool { - let vk = VerifyingKey { - h_g2: serialization::to_g2_fq::(vk.h), - g_alpha_g1: serialization::to_g1::(vk.g_alpha), - h_beta_g2: serialization::to_g2_fq::(vk.h_beta), - g_gamma_g1: serialization::to_g1::(vk.g_gamma), - h_gamma_g2: serialization::to_g2_fq::(vk.h_gamma), - query: vk - .query - .into_iter() - .map(serialization::to_g1::) - .collect(), - }; +// fn verify( +// vk: >::VerificationKey, +// proof: Proof, +// ) -> bool { +// let vk = VerifyingKey { +// h_g2: serialization::to_g2_fq::(vk.h), +// g_alpha_g1: serialization::to_g1::(vk.g_alpha), +// h_beta_g2: serialization::to_g2_fq::(vk.h_beta), +// g_gamma_g1: serialization::to_g1::(vk.g_gamma), +// h_gamma_g2: serialization::to_g2_fq::(vk.h_gamma), +// query: vk +// .query +// .into_iter() +// .map(serialization::to_g1::) +// .collect(), +// }; - let ark_proof = ArkProof { - a: serialization::to_g1::(proof.proof.a), - b: serialization::to_g2_fq::(proof.proof.b), - c: serialization::to_g1::(proof.proof.c), - }; +// let ark_proof = ArkProof { +// a: serialization::to_g1::(proof.proof.a), +// b: serialization::to_g2_fq::(proof.proof.b), +// c: serialization::to_g1::(proof.proof.c), +// }; - let pvk: PreparedVerifyingKey<::ArkEngine> = - prepare_verifying_key(&vk); +// let pvk: PreparedVerifyingKey<::ArkEngine> = +// prepare_verifying_key(&vk); - let public_inputs: Vec<_> = proof - .inputs - .iter() - .map(|s| { - Bw6_761Field::try_from_str(s.trim_start_matches("0x"), 16) - .unwrap() - .into_ark() - }) - .collect::>(); +// let public_inputs: Vec<_> = proof +// .inputs +// .iter() +// .map(|s| { +// Bw6_761Field::try_from_str(s.trim_start_matches("0x"), 16) +// .unwrap() +// .into_ark() +// }) +// .collect::>(); - verify_proof(&pvk, &ark_proof, &public_inputs).unwrap() - } -} +// verify_proof(&pvk, &ark_proof, &public_inputs).unwrap() +// } +// } #[cfg(test)] mod tests { - use crate::flat_absy::{FlatParameter, FlatVariable}; - use zokrates_ast::ir::{Interpreter, Prog, Statement}; + use zokrates_ast::flat::{Parameter, Variable}; + use zokrates_ast::ir::{Prog, Statement}; + use zokrates_interpreter::Interpreter; use super::*; use zokrates_field::{Bls12_377Field, Bw6_761Field}; @@ -217,12 +217,9 @@ mod tests { #[test] fn verify_bls12_377_field() { let program: Prog = Prog { - arguments: vec![FlatParameter::public(FlatVariable::new(0))], + arguments: vec![Parameter::public(Variable::new(0))], return_count: 1, - statements: vec![Statement::constraint( - FlatVariable::new(0), - FlatVariable::public(0), - )], + statements: vec![Statement::constraint(Variable::new(0), Variable::public(0))], }; let keypair = >::setup(program.clone()); @@ -242,12 +239,9 @@ mod tests { #[test] fn verify_bw6_761_field() { let program: Prog = Prog { - arguments: vec![FlatParameter::public(FlatVariable::new(0))], + arguments: vec![Parameter::public(Variable::new(0))], return_count: 1, - statements: vec![Statement::constraint( - FlatVariable::new(0), - FlatVariable::public(0), - )], + statements: vec![Statement::constraint(Variable::new(0), Variable::public(0))], }; let keypair = >::setup(program.clone()); diff --git a/zokrates_ark/src/groth16.rs b/zokrates_ark/src/groth16.rs index 13fc867f..58fb124c 100644 --- a/zokrates_ark/src/groth16.rs +++ b/zokrates_ark/src/groth16.rs @@ -1,25 +1,24 @@ -use crate::proof_system::{Backend, NonUniversalBackend, NotBw6_761Field, Proof, SetupKeypair}; use ark_crypto_primitives::SNARK; use ark_groth16::{ prepare_verifying_key, verify_proof, Groth16, PreparedVerifyingKey, Proof as ArkProof, ProvingKey, VerifyingKey, }; use ark_serialize::{CanonicalDeserialize, CanonicalSerialize}; +use zokrates_field::ArkFieldExtensions; use zokrates_field::Field; -use zokrates_field::{ArkFieldExtensions, Bw6_761Field}; +use zokrates_proof_systems::{Backend, NonUniversalBackend, Proof, SetupKeypair}; -use crate::proof_system::ark::Computation; -use crate::proof_system::ark::{parse_fr, serialization, Ark}; -use crate::proof_system::ark::{parse_g1, parse_g2}; -use crate::proof_system::groth16::{ProofPoints, VerificationKey, G16}; -use crate::proof_system::Scheme; -use ark_bw6_761::BW6_761; +use crate::Computation; +use crate::{parse_fr, serialization, Ark}; +use crate::{parse_g1, parse_g2}; use rand_0_8::{rngs::StdRng, SeedableRng}; use zokrates_ast::ir::{ProgIterator, Statement, Witness}; +use zokrates_proof_systems::groth16::{ProofPoints, VerificationKey, G16}; +use zokrates_proof_systems::Scheme; const G16_WARNING: &str = "WARNING: You are using the G16 scheme which is subject to malleability. See zokrates.github.io/toolbox/proving_schemes.html#g16-malleability for implications."; -impl Backend for Ark { +impl Backend for Ark { fn generate_proof>>( program: ProgIterator, witness: Witness, @@ -86,7 +85,7 @@ impl Backend for Ark { } } -impl NonUniversalBackend for Ark { +impl NonUniversalBackend for Ark { fn setup>>( program: ProgIterator, ) -> SetupKeypair<>::VerificationKey> { @@ -112,108 +111,11 @@ impl NonUniversalBackend for Ark { - fn generate_proof>>( - program: ProgIterator, - witness: Witness, - proving_key: Vec, - ) -> Proof { - println!("{}", G16_WARNING); - - let computation = Computation::with_witness(program, witness); - - let inputs = computation - .public_inputs_values() - .iter() - .map(parse_fr::) - .collect::>(); - - let pk = - ProvingKey::::deserialize_uncompressed(&mut proving_key.as_slice()).unwrap(); - - let rng = &mut StdRng::from_entropy(); - let proof = Groth16::::prove(&pk, computation, rng).unwrap(); - - let proof_points = ProofPoints { - a: parse_g1::(&proof.a), - b: parse_g2::(&proof.b), - c: parse_g1::(&proof.c), - }; - - Proof::new(proof_points, inputs) - } - - fn verify( - vk: >::VerificationKey, - proof: Proof, - ) -> bool { - let vk = VerifyingKey { - alpha_g1: serialization::to_g1::(vk.alpha), - beta_g2: serialization::to_g2::(vk.beta), - gamma_g2: serialization::to_g2::(vk.gamma), - delta_g2: serialization::to_g2::(vk.delta), - gamma_abc_g1: vk - .gamma_abc - .into_iter() - .map(serialization::to_g1::) - .collect(), - }; - - let pvk: PreparedVerifyingKey = prepare_verifying_key(&vk); - let ark_proof = ArkProof { - a: serialization::to_g1::(proof.proof.a), - b: serialization::to_g2::(proof.proof.b), - c: serialization::to_g1::(proof.proof.c), - }; - - let public_inputs: Vec<_> = proof - .inputs - .iter() - .map(|s| { - Bw6_761Field::try_from_str(s.trim_start_matches("0x"), 16) - .unwrap() - .into_ark() - }) - .collect::>(); - - verify_proof(&pvk, &ark_proof, &public_inputs).unwrap() - } -} - -impl NonUniversalBackend for Ark { - fn setup>>( - program: ProgIterator, - ) -> SetupKeypair<>::VerificationKey> { - println!("{}", G16_WARNING); - - let computation = Computation::without_witness(program); - - let rng = &mut StdRng::from_entropy(); - let (pk, vk) = Groth16::::circuit_specific_setup(computation, rng).unwrap(); - - let mut pk_vec: Vec = Vec::new(); - pk.serialize_uncompressed(&mut pk_vec).unwrap(); - - let vk = VerificationKey { - alpha: parse_g1::(&vk.alpha_g1), - beta: parse_g2::(&vk.beta_g2), - gamma: parse_g2::(&vk.gamma_g2), - delta: parse_g2::(&vk.delta_g2), - gamma_abc: vk - .gamma_abc_g1 - .iter() - .map(parse_g1::) - .collect(), - }; - - SetupKeypair::new(vk, pk_vec) - } -} - #[cfg(test)] mod tests { - use crate::flat_absy::{FlatParameter, FlatVariable}; - use zokrates_ast::ir::{Interpreter, Prog, Statement}; + use zokrates_ast::flat::{Parameter, Variable}; + use zokrates_ast::ir::{Prog, Statement}; + use zokrates_interpreter::Interpreter; use super::*; use zokrates_field::{Bls12_377Field, Bw6_761Field}; @@ -221,12 +123,9 @@ mod tests { #[test] fn verify_bls12_377_field() { let program: Prog = Prog { - arguments: vec![FlatParameter::public(FlatVariable::new(0))], + arguments: vec![Parameter::public(Variable::new(0))], return_count: 1, - statements: vec![Statement::constraint( - FlatVariable::new(0), - FlatVariable::public(0), - )], + statements: vec![Statement::constraint(Variable::new(0), Variable::public(0))], }; let keypair = >::setup(program.clone()); @@ -249,12 +148,9 @@ mod tests { #[test] fn verify_bw6_761_field() { let program: Prog = Prog { - arguments: vec![FlatParameter::public(FlatVariable::new(0))], + arguments: vec![Parameter::public(Variable::new(0))], return_count: 1, - statements: vec![Statement::constraint( - FlatVariable::new(0), - FlatVariable::public(0), - )], + statements: vec![Statement::constraint(Variable::new(0), Variable::public(0))], }; let keypair = >::setup(program.clone()); diff --git a/zokrates_ark/src/lib.rs b/zokrates_ark/src/lib.rs index 40f090c6..b64ef9f0 100644 --- a/zokrates_ark/src/lib.rs +++ b/zokrates_ark/src/lib.rs @@ -2,16 +2,22 @@ pub mod gm17; pub mod groth16; pub mod marlin; -use crate::flat_absy::FlatVariable; use ark_ec::PairingEngine; use ark_relations::r1cs::{ ConstraintSynthesizer, ConstraintSystem, ConstraintSystemRef, LinearCombination, - SynthesisError, Variable, + SynthesisError, Variable as ArkVariable, }; use std::collections::BTreeMap; +use zokrates_ast::common::Variable; use zokrates_ast::ir::{CanonicalLinComb, ProgIterator, Statement, Witness}; use zokrates_field::{ArkFieldExtensions, Field}; +use zokrates_field::{Bls12_377Field, Bls12_381Field, Bn128Field}; +pub trait NotBw6_761Field {} +impl NotBw6_761Field for Bls12_377Field {} +impl NotBw6_761Field for Bls12_381Field {} +impl NotBw6_761Field for Bn128Field {} + pub use self::parse::*; pub struct Ark; @@ -41,7 +47,7 @@ impl>> Computation { fn ark_combination( l: CanonicalLinComb, cs: &mut ConstraintSystem<<::ArkEngine as PairingEngine>::Fr>, - symbols: &mut BTreeMap, + symbols: &mut BTreeMap, witness: &mut Witness, ) -> LinearCombination<<::ArkEngine as PairingEngine>::Fr> { l.0.into_iter() @@ -72,23 +78,35 @@ fn ark_combination( .fold(LinearCombination::zero(), |acc, e| acc + e) } -impl>> ProgIterator { - pub fn generate_constraints( +impl>> Computation { + pub fn public_inputs_values(&self) -> Vec<::Fr> { + self.program + .public_inputs(self.witness.as_ref().unwrap()) + .iter() + .map(|v| v.clone().into_ark()) + .collect() + } +} + +impl>> + ConstraintSynthesizer<<::ArkEngine as PairingEngine>::Fr> + for Computation +{ + fn generate_constraints( self, cs: ConstraintSystemRef<<::ArkEngine as PairingEngine>::Fr>, - witness: Option>, ) -> Result<(), SynthesisError> { // mapping from IR variables let mut symbols = BTreeMap::new(); - let mut witness = witness.unwrap_or_else(Witness::empty); + let mut witness = self.witness.unwrap_or_else(Witness::empty); - assert!(symbols.insert(FlatVariable::one(), ConstraintSystem::<<::ArkEngine as PairingEngine>::Fr>::one()).is_none()); + assert!(symbols.insert(Variable::one(), ConstraintSystem::<<::ArkEngine as PairingEngine>::Fr>::one()).is_none()); match cs { ConstraintSystemRef::CS(rc) => { let mut cs = rc.borrow_mut(); - symbols.extend(self.arguments.iter().enumerate().map(|(_, p)| { + symbols.extend(self.program.arguments.iter().enumerate().map(|(_, p)| { let wire = match p.private { true => cs.new_witness_variable(|| { Ok(witness @@ -109,7 +127,7 @@ impl>> ProgIt (p.id, wire) })); - for statement in self.statements { + for statement in self.program.statements { if let Statement::Constraint(quad, lin, _) = statement { let a = ark_combination( quad.left.clone().into_canonical(), @@ -141,32 +159,10 @@ impl>> ProgIt } } -impl>> Computation { - pub fn public_inputs_values(&self) -> Vec<::Fr> { - self.program - .public_inputs(self.witness.as_ref().unwrap()) - .iter() - .map(|v| v.clone().into_ark()) - .collect() - } -} - -impl>> - ConstraintSynthesizer<<::ArkEngine as PairingEngine>::Fr> - for Computation -{ - fn generate_constraints( - self, - cs: ConstraintSystemRef<<::ArkEngine as PairingEngine>::Fr>, - ) -> Result<(), SynthesisError> { - self.program.generate_constraints(cs, self.witness) - } -} - mod parse { use super::*; - use crate::proof_system::{Fr, G1Affine, G2Affine, G2AffineFq}; use ark_ff::ToBytes; + use zokrates_proof_systems::{Fr, G1Affine, G2Affine, G2AffineFq, G2AffineFq2}; pub fn parse_g1( e: &::G1Affine, @@ -207,7 +203,7 @@ mod parse { elements.push(e); } - G2Affine( + G2Affine::Fq2(G2AffineFq2( ( format!("0x{}", hex::encode(&elements[0])), format!("0x{}", hex::encode(&elements[1])), @@ -216,12 +212,12 @@ mod parse { format!("0x{}", hex::encode(&elements[2])), format!("0x{}", hex::encode(&elements[3])), ), - ) + )) } pub fn parse_g2_fq( e: &::G2Affine, - ) -> G2AffineFq { + ) -> G2Affine { let mut bytes: Vec = Vec::new(); e.write(&mut bytes).unwrap(); @@ -234,10 +230,10 @@ mod parse { x.reverse(); y.reverse(); - G2AffineFq( + G2Affine::Fq(G2AffineFq( format!("0x{}", hex::encode(&x)), format!("0x{}", hex::encode(&y)), - ) + )) } pub fn parse_fr(e: &::Fr) -> Fr { @@ -250,10 +246,10 @@ mod parse { } pub mod serialization { - use crate::proof_system::{G1Affine, G2Affine, G2AffineFq}; use ark_ec::PairingEngine; use ark_ff::FromBytes; use zokrates_field::ArkFieldExtensions; + use zokrates_proof_systems::{G1Affine, G2Affine}; #[inline] fn decode_hex(value: String) -> Vec { @@ -273,22 +269,21 @@ pub mod serialization { pub fn to_g2(g2: G2Affine) -> ::G2Affine { let mut bytes = vec![]; - bytes.append(&mut decode_hex((g2.0).0)); - bytes.append(&mut decode_hex((g2.0).1)); - bytes.append(&mut decode_hex((g2.1).0)); - bytes.append(&mut decode_hex((g2.1).1)); - bytes.push(0u8); // infinity flag - ::G2Affine::read(&*bytes).unwrap() - } - - pub fn to_g2_fq( - g2: G2AffineFq, - ) -> ::G2Affine { - let mut bytes = vec![]; - bytes.append(&mut decode_hex(g2.0)); - bytes.append(&mut decode_hex(g2.1)); - bytes.push(0u8); // infinity flag + match g2 { + G2Affine::Fq(g2) => { + bytes.append(&mut decode_hex(g2.0)); + bytes.append(&mut decode_hex(g2.1)); + bytes.push(0u8); // infinity flag + } + G2Affine::Fq2(g2) => { + bytes.append(&mut decode_hex((g2.0).0)); + bytes.append(&mut decode_hex((g2.0).1)); + bytes.append(&mut decode_hex((g2.1).0)); + bytes.append(&mut decode_hex((g2.1).1)); + bytes.push(0u8); // infinity flag + } + }; ::G2Affine::read(&*bytes).unwrap() } diff --git a/zokrates_ark/src/marlin.rs b/zokrates_ark/src/marlin.rs index 576acd84..2ed6a4de 100644 --- a/zokrates_ark/src/marlin.rs +++ b/zokrates_ark/src/marlin.rs @@ -23,13 +23,13 @@ use std::marker::PhantomData; use zokrates_field::{ArkFieldExtensions, Field}; -use crate::proof_system::ark::Ark; -use crate::proof_system::ark::Computation; -use crate::proof_system::ark::{parse_fr, parse_g1, parse_g2, serialization}; -use crate::proof_system::marlin::{self, KZGVerifierKey, ProofPoints, VerificationKey}; -use crate::proof_system::Scheme; -use crate::proof_system::{Backend, Proof, SetupKeypair, UniversalBackend}; +use crate::Ark; +use crate::Computation; +use crate::{parse_fr, parse_g1, parse_g2, serialization}; use zokrates_ast::ir::{ProgIterator, Statement, Witness}; +use zokrates_proof_systems::marlin::{self, KZGVerifierKey, ProofPoints, VerificationKey}; +use zokrates_proof_systems::Scheme; +use zokrates_proof_systems::{Backend, Proof, SetupKeypair, UniversalBackend}; const MINIMUM_CONSTRAINT_COUNT: usize = 2; @@ -386,27 +386,28 @@ impl Backend for Ark { #[cfg(test)] mod tests { - use crate::flat_absy::{FlatParameter, FlatVariable}; - use zokrates_ast::ir::{Interpreter, Prog, QuadComb, Statement}; + use zokrates_ast::flat::{Parameter, Variable}; + use zokrates_ast::ir::{Prog, QuadComb, Statement}; + use zokrates_interpreter::Interpreter; use super::*; - use crate::proof_system::scheme::Marlin; use zokrates_field::{Bls12_377Field, Bw6_761Field}; + use zokrates_proof_systems::Marlin; #[test] fn verify_bls12_377_field() { let program: Prog = Prog { - arguments: vec![FlatParameter::private(FlatVariable::new(0))], + arguments: vec![Parameter::private(Variable::new(0))], return_count: 1, statements: vec![ Statement::constraint( QuadComb::from_linear_combinations( - FlatVariable::new(0).into(), - FlatVariable::new(0).into(), + Variable::new(0).into(), + Variable::new(0).into(), ), - FlatVariable::new(1), + Variable::new(1), ), - Statement::constraint(FlatVariable::new(1), FlatVariable::public(0)), + Statement::constraint(Variable::new(1), Variable::public(0)), ], }; @@ -429,17 +430,17 @@ mod tests { #[test] fn verify_bw6_761_field() { let program: Prog = Prog { - arguments: vec![FlatParameter::private(FlatVariable::new(0))], + arguments: vec![Parameter::private(Variable::new(0))], return_count: 1, statements: vec![ Statement::constraint( QuadComb::from_linear_combinations( - FlatVariable::new(0).into(), - FlatVariable::new(0).into(), + Variable::new(0).into(), + Variable::new(0).into(), ), - FlatVariable::new(1), + Variable::new(1), ), - Statement::constraint(FlatVariable::new(1), FlatVariable::public(0)), + Statement::constraint(Variable::new(1), Variable::public(0)), ], }; diff --git a/zokrates_ast/Cargo.toml b/zokrates_ast/Cargo.toml index 63288786..8f27808f 100644 --- a/zokrates_ast/Cargo.toml +++ b/zokrates_ast/Cargo.toml @@ -3,7 +3,10 @@ name = "zokrates_ast" version = "0.1.0" edition = "2021" -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html +[features] +default = ["bellman", "ark"] +bellman = ["zokrates_field/bellman", "pairing_ce"] +ark = ["ark-bls12-377"] [dependencies] zokrates_pest_ast = { version = "0.2.0", path = "../zokrates_pest_ast" } @@ -14,6 +17,9 @@ csv = "1" serde_cbor = "0.11.2" num-bigint = { version = "0.2", default-features = false } serde_json = { version = "1.0", features = ["preserve_order"] } +zokrates_embed = { version = "0.1.0", path = "../zokrates_embed" } +pairing_ce = { version = "^0.21", optional = true } +ark-bls12-377 = { version = "^0.3.0", features = ["curve"], default-features = false, optional = true } diff --git a/zokrates_ast/src/common/embed.rs b/zokrates_ast/src/common/embed.rs index 47551172..71342c00 100644 --- a/zokrates_ast/src/common/embed.rs +++ b/zokrates_ast/src/common/embed.rs @@ -344,7 +344,6 @@ fn flat_expression_from_vec(v: &[(usize, T)]) -> FlatExpression { #[cfg(feature = "bellman")] pub fn sha256_round( ) -> FlatFunctionIterator>> { - use zokrates_ast::ir::RuntimeError; use zokrates_field::Bn128Field; assert_eq!(T::id(), Bn128Field::id()); @@ -449,7 +448,6 @@ pub fn sha256_round( pub fn snark_verify_bls12_377( n: usize, ) -> FlatFunctionIterator>> { - use zokrates_ast::ir::RuntimeError; use zokrates_field::Bw6_761Field; assert_eq!(T::id(), Bw6_761Field::id()); @@ -695,72 +693,73 @@ mod tests { } } - #[cfg(feature = "bellman")] - #[cfg(test)] - mod sha256 { - use super::*; - use zokrates_ast::ir::Interpreter; + // MOVE TO CORE + // #[cfg(feature = "bellman")] + // #[cfg(test)] + // mod sha256 { + // use super::*; + // use crate::ir::Interpreter; - #[test] - fn generate_sha256_constraints() { - let compiled = sha256_round::(); + // #[test] + // fn generate_sha256_constraints() { + // let compiled = sha256_round::(); - let compiled = compiled.collect(); + // let compiled = compiled.collect(); - // function should have 768 inputs - assert_eq!(compiled.arguments.len(), 768); + // // function should have 768 inputs + // assert_eq!(compiled.arguments.len(), 768); - // function should return 256 values - assert_eq!(compiled.return_count, 256,); + // // function should return 256 values + // assert_eq!(compiled.return_count, 256,); - // directive should take 768 inputs and return n_var outputs - let directive = compiled - .statements - .iter() - .filter_map(|s| match s { - FlatStatement::Directive(d) => Some(d.clone()), - _ => None, - }) - .next() - .unwrap(); - assert_eq!(directive.inputs.len(), 768); - assert_eq!(directive.outputs.len(), 26935); - // function input should be offset by variable_count - assert_eq!( - compiled.arguments[0].id, - Variable::new(directive.outputs.len() + 1) - ); + // // directive should take 768 inputs and return n_var outputs + // let directive = compiled + // .statements + // .iter() + // .filter_map(|s| match s { + // FlatStatement::Directive(d) => Some(d.clone()), + // _ => None, + // }) + // .next() + // .unwrap(); + // assert_eq!(directive.inputs.len(), 768); + // assert_eq!(directive.outputs.len(), 26935); + // // function input should be offset by variable_count + // assert_eq!( + // compiled.arguments[0].id, + // Variable::new(directive.outputs.len() + 1) + // ); - // bellman variable #0: index 0 should equal 1 - assert_eq!( - compiled.statements[1], - FlatStatement::Condition( - Variable::new(0).into(), - FlatExpression::Number(Bn128Field::from(1)), - RuntimeError::BellmanOneBinding - ) - ); + // // bellman variable #0: index 0 should equal 1 + // assert_eq!( + // compiled.statements[1], + // FlatStatement::Condition( + // Variable::new(0).into(), + // FlatExpression::Number(Bn128Field::from(1)), + // RuntimeError::BellmanOneBinding + // ) + // ); - // bellman input #0: index 1 should equal zokrates input #0: index v_count - assert_eq!( - compiled.statements[2], - FlatStatement::Condition( - Variable::new(1).into(), - Variable::new(26936).into(), - RuntimeError::BellmanInputBinding - ) - ); + // // bellman input #0: index 1 should equal zokrates input #0: index v_count + // assert_eq!( + // compiled.statements[2], + // FlatStatement::Condition( + // Variable::new(1).into(), + // Variable::new(26936).into(), + // RuntimeError::BellmanInputBinding + // ) + // ); - let input: Vec<_> = (0..512) - .map(|_| 0) - .chain((0..256).map(|_| 1)) - .map(Bn128Field::from) - .collect(); + // let input: Vec<_> = (0..512) + // .map(|_| 0) + // .chain((0..256).map(|_| 1)) + // .map(Bn128Field::from) + // .collect(); - let ir = zokrates_ast::ir::from_flat::from_flat(compiled); + // let ir = zokrates_ast::ir::from_flat::from_flat(compiled); - let interpreter = Interpreter::default(); - interpreter.execute(ir, &input).unwrap(); - } - } + // let interpreter = Interpreter::default(); + // interpreter.execute(ir, &input).unwrap(); + // } + // } } diff --git a/zokrates_ast/src/common/error.rs b/zokrates_ast/src/common/error.rs index c1fe0656..f1d8b2d1 100644 --- a/zokrates_ast/src/common/error.rs +++ b/zokrates_ast/src/common/error.rs @@ -32,6 +32,15 @@ pub enum RuntimeError { SelectRangeCheck, } +impl From for RuntimeError { + fn from(error: crate::zir::RuntimeError) -> Self { + match error { + crate::zir::RuntimeError::SourceAssertion(s) => RuntimeError::SourceAssertion(s), + crate::zir::RuntimeError::SelectRangeCheck => RuntimeError::SelectRangeCheck, + } + } +} + impl RuntimeError { pub fn is_malicious(&self) -> bool { use RuntimeError::*; diff --git a/zokrates_ast/src/flat/folder.rs b/zokrates_ast/src/flat/folder.rs index a000c8b4..254f2d5f 100644 --- a/zokrates_ast/src/flat/folder.rs +++ b/zokrates_ast/src/flat/folder.rs @@ -50,22 +50,37 @@ pub fn fold_statement>( f: &mut F, s: FlatStatement, ) -> Vec> { - // match s { - // Statement::Constraint(quad, lin, message) => vec![Statement::Constraint( - // f.fold_quadratic_combination(quad), - // f.fold_linear_combination(lin), - // message, - // )], - // Statement::Directive(dir) => vec![Statement::Directive(f.fold_directive(dir))], - // } - unimplemented!() + match s { + FlatStatement::Condition(left, right, error) => vec![FlatStatement::Condition( + f.fold_expression(left), + f.fold_expression(right), + error, + )], + FlatStatement::Definition(v, e) => vec![FlatStatement::Definition( + f.fold_variable(v), + f.fold_expression(e), + )], + FlatStatement::Directive(d) => vec![FlatStatement::Directive(f.fold_directive(d))], + } } pub fn fold_expression>( f: &mut F, e: FlatExpression, ) -> FlatExpression { - unimplemented!() + match e { + FlatExpression::Number(n) => FlatExpression::Number(n), + FlatExpression::Identifier(id) => FlatExpression::Identifier(f.fold_variable(id)), + FlatExpression::Add(box left, box right) => { + FlatExpression::Add(box f.fold_expression(left), box f.fold_expression(right)) + } + FlatExpression::Sub(box left, box right) => { + FlatExpression::Sub(box f.fold_expression(left), box f.fold_expression(right)) + } + FlatExpression::Mult(box left, box right) => { + FlatExpression::Mult(box f.fold_expression(left), box f.fold_expression(right)) + } + } } pub fn fold_directive>(f: &mut F, ds: FlatDirective) -> FlatDirective { diff --git a/zokrates_core/src/static_analysis/unconstrained_vars.rs b/zokrates_ast/src/ir/check.rs similarity index 84% rename from zokrates_core/src/static_analysis/unconstrained_vars.rs rename to zokrates_ast/src/ir/check.rs index ad52b4d8..11c5fd84 100644 --- a/zokrates_core/src/static_analysis/unconstrained_vars.rs +++ b/zokrates_ast/src/ir/check.rs @@ -1,10 +1,10 @@ +use crate::ir::folder::Folder; +use crate::ir::Directive; +use crate::ir::Parameter; +use crate::ir::ProgIterator; +use crate::ir::Statement; +use crate::ir::Variable; use std::collections::HashSet; -use zokrates_ast::ir::folder::Folder; -use zokrates_ast::ir::Directive; -use zokrates_ast::ir::Parameter; -use zokrates_ast::ir::ProgIterator; -use zokrates_ast::ir::Statement; -use zokrates_ast::ir::Variable; use zokrates_field::Field; #[derive(Debug)] diff --git a/zokrates_ast/src/ir/from_flat.rs b/zokrates_ast/src/ir/from_flat.rs index c6a4e4e5..abe2b075 100644 --- a/zokrates_ast/src/ir/from_flat.rs +++ b/zokrates_ast/src/ir/from_flat.rs @@ -1,7 +1,5 @@ -use crate::flat_absy::{ - FlatDirective, FlatExpression, FlatProgIterator, FlatStatement, FlatVariable, -}; -use zokrates_ast::ir::{Directive, LinComb, ProgIterator, QuadComb, Statement}; +use crate::flat::{FlatDirective, FlatExpression, FlatProgIterator, FlatStatement, Variable}; +use crate::ir::{Directive, LinComb, ProgIterator, QuadComb, Statement}; use zokrates_field::Field; impl QuadComb { @@ -33,7 +31,7 @@ impl From> for LinComb { fn from(flat_expression: FlatExpression) -> LinComb { match flat_expression { FlatExpression::Number(ref n) if *n == T::from(0) => LinComb::zero(), - FlatExpression::Number(n) => LinComb::summand(n, FlatVariable::one()), + FlatExpression::Number(n) => LinComb::summand(n, Variable::one()), FlatExpression::Identifier(id) => LinComb::from(id), FlatExpression::Add(box e1, box e2) => LinComb::from(e1) + LinComb::from(e2), FlatExpression::Sub(box e1, box e2) => LinComb::from(e1) - LinComb::from(e2), @@ -48,7 +46,7 @@ impl From> for LinComb { FlatExpression::Mult( box FlatExpression::Number(n1), box FlatExpression::Number(n2), - ) => LinComb::summand(n1 * n2, FlatVariable::one()), + ) => LinComb::summand(n1 * n2, Variable::one()), e => unreachable!("{}", e), } } @@ -109,7 +107,7 @@ mod tests { fn one() { // 1 let one = FlatExpression::Number(Bn128Field::from(1)); - let expected: LinComb = FlatVariable::one().into(); + let expected: LinComb = Variable::one().into(); assert_eq!(LinComb::from(one), expected); } @@ -117,7 +115,7 @@ mod tests { fn forty_two() { // 42 let one = FlatExpression::Number(Bn128Field::from(42)); - let expected: LinComb = LinComb::summand(42, FlatVariable::one()); + let expected: LinComb = LinComb::summand(42, Variable::one()); assert_eq!(LinComb::from(one), expected); } @@ -125,11 +123,11 @@ mod tests { fn add() { // x + y let add = FlatExpression::Add( - box FlatExpression::Identifier(FlatVariable::new(42)), - box FlatExpression::Identifier(FlatVariable::new(21)), + box FlatExpression::Identifier(Variable::new(42)), + box FlatExpression::Identifier(Variable::new(21)), ); let expected: LinComb = - LinComb::summand(1, FlatVariable::new(42)) + LinComb::summand(1, FlatVariable::new(21)); + LinComb::summand(1, Variable::new(42)) + LinComb::summand(1, Variable::new(21)); assert_eq!(LinComb::from(add), expected); } @@ -139,15 +137,15 @@ mod tests { let add = FlatExpression::Add( box FlatExpression::Mult( box FlatExpression::Number(Bn128Field::from(42)), - box FlatExpression::Identifier(FlatVariable::new(42)), + box FlatExpression::Identifier(Variable::new(42)), ), box FlatExpression::Mult( box FlatExpression::Number(Bn128Field::from(21)), - box FlatExpression::Identifier(FlatVariable::new(21)), + box FlatExpression::Identifier(Variable::new(21)), ), ); - let expected: LinComb = LinComb::summand(42, FlatVariable::new(42)) - + LinComb::summand(21, FlatVariable::new(21)); + let expected: LinComb = + LinComb::summand(42, Variable::new(42)) + LinComb::summand(21, Variable::new(21)); assert_eq!(LinComb::from(add), expected); } @@ -156,16 +154,16 @@ mod tests { // x*42 + y*21 let add = FlatExpression::Add( box FlatExpression::Mult( - box FlatExpression::Identifier(FlatVariable::new(42)), + box FlatExpression::Identifier(Variable::new(42)), box FlatExpression::Number(Bn128Field::from(42)), ), box FlatExpression::Mult( - box FlatExpression::Identifier(FlatVariable::new(21)), + box FlatExpression::Identifier(Variable::new(21)), box FlatExpression::Number(Bn128Field::from(21)), ), ); - let expected: LinComb = LinComb::summand(42, FlatVariable::new(42)) - + LinComb::summand(21, FlatVariable::new(21)); + let expected: LinComb = + LinComb::summand(42, Variable::new(42)) + LinComb::summand(21, Variable::new(21)); assert_eq!(LinComb::from(add), expected); } } diff --git a/zokrates_ast/src/ir/mod.rs b/zokrates_ast/src/ir/mod.rs index 430b1525..e8dff12b 100644 --- a/zokrates_ast/src/ir/mod.rs +++ b/zokrates_ast/src/ir/mod.rs @@ -4,9 +4,10 @@ use std::fmt; use std::hash::Hash; use zokrates_field::Field; +mod check; mod expression; pub mod folder; -//pub mod from_flat; +pub mod from_flat; mod serialize; pub mod smtlib2; pub mod visitor; diff --git a/zokrates_ast/src/ir/serialize.rs b/zokrates_ast/src/ir/serialize.rs index ea03f00d..0737c31e 100644 --- a/zokrates_ast/src/ir/serialize.rs +++ b/zokrates_ast/src/ir/serialize.rs @@ -1,3 +1,5 @@ +use crate::ir::check::UnconstrainedVariableDetector; + use super::{ProgIterator, Statement}; use serde_cbor::{self, StreamDeserializer}; use std::io::{Read, Write}; @@ -57,7 +59,7 @@ impl>> ProgIterator { /// serialize a program iterator, returning the number of constraints serialized /// Note that we only return constraints, not other statements such as directives pub fn serialize(self, mut w: W) -> Result { - //use super::folder::Folder; + use super::folder::Folder; w.write_all(ZOKRATES_MAGIC)?; w.write_all(ZOKRATES_VERSION_2)?; @@ -66,7 +68,7 @@ impl>> ProgIterator { serde_cbor::to_writer(&mut w, &self.arguments)?; serde_cbor::to_writer(&mut w, &self.return_count)?; - //let mut unconstrained_variable_detector = UnconstrainedVariableDetector::new(&self); + let mut unconstrained_variable_detector = UnconstrainedVariableDetector::new(&self); let statements = self.statements.into_iter(); @@ -75,17 +77,16 @@ impl>> ProgIterator { if matches!(s, Statement::Constraint(..)) { count += 1; } - //let s = unconstrained_variable_detector.fold_statement(s); - //for s in s { - serde_cbor::to_writer(&mut w, &s)?; - //} + let s = unconstrained_variable_detector.fold_statement(s); + for s in s { + serde_cbor::to_writer(&mut w, &s)?; + } } - // unconstrained_variable_detector - // .finalize() - // .map(|_| count) - // .map_err(|count| format!("Error: Found {} unconstrained variable(s)", count).into()) - Ok(count) + unconstrained_variable_detector + .finalize() + .map(|_| count) + .map_err(|count| format!("Error: Found {} unconstrained variable(s)", count).into()) } } diff --git a/zokrates_ast/src/typed/mod.rs b/zokrates_ast/src/typed/mod.rs index 8ee9d622..bf6d8365 100644 --- a/zokrates_ast/src/typed/mod.rs +++ b/zokrates_ast/src/typed/mod.rs @@ -85,12 +85,6 @@ pub struct TypedProgram<'ast, T> { pub main: OwnedTypedModuleId, } -impl<'ast, T> TypedProgram<'ast, T> { - pub fn main_function(&self) -> TypedFunction<'ast, T> { - unimplemented!() - } -} - impl<'ast, T: Field> TypedProgram<'ast, T> { pub fn abi(&self) -> Abi { let main = &self.modules[&self.main] diff --git a/zokrates_ast/src/typed/parameter.rs b/zokrates_ast/src/typed/parameter.rs index 4fad5c82..45b0dcae 100644 --- a/zokrates_ast/src/typed/parameter.rs +++ b/zokrates_ast/src/typed/parameter.rs @@ -8,7 +8,6 @@ pub struct GParameter<'ast, S> { pub private: bool, } -#[cfg(test)] impl<'ast, S> From> for GParameter<'ast, S> { fn from(v: GVariable<'ast, S>) -> Self { GParameter { diff --git a/zokrates_ast/src/typed/variable.rs b/zokrates_ast/src/typed/variable.rs index e4eadffe..53b3b555 100644 --- a/zokrates_ast/src/typed/variable.rs +++ b/zokrates_ast/src/typed/variable.rs @@ -54,11 +54,6 @@ impl<'ast, S: Clone> GVariable<'ast, S> { Self::with_id_and_type(id, GType::uint(bitwidth)) } - #[cfg(test)] - pub fn field_array>>(id: I, size: S) -> Self { - Self::array(id, GType::FieldElement, size) - } - pub fn array>, U: Into>(id: I, ty: GType, size: U) -> Self { Self::with_id_and_type(id, GType::array((ty, size.into()))) } diff --git a/zokrates_ast/src/untyped/node.rs b/zokrates_ast/src/untyped/node.rs index 75c9d598..2bc09eae 100644 --- a/zokrates_ast/src/untyped/node.rs +++ b/zokrates_ast/src/untyped/node.rs @@ -52,7 +52,6 @@ pub trait NodeValue: fmt::Display + fmt::Debug + Sized + PartialEq { Node::new(start, end, self) } - #[cfg(test)] fn mock(self) -> Node { Node::new(Position::mock(), Position::mock(), self) } diff --git a/zokrates_ast/src/zir/mod.rs b/zokrates_ast/src/zir/mod.rs index f93ea719..ff73b966 100644 --- a/zokrates_ast/src/zir/mod.rs +++ b/zokrates_ast/src/zir/mod.rs @@ -100,6 +100,12 @@ impl fmt::Display for RuntimeError { } } +impl RuntimeError { + pub fn mock() -> Self { + RuntimeError::SourceAssertion(String::default()) + } +} + /// A statement in a `ZirFunction` #[derive(Clone, PartialEq, Hash, Eq, Debug)] pub enum ZirStatement<'ast, T> { diff --git a/zokrates_ast/src/zir/uint.rs b/zokrates_ast/src/zir/uint.rs index 3e3b51a2..ee9a2302 100644 --- a/zokrates_ast/src/zir/uint.rs +++ b/zokrates_ast/src/zir/uint.rs @@ -4,12 +4,14 @@ use crate::zir::BooleanExpression; use zokrates_field::Field; impl<'ast, T: Field> UExpression<'ast, T> { + #[allow(clippy::should_implement_trait)] pub fn add(self, other: Self) -> UExpression<'ast, T> { let bitwidth = self.bitwidth; assert_eq!(bitwidth, other.bitwidth); UExpressionInner::Add(box self, box other).annotate(bitwidth) } + #[allow(clippy::should_implement_trait)] pub fn sub(self, other: Self) -> UExpression<'ast, T> { let bitwidth = self.bitwidth; assert_eq!(bitwidth, other.bitwidth); @@ -27,12 +29,14 @@ impl<'ast, T: Field> UExpression<'ast, T> { UExpressionInner::Mult(box self, box other).annotate(bitwidth) } + #[allow(clippy::should_implement_trait)] pub fn div(self, other: Self) -> UExpression<'ast, T> { let bitwidth = self.bitwidth; assert_eq!(bitwidth, other.bitwidth); UExpressionInner::Div(box self, box other).annotate(bitwidth) } + #[allow(clippy::should_implement_trait)] pub fn rem(self, other: Self) -> UExpression<'ast, T> { let bitwidth = self.bitwidth; assert_eq!(bitwidth, other.bitwidth); @@ -45,6 +49,7 @@ impl<'ast, T: Field> UExpression<'ast, T> { UExpressionInner::Xor(box self, box other).annotate(bitwidth) } + #[allow(clippy::should_implement_trait)] pub fn not(self) -> UExpression<'ast, T> { let bitwidth = self.bitwidth; UExpressionInner::Not(box self).annotate(bitwidth) diff --git a/zokrates_bellman/Cargo.toml b/zokrates_bellman/Cargo.toml new file mode 100644 index 00000000..9b9e483d --- /dev/null +++ b/zokrates_bellman/Cargo.toml @@ -0,0 +1,28 @@ +[package] +name = "zokrates_bellman" +version = "0.1.0" +edition = "2021" + +[features] +wasm = ["bellman/nolog", "bellman/wasm"] +multicore = ["bellman/multicore", "phase2/multicore"] + +[dependencies] +zokrates_field = { version = "0.5", path = "../zokrates_field", default-features = false } +zokrates_ast = { version = "0.1", path = "../zokrates_ast", default-features = false } +zokrates_proof_systems = { version = "0.1", path = "../zokrates_proof_systems", default-features = false } + +bellman = { package = "bellman_ce", version = "^0.3", default-features = false } +pairing = { package = "pairing_ce", version = "^0.21" } +phase2 = { git = "https://github.com/Zokrates/phase2", default-features = false } +rand_0_4 = { version = "0.4", package = "rand" }# +getrandom = { version = "0.2", features = ["js", "wasm-bindgen"] } +hex = "0.4.2" + +[dev-dependencies] +zokrates_interpreter = { version = "0.1", path = "../zokrates_interpreter" } + + + + + diff --git a/zokrates_core/src/proof_system/bellman/groth16.rs b/zokrates_bellman/src/groth16.rs similarity index 91% rename from zokrates_core/src/proof_system/bellman/groth16.rs rename to zokrates_bellman/src/groth16.rs index c29a8dec..17650780 100644 --- a/zokrates_core/src/proof_system/bellman/groth16.rs +++ b/zokrates_bellman/src/groth16.rs @@ -4,19 +4,19 @@ use bellman::groth16::{ }; use pairing::{ff::to_hex, CurveAffine, Engine}; -use crate::proof_system::{Backend, MpcBackend, NonUniversalBackend, Proof, SetupKeypair}; use zokrates_field::BellmanFieldExtensions; use zokrates_field::Field; +use zokrates_proof_systems::{Backend, MpcBackend, NonUniversalBackend, Proof, SetupKeypair}; -use crate::proof_system::bellman::Bellman; -use crate::proof_system::bellman::Computation; -use crate::proof_system::bellman::{parse_g1, parse_g2}; -use crate::proof_system::groth16::{ProofPoints, VerificationKey, G16}; -use crate::proof_system::Scheme; +use crate::Bellman; +use crate::Computation; +use crate::{parse_g1, parse_g2}; use phase2::MPCParameters; use rand_0_4::Rng; use std::io::{Read, Write}; use zokrates_ast::ir::{ProgIterator, Statement, Witness}; +use zokrates_proof_systems::groth16::{ProofPoints, VerificationKey, G16}; +use zokrates_proof_systems::Scheme; const G16_WARNING: &str = "WARNING: You are using the G16 scheme which is subject to malleability. See zokrates.github.io/toolbox/proving_schemes.html#g16-malleability for implications."; @@ -157,8 +157,8 @@ impl MpcBackend for Bellman { pub mod serialization { use super::*; - use crate::proof_system::{G1Affine, G2Affine}; use pairing::from_hex; + use zokrates_proof_systems::{G1Affine, G2Affine}; pub fn parameters_to_verification_key( parameters: &Parameters, @@ -188,9 +188,14 @@ pub mod serialization { pub fn to_g2( g2: G2Affine, ) -> ::G2Affine { - let x = T::new_fq2(&(g2.0).0, &(g2.0).1); - let y = T::new_fq2(&(g2.1).0, &(g2.1).1); - ::G2Affine::from_xy_unchecked(x, y) + match g2 { + G2Affine::Fq2(g2) => { + let x = T::new_fq2(&(g2.0).0, &(g2.0).1); + let y = T::new_fq2(&(g2.1).0, &(g2.1).1); + ::G2Affine::from_xy_unchecked(x, y) + } + _ => unreachable!(), + } } } @@ -200,7 +205,7 @@ mod tests { use zokrates_interpreter::Interpreter; use super::*; - use crate::flat_absy::{Parameter, Variable}; + use zokrates_ast::common::{Parameter, Variable}; use zokrates_ast::ir::{Prog, Statement}; #[test] diff --git a/zokrates_core/src/proof_system/bellman/mod.rs b/zokrates_bellman/src/lib.rs similarity index 95% rename from zokrates_core/src/proof_system/bellman/mod.rs rename to zokrates_bellman/src/lib.rs index 67c81bb5..f6413f18 100644 --- a/zokrates_core/src/proof_system/bellman/mod.rs +++ b/zokrates_bellman/src/lib.rs @@ -83,8 +83,10 @@ fn bellman_combination>> Computation { - pub fn synthesize>( +impl>> + Circuit for Computation +{ + fn synthesize>( self, cs: &mut CS, ) -> Result<(), SynthesisError> { @@ -95,7 +97,7 @@ impl>> Co assert!(symbols.insert(Variable::one(), CS::one()).is_none()); - symbols.extend(self.arguments.iter().enumerate().map(|(index, p)| { + symbols.extend(self.program.arguments.iter().enumerate().map(|(index, p)| { let wire = match p.private { true => cs.alloc( || format!("PRIVATE_INPUT_{}", index), @@ -122,7 +124,7 @@ impl>> Co (p.id, wire) })); - for statement in self.statements { + for statement in self.program.statements { if let Statement::Constraint(quad, lin, _) = statement { let a = &bellman_combination( quad.left.into_canonical(), @@ -193,21 +195,10 @@ impl>> Co } } -impl>> - Circuit for Computation -{ - fn synthesize>( - self, - cs: &mut CS, - ) -> Result<(), SynthesisError> { - self.program.synthesize(cs, self.witness) - } -} - mod parse { use super::*; - use crate::proof_system::{G1Affine, G2Affine}; - use pairing_ce::CurveAffine; + use pairing::CurveAffine; + use zokrates_proof_systems::{G1Affine, G2Affine, G2AffineFq2}; fn to_hex(bytes: &[u8]) -> String { let mut hex = hex::encode(bytes); @@ -240,7 +231,7 @@ mod parse { let y1 = to_hex(iter.next().unwrap()); let y0 = to_hex(iter.next().unwrap()); - G2Affine((x0, x1), (y0, y1)) + G2Affine::Fq2(G2AffineFq2((x0, x1), (y0, y1))) } } @@ -253,7 +244,7 @@ mod tests { mod prove { use super::*; - use crate::flat_absy::Parameter; + use zokrates_ast::flat::Parameter; use zokrates_ast::ir::Prog; #[test] diff --git a/zokrates_cli/Cargo.toml b/zokrates_cli/Cargo.toml index 5109b5bc..1b0708aa 100644 --- a/zokrates_cli/Cargo.toml +++ b/zokrates_cli/Cargo.toml @@ -7,9 +7,9 @@ edition = "2018" [features] default = ["bellman", "ark"] -libsnark = ["zokrates_core/libsnark", "zokrates_common/libsnark"] -bellman = ["zokrates_core/bellman", "zokrates_common/bellman"] -ark = ["zokrates_core/ark", "zokrates_common/ark"] +libsnark = ["zokrates_libsnark"] +bellman = ["zokrates_bellman", "zokrates_core/bellman"] +ark = ["zokrates_ark", "zokrates_core/ark"] [dependencies] log = "0.4" @@ -21,6 +21,8 @@ regex = "0.2" zokrates_field = { version = "0.5", path = "../zokrates_field", default-features = false } zokrates_abi = { version = "0.1", path = "../zokrates_abi" } zokrates_core = { version = "0.6", path = "../zokrates_core", default-features = false } +zokrates_ast = { version = "0.1", path = "../zokrates_ast", default-features = false } +zokrates_interpreter = { version = "0.1", path = "../zokrates_interpreter", default-features = false } typed-arena = "1.4.1" zokrates_fs_resolver = { version = "0.5", path = "../zokrates_fs_resolver"} zokrates_common = { version = "0.1", path = "../zokrates_common" } @@ -35,6 +37,12 @@ hex = "0.3.1" blake2 = "0.8.1" sha2 = "0.10.0" +# Backends +zokrates_proof_systems = { version = "0.1", path = "../zokrates_proof_systems", default-features = false } +zokrates_libsnark = { version = "0.1", path = "../zokrates_libsnark", default-features = false, optional = true } +zokrates_ark = { version = "0.1", path = "../zokrates_ark", default-features = false, optional = true } +zokrates_bellman = { version = "0.1", path = "../zokrates_bellman", default-features = false, optional = true } + [dev-dependencies] glob = "0.2.11" assert_cli = "0.5" diff --git a/zokrates_cli/src/bin.rs b/zokrates_cli/src/bin.rs index cca7d11e..7035ef53 100644 --- a/zokrates_cli/src/bin.rs +++ b/zokrates_cli/src/bin.rs @@ -122,7 +122,6 @@ mod tests { use std::string::String; use typed_arena::Arena; use zokrates_core::compile::{compile, CompilationArtifacts, CompileConfig}; - use zokrates_core::ir; use zokrates_field::Bn128Field; use zokrates_fs_resolver::FileSystemResolver; @@ -217,7 +216,7 @@ mod tests { ) .unwrap(); - let interpreter = ir::Interpreter::default(); + let interpreter = zokrates_interpreter::Interpreter::default(); let _ = interpreter .execute(artifacts.prog(), &[Bn128Field::from(0)]) @@ -257,7 +256,7 @@ mod tests { ) .unwrap(); - let interpreter = ir::Interpreter::default(); + let interpreter = zokrates_interpreter::Interpreter::default(); let res = interpreter.execute(artifacts.prog(), &[Bn128Field::from(0)]); diff --git a/zokrates_cli/src/ops/compute_witness.rs b/zokrates_cli/src/ops/compute_witness.rs index 944451df..2b2a8ae7 100644 --- a/zokrates_cli/src/ops/compute_witness.rs +++ b/zokrates_cli/src/ops/compute_witness.rs @@ -5,10 +5,11 @@ use std::fs::File; use std::io::{stdin, BufReader, BufWriter, Read}; use std::path::Path; use zokrates_abi::Encode; -use zokrates_core::ir; -use zokrates_core::ir::ProgEnum; -use zokrates_core::typed_absy::abi::Abi; -use zokrates_core::typed_absy::types::{ConcreteSignature, ConcreteType}; +use zokrates_ast::ir::{self, ProgEnum}; +use zokrates_ast::typed::{ + abi::Abi, + types::{ConcreteSignature, ConcreteType}, +}; use zokrates_field::Field; pub fn subcommand() -> App<'static, 'static> { @@ -156,7 +157,7 @@ fn cli_compute>>( } .map_err(|e| format!("Could not parse argument: {}", e))?; - let interpreter = ir::Interpreter::default(); + let interpreter = zokrates_interpreter::Interpreter::default(); let witness = interpreter .execute(ir_prog, &arguments.encode()) diff --git a/zokrates_cli/src/ops/export_verifier.rs b/zokrates_cli/src/ops/export_verifier.rs index 1ab395f6..e5086cde 100644 --- a/zokrates_cli/src/ops/export_verifier.rs +++ b/zokrates_cli/src/ops/export_verifier.rs @@ -6,8 +6,8 @@ use std::io::{BufReader, BufWriter, Write}; use std::path::Path; use zokrates_common::constants; use zokrates_common::helpers::{CurveParameter, SchemeParameter}; -use zokrates_core::proof_system::*; use zokrates_field::Bn128Field; +use zokrates_proof_systems::*; pub fn subcommand() -> App<'static, 'static> { SubCommand::with_name("export-verifier") diff --git a/zokrates_cli/src/ops/generate_proof.rs b/zokrates_cli/src/ops/generate_proof.rs index 9c1b1d6f..7b7e237f 100644 --- a/zokrates_cli/src/ops/generate_proof.rs +++ b/zokrates_cli/src/ops/generate_proof.rs @@ -4,19 +4,18 @@ use std::convert::TryFrom; use std::fs::File; use std::io::{BufReader, Read, Write}; use std::path::Path; +#[cfg(feature = "ark")] +use zokrates_ark::Ark; +use zokrates_ast::ir::{self, ProgEnum}; +#[cfg(feature = "bellman")] +use zokrates_bellman::Bellman; use zokrates_common::constants; use zokrates_common::helpers::*; -use zokrates_core::ir; -use zokrates_core::ir::ProgEnum; -#[cfg(feature = "ark")] -use zokrates_core::proof_system::ark::Ark; -#[cfg(feature = "bellman")] -use zokrates_core::proof_system::bellman::Bellman; -#[cfg(feature = "libsnark")] -use zokrates_core::proof_system::libsnark::Libsnark; -#[cfg(any(feature = "bellman", feature = "ark", feature = "libsnark"))] -use zokrates_core::proof_system::*; use zokrates_field::Field; +#[cfg(feature = "libsnark")] +use zokrates_libsnark::Libsnark; +#[cfg(any(feature = "bellman", feature = "ark", feature = "libsnark"))] +use zokrates_proof_systems::*; pub fn subcommand() -> App<'static, 'static> { SubCommand::with_name("generate-proof") diff --git a/zokrates_cli/src/ops/generate_smtlib2.rs b/zokrates_cli/src/ops/generate_smtlib2.rs index 127dc6ad..b1bf6f6a 100644 --- a/zokrates_cli/src/ops/generate_smtlib2.rs +++ b/zokrates_cli/src/ops/generate_smtlib2.rs @@ -3,9 +3,7 @@ use clap::{App, Arg, ArgMatches, SubCommand}; use std::fs::File; use std::io::{BufReader, Write}; use std::path::Path; -use zokrates_core::ir; -use zokrates_core::ir::smtlib2::SMTLib2Display; -use zokrates_core::ir::ProgEnum; +use zokrates_ast::ir::{self, smtlib2::SMTLib2Display, ProgEnum}; use zokrates_field::Field; pub fn subcommand() -> App<'static, 'static> { diff --git a/zokrates_cli/src/ops/inspect.rs b/zokrates_cli/src/ops/inspect.rs index 571ba5c3..523d664a 100644 --- a/zokrates_cli/src/ops/inspect.rs +++ b/zokrates_cli/src/ops/inspect.rs @@ -3,8 +3,7 @@ use clap::{App, Arg, ArgMatches, SubCommand}; use std::fs::File; use std::io::{BufReader, BufWriter, Write}; use std::path::{Path, PathBuf}; -use zokrates_core::ir; -use zokrates_core::ir::ProgEnum; +use zokrates_ast::ir::{self, ProgEnum}; use zokrates_field::Field; pub fn subcommand() -> App<'static, 'static> { diff --git a/zokrates_cli/src/ops/mpc/beacon.rs b/zokrates_cli/src/ops/mpc/beacon.rs index 0e3e39c8..b5af669e 100644 --- a/zokrates_cli/src/ops/mpc/beacon.rs +++ b/zokrates_cli/src/ops/mpc/beacon.rs @@ -3,10 +3,10 @@ use clap::{App, Arg, ArgMatches, SubCommand}; use std::fs::File; use std::io::{BufReader, BufWriter}; use std::path::Path; +use zokrates_bellman::Bellman; use zokrates_common::constants::{BLS12_381, BN128}; -use zokrates_core::proof_system::bellman::Bellman; -use zokrates_core::proof_system::{MpcBackend, MpcScheme, G16}; use zokrates_field::{BellmanFieldExtensions, Bls12_381Field, Bn128Field, Field}; +use zokrates_proof_systems::{MpcBackend, MpcScheme, G16}; pub fn subcommand() -> App<'static, 'static> { SubCommand::with_name("beacon") diff --git a/zokrates_cli/src/ops/mpc/contribute.rs b/zokrates_cli/src/ops/mpc/contribute.rs index f5820949..3490f381 100644 --- a/zokrates_cli/src/ops/mpc/contribute.rs +++ b/zokrates_cli/src/ops/mpc/contribute.rs @@ -3,10 +3,10 @@ use clap::{App, Arg, ArgMatches, SubCommand}; use std::fs::File; use std::io::{BufReader, BufWriter}; use std::path::Path; +use zokrates_bellman::Bellman; use zokrates_common::constants::{BLS12_381, BN128}; -use zokrates_core::proof_system::bellman::Bellman; -use zokrates_core::proof_system::{MpcBackend, MpcScheme, G16}; use zokrates_field::{BellmanFieldExtensions, Bls12_381Field, Bn128Field, Field}; +use zokrates_proof_systems::{MpcBackend, MpcScheme, G16}; pub fn subcommand() -> App<'static, 'static> { SubCommand::with_name("contribute") diff --git a/zokrates_cli/src/ops/mpc/export.rs b/zokrates_cli/src/ops/mpc/export.rs index 1923a947..b9ea3fbc 100644 --- a/zokrates_cli/src/ops/mpc/export.rs +++ b/zokrates_cli/src/ops/mpc/export.rs @@ -3,10 +3,10 @@ use clap::{App, Arg, ArgMatches, SubCommand}; use std::fs::File; use std::io::{BufReader, Write}; use std::path::Path; +use zokrates_bellman::Bellman; use zokrates_common::constants::{BLS12_381, BN128}; -use zokrates_core::proof_system::bellman::Bellman; -use zokrates_core::proof_system::{MpcBackend, MpcScheme, G16}; use zokrates_field::{BellmanFieldExtensions, Bls12_381Field, Bn128Field, Field}; +use zokrates_proof_systems::{MpcBackend, MpcScheme, G16}; pub fn subcommand() -> App<'static, 'static> { SubCommand::with_name("export") diff --git a/zokrates_cli/src/ops/mpc/init.rs b/zokrates_cli/src/ops/mpc/init.rs index 465b68e0..71136366 100644 --- a/zokrates_cli/src/ops/mpc/init.rs +++ b/zokrates_cli/src/ops/mpc/init.rs @@ -3,11 +3,10 @@ use clap::{App, Arg, ArgMatches, SubCommand}; use std::fs::File; use std::io::{BufReader, BufWriter}; use std::path::Path; -use zokrates_core::ir; -use zokrates_core::ir::ProgEnum; -use zokrates_core::proof_system::bellman::Bellman; -use zokrates_core::proof_system::{MpcBackend, MpcScheme, G16}; +use zokrates_ast::ir::{self, ProgEnum}; +use zokrates_bellman::Bellman; use zokrates_field::{BellmanFieldExtensions, Field}; +use zokrates_proof_systems::{MpcBackend, MpcScheme, G16}; pub fn subcommand() -> App<'static, 'static> { SubCommand::with_name("init") diff --git a/zokrates_cli/src/ops/mpc/verify.rs b/zokrates_cli/src/ops/mpc/verify.rs index b734991f..6beca03d 100644 --- a/zokrates_cli/src/ops/mpc/verify.rs +++ b/zokrates_cli/src/ops/mpc/verify.rs @@ -3,11 +3,10 @@ use clap::{App, Arg, ArgMatches, SubCommand}; use std::fs::File; use std::io::BufReader; use std::path::Path; -use zokrates_core::ir; -use zokrates_core::ir::ProgEnum; -use zokrates_core::proof_system::bellman::Bellman; -use zokrates_core::proof_system::{MpcBackend, MpcScheme, G16}; +use zokrates_ast::ir::{self, ProgEnum}; +use zokrates_bellman::Bellman; use zokrates_field::{BellmanFieldExtensions, Field}; +use zokrates_proof_systems::{MpcBackend, MpcScheme, G16}; pub fn subcommand() -> App<'static, 'static> { SubCommand::with_name("verify") diff --git a/zokrates_cli/src/ops/print_proof.rs b/zokrates_cli/src/ops/print_proof.rs index 9c597e0d..c26ad769 100644 --- a/zokrates_cli/src/ops/print_proof.rs +++ b/zokrates_cli/src/ops/print_proof.rs @@ -5,10 +5,10 @@ use std::fs::File; use std::path::Path; use zokrates_common::constants as common_constants; use zokrates_common::helpers::{CurveParameter, SchemeParameter}; -use zokrates_core::proof_system::{ +use zokrates_field::Bn128Field; +use zokrates_proof_systems::{ Marlin, Proof, SolidityCompatibleField, SolidityCompatibleScheme, G16, GM17, PGHR13, }; -use zokrates_field::Bn128Field; pub fn subcommand() -> App<'static, 'static> { SubCommand::with_name("print-proof") diff --git a/zokrates_cli/src/ops/setup.rs b/zokrates_cli/src/ops/setup.rs index 8b1248ac..419454a5 100644 --- a/zokrates_cli/src/ops/setup.rs +++ b/zokrates_cli/src/ops/setup.rs @@ -4,19 +4,18 @@ use std::convert::TryFrom; use std::fs::File; use std::io::{BufReader, Write}; use std::path::Path; +#[cfg(feature = "ark")] +use zokrates_ark::Ark; +use zokrates_ast::ir::{self, ProgEnum}; +#[cfg(feature = "bellman")] +use zokrates_bellman::Bellman; use zokrates_common::constants; use zokrates_common::helpers::*; -use zokrates_core::ir; -use zokrates_core::ir::ProgEnum; -#[cfg(feature = "ark")] -use zokrates_core::proof_system::ark::Ark; -#[cfg(feature = "bellman")] -use zokrates_core::proof_system::bellman::Bellman; -#[cfg(feature = "libsnark")] -use zokrates_core::proof_system::libsnark::Libsnark; -#[cfg(any(feature = "bellman", feature = "ark", feature = "libsnark"))] -use zokrates_core::proof_system::*; use zokrates_field::Field; +#[cfg(feature = "libsnark")] +use zokrates_libsnark::Libsnark; +#[cfg(any(feature = "bellman", feature = "ark", feature = "libsnark"))] +use zokrates_proof_systems::*; pub fn subcommand() -> App<'static, 'static> { SubCommand::with_name("setup") diff --git a/zokrates_cli/src/ops/universal_setup.rs b/zokrates_cli/src/ops/universal_setup.rs index ac1a9b04..8d673b28 100644 --- a/zokrates_cli/src/ops/universal_setup.rs +++ b/zokrates_cli/src/ops/universal_setup.rs @@ -4,13 +4,13 @@ use std::convert::TryFrom; use std::fs::File; use std::io::Write; use std::path::Path; +#[cfg(feature = "ark")] +use zokrates_ark::Ark; use zokrates_common::constants; use zokrates_common::helpers::*; -#[cfg(feature = "ark")] -use zokrates_core::proof_system::ark::Ark; -#[cfg(any(feature = "bellman", feature = "ark", feature = "libsnark"))] -use zokrates_core::proof_system::*; use zokrates_field::{Bls12_377Field, Bls12_381Field, Bn128Field, Bw6_761Field, Field}; +#[cfg(any(feature = "bellman", feature = "ark", feature = "libsnark"))] +use zokrates_proof_systems::*; pub fn subcommand() -> App<'static, 'static> { SubCommand::with_name("universal-setup") diff --git a/zokrates_cli/src/ops/verify.rs b/zokrates_cli/src/ops/verify.rs index 4402df9c..ba7d4bee 100644 --- a/zokrates_cli/src/ops/verify.rs +++ b/zokrates_cli/src/ops/verify.rs @@ -4,17 +4,17 @@ use std::convert::TryFrom; use std::fs::File; use std::io::BufReader; use std::path::Path; +#[cfg(feature = "ark")] +use zokrates_ark::Ark; +#[cfg(feature = "bellman")] +use zokrates_bellman::Bellman; use zokrates_common::constants; use zokrates_common::helpers::*; -#[cfg(feature = "ark")] -use zokrates_core::proof_system::ark::Ark; -#[cfg(feature = "bellman")] -use zokrates_core::proof_system::bellman::Bellman; -#[cfg(feature = "libsnark")] -use zokrates_core::proof_system::libsnark::Libsnark; -#[cfg(any(feature = "bellman", feature = "ark", feature = "libsnark"))] -use zokrates_core::proof_system::*; use zokrates_field::{Bls12_377Field, Bls12_381Field, Bn128Field, Bw6_761Field, Field}; +#[cfg(feature = "libsnark")] +use zokrates_libsnark::Libsnark; +#[cfg(any(feature = "bellman", feature = "ark", feature = "libsnark"))] +use zokrates_proof_systems::*; pub fn subcommand() -> App<'static, 'static> { SubCommand::with_name("verify") diff --git a/zokrates_cli/tests/integration.rs b/zokrates_cli/tests/integration.rs index 47d65abb..d51e5f3e 100644 --- a/zokrates_cli/tests/integration.rs +++ b/zokrates_cli/tests/integration.rs @@ -19,12 +19,12 @@ mod integration { use std::path::Path; use tempdir::TempDir; use zokrates_abi::{parse_strict, Encode}; - use zokrates_core::proof_system::{ + use zokrates_ast::typed::abi::Abi; + use zokrates_field::Bn128Field; + use zokrates_proof_systems::{ to_token::ToToken, Marlin, Proof, SolidityCompatibleScheme, G16, GM17, PGHR13, SOLIDITY_G2_ADDITION_LIB, }; - use zokrates_core::typed_absy::abi::Abi; - use zokrates_field::Bn128Field; macro_rules! map( { diff --git a/zokrates_core/Cargo.toml b/zokrates_core/Cargo.toml index e469112a..0ae9abfb 100644 --- a/zokrates_core/Cargo.toml +++ b/zokrates_core/Cargo.toml @@ -5,15 +5,12 @@ edition = "2018" authors = ["Jacob Eberhardt ", "Dennis Kuhnert "] repository = "https://github.com/Zokrates/ZoKrates" readme = "README.md" -build = "build.rs" [features] -default = ["bellman", "ark"] -libsnark = ["cc", "cmake"] -bellman = ["bellman_ce", "pairing_ce", "ff_ce", "zokrates_field/bellman"] -wasm = ["bellman_ce/nolog", "bellman_ce/wasm"] -multicore = ["bellman_ce/multicore", "phase2/multicore"] -ark = ["ark-ff", "ark-ec", "ark-bls12-377", "ark-bw6-761", "ark-gm17", "ark-groth16", "ark-crypto-primitives", "ark-serialize", "ark-relations", "ark-marlin", "ark-poly", "ark-poly-commit", "sha3", "digest"] +default = ["ark", "bellman"] +ark = ["zokrates_ast/ark"] +bellman = ["zokrates_ast/bellman"] +libsnark = [] [dependencies] log = "0.4" @@ -26,49 +23,14 @@ reduce = "0.1.1" # serialization and deserialization serde = { version = "1.0", features = ["derive"] } serde_json = { version = "1.0", features = ["preserve_order"] } -hex = "0.4.2" -regex = "0.2" zokrates_field = { version = "0.5.0", path = "../zokrates_field", default-features = false } zokrates_pest_ast = { version = "0.2.0", path = "../zokrates_pest_ast" } -zokrates_common = { path = "../zokrates_common" } +zokrates_common = { version = "0.1", path = "../zokrates_common" } zokrates_embed = { version = "0.1.0", path = "../zokrates_embed" } zokrates_interpreter = { version = "0.1", path = "../zokrates_interpreter" } zokrates_ast = { version = "0.1", path = "../zokrates_ast" } -getrandom = { version = "0.2", features = ["js", "wasm-bindgen"] } -rand_0_4 = { version = "0.4", package = "rand" } -rand_0_8 = { version = "0.8", package = "rand" } csv = "1" -phase2 = { git = "https://github.com/Zokrates/phase2", default-features = false } - -# bellman -bellman_ce = { version = "^0.3", default-features = false, optional = true } -pairing_ce = { version = "^0.21", optional = true } -ff_ce = { version = "^0.9", optional = true } - -# ark -ark-ff = { version = "^0.3.0", default-features = false, optional = true } -ark-ec = { version = "^0.3.0", default-features = false, optional = true } -ark-bn254 = { version = "^0.3.0", features = ["curve"], default-features = false, optional = true } -ark-bls12-377 = { version = "^0.3.0", features = ["curve"], default-features = false, optional = true } -ark-bw6-761 = { version = "^0.3.0", default-features = false, optional = true } -ark-gm17 = { version = "^0.3.0", default-features = false, optional = true } -ark-groth16 = { version = "^0.3.0", default-features = false, optional = true } -ark-serialize = { version = "^0.3.0", default-features = false, optional = true } -ark-relations = { version = "^0.3.0", default-features = false, optional = true } -ark-marlin = { git = "https://github.com/arkworks-rs/marlin", rev = "63cfd82", default-features = false, optional = true } -ark-poly = { version = "^0.3.0", default-features = false, optional = true } -ark-poly-commit = { version = "^0.3.0", default-features = false, optional = true } -ark-crypto-primitives = { version = "^0.3.0", default-features = false, optional = true } -sha3 = { version = "0.9", optional = true } -digest = { version = "0.9", optional = true } -ethabi = "17.0.0" -primitive-types = { version = "0.11", features = ["rlp"] } [dev-dependencies] -wasm-bindgen-test = "^0.3.0" pretty_assertions = "0.6.1" zokrates_fs_resolver = { version = "0.5", path = "../zokrates_fs_resolver"} - -[build-dependencies] -cc = { version = "1.0", features = ["parallel"], optional = true } -cmake = { version = "=0.1.45", optional = true } diff --git a/zokrates_core/src/compile.rs b/zokrates_core/src/compile.rs index f7986766..5b1febd5 100644 --- a/zokrates_core/src/compile.rs +++ b/zokrates_core/src/compile.rs @@ -3,14 +3,12 @@ //! @file compile.rs //! @author Thibaut Schaeffer //! @date 2018 -use crate::absy::{Module, OwnedModuleId, Program}; -use crate::flatten::FlattenerIterator; +use crate::flatten::from_function_and_config; use crate::imports::{self, Importer}; use crate::macros; +use crate::optimizer::optimize; use crate::semantics::{self, Checker}; -use crate::static_analysis; -use crate::typed_absy::abi::Abi; -use crate::zir::ZirProgram; +use crate::static_analysis::{self, analyse}; use macros::process_macros; use serde::{Deserialize, Serialize}; use std::collections::HashMap; @@ -18,7 +16,10 @@ use std::fmt; use std::io; use std::path::{Path, PathBuf}; use typed_arena::Arena; -use zokrates_ast::ir; +use zokrates_ast::ir::{self, from_flat::from_flat}; +use zokrates_ast::typed::abi::Abi; +use zokrates_ast::untyped::{Module, OwnedModuleId, Program}; +use zokrates_ast::zir::ZirProgram; use zokrates_common::Resolver; use zokrates_field::Field; use zokrates_pest_ast as pest; @@ -195,21 +196,20 @@ pub fn compile<'ast, T: Field, E: Into>( arena: &'ast Arena, ) -> Result> + 'ast>, CompileErrors> { - let (typed_ast, abi): (crate::zir::ZirProgram<'_, T>, _) = + let (typed_ast, abi): (zokrates_ast::zir::ZirProgram<'_, T>, _) = check_with_arena(source, location, resolver, &config, arena)?; // flatten input program log::debug!("Flatten"); - let program_flattened = FlattenerIterator::from_function_and_config(typed_ast.main, config); + let program_flattened = from_function_and_config(typed_ast.main, config); // convert to ir log::debug!("Convert to IR"); - //let ir_prog = ir::from_flat::from_flat(program_flattened); - let ir_prog = unimplemented!(); + let ir_prog = from_flat(program_flattened); // optimize log::debug!("Optimise IR"); - let optimized_ir_prog = ir_prog.optimize(); + let optimized_ir_prog = optimize(ir_prog); Ok(CompilationArtifacts { prog: optimized_ir_prog, @@ -254,8 +254,7 @@ fn check_with_arena<'ast, T: Field, E: Into>( log::debug!("Run static analysis"); // analyse (unroll and constant propagation) - typed_ast - .analyse(config) + analyse(typed_ast, config) .map_err(|e| CompileErrors(vec![CompileErrorInner::from(e).in_file(&main_module)])) } @@ -361,8 +360,8 @@ mod test { mod abi { use super::*; - use crate::typed_absy::abi::*; - use crate::typed_absy::types::*; + use zokrates_ast::typed::abi::*; + use zokrates_ast::typed::types::*; #[test] fn use_struct_declaration_types() { diff --git a/zokrates_core/src/flatten/mod.rs b/zokrates_core/src/flatten/mod.rs index a724825b..48553a89 100644 --- a/zokrates_core/src/flatten/mod.rs +++ b/zokrates_core/src/flatten/mod.rs @@ -12,13 +12,6 @@ use zokrates_ast::zir::{ShouldReduce, UMetadata, ZirExpressionList}; use zokrates_interpreter::Interpreter; use crate::compile::CompileConfig; -use crate::flat_absy::*; -use crate::zir::types::{Type, UBitwidth}; -use crate::zir::{ - BooleanExpression, FieldElementExpression, Identifier, IfElse, Parameter as ZirParameter, - UExpression, UExpressionInner, Variable as ZirVariable, ZirExpression, ZirFunction, - ZirStatement, -}; use std::collections::{ hash_map::{Entry, HashMap}, VecDeque, @@ -27,7 +20,14 @@ use std::convert::TryFrom; use zokrates_ast::common::embed::*; use zokrates_ast::common::FlatEmbed; use zokrates_ast::common::{RuntimeError, Variable}; +use zokrates_ast::flat::*; use zokrates_ast::ir::Solver; +use zokrates_ast::zir::types::{Type, UBitwidth}; +use zokrates_ast::zir::{ + BooleanExpression, FieldElementExpression, Identifier, IfElse, Parameter as ZirParameter, + UExpression, UExpressionInner, Variable as ZirVariable, ZirExpression, ZirFunction, + ZirStatement, +}; use zokrates_field::Field; type FlatStatements = VecDeque>; @@ -36,10 +36,10 @@ type FlatStatements = VecDeque>; /// /// # Arguments /// * `funct` - `ZirFunction` that will be flattened -pub fn from_function_and_config<'ast, T: Field>( - funct: ZirFunction<'ast, T>, +pub fn from_function_and_config( + funct: ZirFunction, config: CompileConfig, -) -> FlattenerIterator<'ast, T> { +) -> FlattenerIterator { let mut flattener = Flattener::new(config); let mut statements_flattened = FlatStatements::new(); // push parameters @@ -208,15 +208,6 @@ impl FlatUExpression { } } -// impl From for RuntimeError { -// fn from(error: crate::zir::RuntimeError) -> Self { -// match error { -// crate::zir::RuntimeError::SourceAssertion(s) => RuntimeError::SourceAssertion(s), -// crate::zir::RuntimeError::SelectRangeCheck => RuntimeError::SelectRangeCheck, -// } -// } -// } - impl<'ast, T: Field> Flattener<'ast, T> { /// Returns a `Flattener` with fresh `layout`. fn new(config: CompileConfig) -> Flattener<'ast, T> { @@ -2710,13 +2701,13 @@ impl<'ast, T: Field> Flattener<'ast, T> { #[cfg(test)] mod tests { use super::*; - use crate::zir; - use crate::zir::types::Signature; - use crate::zir::types::Type; + use zokrates_ast::zir; + use zokrates_ast::zir::types::Signature; + use zokrates_ast::zir::types::Type; use zokrates_field::Bn128Field; fn flatten_function(f: ZirFunction) -> FlatProg { - FlattenerIterator::from_function_and_config(f, CompileConfig::default()).collect() + from_function_and_config(f, CompileConfig::default()).collect() } #[test] @@ -2734,11 +2725,11 @@ mod tests { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::boolean("x".into()), + zir::Variable::boolean("x".into()), BooleanExpression::Value(true).into(), ), ZirStatement::Definition( - Variable::boolean("y".into()), + zir::Variable::boolean("y".into()), BooleanExpression::Value(true).into(), ), ZirStatement::Assertion( @@ -2798,11 +2789,11 @@ mod tests { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::field_element("x"), + zir::Variable::field_element("x"), FieldElementExpression::Number(Bn128Field::from(1)).into(), ), ZirStatement::Definition( - Variable::field_element("y"), + zir::Variable::field_element("y"), FieldElementExpression::Number(Bn128Field::from(2)).into(), ), ZirStatement::Assertion( @@ -2872,7 +2863,7 @@ mod tests { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::uint("x".into(), 32), + zir::Variable::uint("x".into(), 32), ZirExpression::Uint( UExpressionInner::Value(42) .annotate(32) @@ -2936,11 +2927,11 @@ mod tests { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::field_element("x"), + zir::Variable::field_element("x"), FieldElementExpression::Number(Bn128Field::from(2)).into(), ), ZirStatement::Definition( - Variable::field_element("y"), + zir::Variable::field_element("y"), FieldElementExpression::Number(Bn128Field::from(2)).into(), ), ZirStatement::Assertion( @@ -3004,15 +2995,15 @@ mod tests { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::field_element("x"), + zir::Variable::field_element("x"), FieldElementExpression::Number(Bn128Field::from(2)).into(), ), ZirStatement::Definition( - Variable::field_element("y"), + zir::Variable::field_element("y"), FieldElementExpression::Number(Bn128Field::from(2)).into(), ), ZirStatement::Definition( - Variable::field_element("z"), + zir::Variable::field_element("z"), FieldElementExpression::Number(Bn128Field::from(4)).into(), ), ZirStatement::Assertion( @@ -3083,15 +3074,15 @@ mod tests { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::field_element("x"), + zir::Variable::field_element("x"), FieldElementExpression::Number(Bn128Field::from(2)).into(), ), ZirStatement::Definition( - Variable::field_element("y"), + zir::Variable::field_element("y"), FieldElementExpression::Number(Bn128Field::from(2)).into(), ), ZirStatement::Definition( - Variable::field_element("z"), + zir::Variable::field_element("z"), FieldElementExpression::Number(Bn128Field::from(4)).into(), ), ZirStatement::Assertion( @@ -3164,19 +3155,19 @@ mod tests { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::field_element("x"), + zir::Variable::field_element("x"), FieldElementExpression::Number(Bn128Field::from(4)).into(), ), ZirStatement::Definition( - Variable::field_element("y"), + zir::Variable::field_element("y"), FieldElementExpression::Number(Bn128Field::from(4)).into(), ), ZirStatement::Definition( - Variable::field_element("z"), + zir::Variable::field_element("z"), FieldElementExpression::Number(Bn128Field::from(8)).into(), ), ZirStatement::Definition( - Variable::field_element("t"), + zir::Variable::field_element("t"), FieldElementExpression::Number(Bn128Field::from(2)).into(), ), ZirStatement::Assertion( @@ -3257,11 +3248,11 @@ mod tests { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::field_element("a"), + zir::Variable::field_element("a"), FieldElementExpression::Number(Bn128Field::from(7)).into(), ), ZirStatement::Definition( - Variable::field_element("b"), + zir::Variable::field_element("b"), FieldElementExpression::Pow( box FieldElementExpression::Identifier("a".into()), box 0u32.into(), @@ -3316,11 +3307,11 @@ mod tests { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::field_element("a"), + zir::Variable::field_element("a"), FieldElementExpression::Number(Bn128Field::from(7)).into(), ), ZirStatement::Definition( - Variable::field_element("b"), + zir::Variable::field_element("b"), FieldElementExpression::Pow( box FieldElementExpression::Identifier("a".into()), box 1u32.into(), @@ -3395,11 +3386,11 @@ mod tests { arguments: vec![], statements: vec![ ZirStatement::Definition( - Variable::field_element("a"), + zir::Variable::field_element("a"), FieldElementExpression::Number(Bn128Field::from(7)).into(), ), ZirStatement::Definition( - Variable::field_element("b"), + zir::Variable::field_element("b"), FieldElementExpression::Pow( box FieldElementExpression::Identifier("a".into()), box 13u32.into(), @@ -3542,12 +3533,12 @@ mod tests { let mut statements_flattened = FlatStatements::new(); let definition = ZirStatement::Definition( - Variable::field_element("b"), + zir::Variable::field_element("b"), FieldElementExpression::Number(Bn128Field::from(42)).into(), ); let statement = ZirStatement::Definition( - Variable::field_element("a"), + zir::Variable::field_element("a"), FieldElementExpression::Div( box FieldElementExpression::Div( box FieldElementExpression::Number(Bn128Field::from(5)), diff --git a/zokrates_core/src/flatten/utils.rs b/zokrates_core/src/flatten/utils.rs index 8fd7b8ef..6fc25792 100644 --- a/zokrates_core/src/flatten/utils.rs +++ b/zokrates_core/src/flatten/utils.rs @@ -1,4 +1,4 @@ -use crate::flat_absy::*; +use zokrates_ast::flat::*; use zokrates_field::Field; pub fn flat_expression_from_bits(v: Vec>) -> FlatExpression { diff --git a/zokrates_core/src/imports.rs b/zokrates_core/src/imports.rs index 760bbbdc..e734762b 100644 --- a/zokrates_core/src/imports.rs +++ b/zokrates_core/src/imports.rs @@ -4,17 +4,17 @@ //! @author Thibaut Schaeffer //! @date 2018 -use crate::absy::*; use crate::compile::parse_module; use crate::compile::{CompileErrorInner, CompileErrors}; use std::collections::HashMap; use std::fmt; use std::io; use std::path::{Path, PathBuf}; +use zokrates_ast::untyped::*; -use crate::absy::types::UnresolvedType; use typed_arena::Arena; use zokrates_ast::common::FlatEmbed; +use zokrates_ast::untyped::types::UnresolvedType; use zokrates_common::Resolver; use zokrates_field::Field; diff --git a/zokrates_core/src/lib.rs b/zokrates_core/src/lib.rs index ae703cda..b6cebfcb 100644 --- a/zokrates_core/src/lib.rs +++ b/zokrates_core/src/lib.rs @@ -1,23 +1,9 @@ #![feature(box_patterns, box_syntax)] -cfg_if::cfg_if! { - if #[cfg(feature = "bellman")] { - extern crate bellman_ce as bellman; - extern crate ff_ce as ff; - extern crate pairing_ce as pairing; - } -} - +pub mod compile; mod flatten; pub mod imports; mod macros; mod optimizer; mod semantics; mod static_analysis; -use zokrates_ast::zir; - -pub use zokrates_ast::untyped as absy; -pub mod compile; -pub use zokrates_ast::flat as flat_absy; -pub mod proof_system; -pub use zokrates_ast::typed as typed_absy; diff --git a/zokrates_core/src/optimizer/duplicate.rs b/zokrates_core/src/optimizer/duplicate.rs index ea596403..68c95409 100644 --- a/zokrates_core/src/optimizer/duplicate.rs +++ b/zokrates_core/src/optimizer/duplicate.rs @@ -53,7 +53,7 @@ impl Folder for DuplicateOptimizer { #[cfg(test)] mod tests { use super::*; - use crate::flat_absy::Variable; + use zokrates_ast::flat::Variable; use zokrates_field::Bn128Field; #[test] diff --git a/zokrates_core/src/optimizer/redefinition.rs b/zokrates_core/src/optimizer/redefinition.rs index 14e42cd7..3445f7fa 100644 --- a/zokrates_core/src/optimizer/redefinition.rs +++ b/zokrates_core/src/optimizer/redefinition.rs @@ -36,8 +36,8 @@ // - `q == k * v if v isn't in i`: insert `v` into `i` and return `c_0` // - otherwise return `c_0` -use crate::flat_absy::Variable; use std::collections::{HashMap, HashSet}; +use zokrates_ast::flat::Variable; use zokrates_ast::ir::folder::Folder; use zokrates_ast::ir::LinComb; use zokrates_ast::ir::*; @@ -198,7 +198,7 @@ impl Folder for RedefinitionOptimizer { #[cfg(test)] mod tests { use super::*; - use crate::flat_absy::Parameter; + use zokrates_ast::flat::Parameter; use zokrates_field::Bn128Field; #[test] diff --git a/zokrates_core/src/semantics.rs b/zokrates_core/src/semantics.rs index f907274b..83f0345b 100644 --- a/zokrates_core/src/semantics.rs +++ b/zokrates_core/src/semantics.rs @@ -4,26 +4,26 @@ //! @author Thibaut Schaeffer //! @date 2017 -use crate::absy::Identifier; -use crate::absy::*; -use crate::typed_absy::types::{GGenericsAssignment, GenericsAssignment}; -use crate::typed_absy::*; -use crate::typed_absy::{DeclarationParameter, DeclarationVariable, Variable}; use num_bigint::BigUint; use std::collections::{btree_map::Entry, BTreeMap, BTreeSet, HashMap, HashSet}; use std::fmt; use std::path::PathBuf; +use zokrates_ast::typed::types::{GGenericsAssignment, GenericsAssignment}; +use zokrates_ast::typed::*; +use zokrates_ast::typed::{DeclarationParameter, DeclarationVariable, Variable}; +use zokrates_ast::untyped::Identifier; +use zokrates_ast::untyped::*; use zokrates_field::Field; -use crate::absy::types::{UnresolvedSignature, UnresolvedType, UserTypeId}; +use zokrates_ast::untyped::types::{UnresolvedSignature, UnresolvedType, UserTypeId}; -use crate::typed_absy::types::{ +use std::hash::{Hash, Hasher}; +use zokrates_ast::typed::types::{ check_type, specialize_declaration_type, ArrayType, DeclarationArrayType, DeclarationConstant, DeclarationFunctionKey, DeclarationSignature, DeclarationStructMember, DeclarationStructType, DeclarationTupleType, DeclarationType, GenericIdentifier, StructLocation, StructMember, TupleType, }; -use std::hash::{Hash, Hasher}; #[derive(PartialEq, Debug)] pub struct ErrorInner { @@ -902,7 +902,7 @@ impl<'ast, T: Field> Checker<'ast, T> { self.insert_into_scope(Variable::with_id_and_type(CoreIdentifier::Constant(CanonicalConstantIdentifier::new( declaration.id, module_id.into(), - )), crate::typed_absy::types::try_from_g_type(ty.clone()).unwrap())); + )), zokrates_ast::typed::types::try_from_g_type(ty.clone()).unwrap())); state .constants @@ -1137,7 +1137,7 @@ impl<'ast, T: Field> Checker<'ast, T> { let ty = specialize_declaration_type(decl_v.clone()._type, &generics).unwrap(); - match self.insert_into_scope(crate::typed_absy::variable::Variable { + match self.insert_into_scope(zokrates_ast::typed::variable::Variable { id: decl_v.clone().id, _type: ty, }) { @@ -1638,7 +1638,7 @@ impl<'ast, T: Field> Checker<'ast, T> { fn check_variable( &mut self, - v: crate::absy::VariableNode<'ast>, + v: zokrates_ast::untyped::VariableNode<'ast>, module_id: &ModuleId, types: &TypeMap<'ast, T>, ) -> Result, Vec> { @@ -1651,7 +1651,7 @@ impl<'ast, T: Field> Checker<'ast, T> { fn check_for_loop( &mut self, - var: crate::absy::VariableNode<'ast>, + var: zokrates_ast::untyped::VariableNode<'ast>, range: (ExpressionNode<'ast>, ExpressionNode<'ast>), statements: Vec>, pos: (Position, Position), @@ -2475,11 +2475,11 @@ impl<'ast, T: Field> Checker<'ast, T> { })?; let kind = match kind { - crate::absy::ConditionalKind::IfElse => { - crate::typed_absy::ConditionalKind::IfElse + zokrates_ast::untyped::ConditionalKind::IfElse => { + zokrates_ast::typed::ConditionalKind::IfElse } - crate::absy::ConditionalKind::Ternary => { - crate::typed_absy::ConditionalKind::Ternary + zokrates_ast::untyped::ConditionalKind::Ternary => { + zokrates_ast::typed::ConditionalKind::Ternary } }; @@ -3627,9 +3627,9 @@ impl<'ast, T: Field> Checker<'ast, T> { #[cfg(test)] mod tests { use super::*; - use crate::absy; - use crate::typed_absy; use lazy_static::lazy_static; + use zokrates_ast::typed; + use zokrates_ast::untyped; use zokrates_field::Bn128Field; lazy_static! { @@ -3752,8 +3752,8 @@ mod tests { ) .mock()]; - let arguments = vec![absy::Parameter { - id: absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + let arguments = vec![untyped::Parameter { + id: untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), private: true, } .mock()]; @@ -3955,8 +3955,8 @@ mod tests { let mut f0 = function0(); - f0.value.arguments = vec![absy::Parameter::private( - absy::Variable::new( + f0.value.arguments = vec![untyped::Parameter::private( + untyped::Variable::new( "a", UnresolvedType::array( UnresolvedType::FieldElement.mock(), @@ -3976,8 +3976,8 @@ mod tests { .mock()]); let mut f1 = function0(); - f1.value.arguments = vec![absy::Parameter::private( - absy::Variable::new( + f1.value.arguments = vec![untyped::Parameter::private( + untyped::Variable::new( "a", UnresolvedType::array( UnresolvedType::FieldElement.mock(), @@ -4064,8 +4064,8 @@ mod tests { let mut foo = function0(); - foo.value.arguments = vec![absy::Parameter::private( - absy::Variable::new( + foo.value.arguments = vec![untyped::Parameter::private( + untyped::Variable::new( "a", UnresolvedType::array( UnresolvedType::FieldElement.mock(), @@ -4474,7 +4474,7 @@ mod tests { assert_eq!( checker.check_statement(statement, &*MODULE_ID, &TypeMap::new()), Ok(TypedStatement::Definition( - TypedAssignee::Identifier(typed_absy::Variable::field_element("a")), + TypedAssignee::Identifier(typed::Variable::field_element("a")), FieldElementExpression::Identifier("b".into()).into() )) ); @@ -4491,7 +4491,7 @@ mod tests { let foo_args = vec![]; let foo_statements = vec![ Statement::Declaration( - absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), Statement::Definition( @@ -4576,7 +4576,7 @@ mod tests { let foo_args = vec![]; let foo_statements = vec![ Statement::Declaration( - absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), Statement::Definition( @@ -4603,7 +4603,7 @@ mod tests { let bar_args = vec![]; let bar_statements = vec![ Statement::Declaration( - absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), Statement::Definition( @@ -4679,7 +4679,7 @@ mod tests { // should fail let foo_statements: Vec = vec![ Statement::For( - absy::Variable::new("i", UnresolvedType::Uint(32).mock()).mock(), + untyped::Variable::new("i", UnresolvedType::Uint(32).mock()).mock(), Expression::IntConstant(0usize.into()).mock(), Expression::IntConstant(10usize.into()).mock(), vec![], @@ -4726,7 +4726,7 @@ mod tests { let for_statements = vec![ Statement::Declaration( - absy::Variable::new("a", UnresolvedType::Uint(32).mock()).mock(), + untyped::Variable::new("a", UnresolvedType::Uint(32).mock()).mock(), ) .mock(), Statement::Definition( @@ -4738,7 +4738,7 @@ mod tests { let foo_statements = vec![ Statement::For( - absy::Variable::new("i", UnresolvedType::Uint(32).mock()).mock(), + untyped::Variable::new("i", UnresolvedType::Uint(32).mock()).mock(), Expression::IntConstant(0usize.into()).mock(), Expression::IntConstant(10usize.into()).mock(), for_statements, @@ -4754,9 +4754,9 @@ mod tests { ]; let for_statements_checked = vec![ - TypedStatement::Declaration(typed_absy::Variable::uint("a", UBitwidth::B32)), + TypedStatement::Declaration(typed::Variable::uint("a", UBitwidth::B32)), TypedStatement::Definition( - TypedAssignee::Identifier(typed_absy::Variable::uint("a", UBitwidth::B32)), + TypedAssignee::Identifier(typed::Variable::uint("a", UBitwidth::B32)), UExpressionInner::Identifier("i".into()) .annotate(UBitwidth::B32) .into(), @@ -4765,7 +4765,7 @@ mod tests { let foo_statements_checked = vec![ TypedStatement::For( - typed_absy::Variable::uint("i", UBitwidth::B32), + typed::Variable::uint("i", UBitwidth::B32), 0u32.into(), 10u32.into(), for_statements_checked, @@ -4805,7 +4805,7 @@ mod tests { // should fail let bar_statements: Vec = vec![ Statement::Declaration( - absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), Statement::MultipleDefinition( @@ -4928,7 +4928,7 @@ mod tests { // should fail let bar_statements: Vec = vec![ Statement::Declaration( - absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), Statement::MultipleDefinition( @@ -4990,8 +4990,8 @@ mod tests { .mock()]; let foo = Function { - arguments: vec![crate::absy::Parameter { - id: absy::Variable::new("x", UnresolvedType::FieldElement.mock()).mock(), + arguments: vec![zokrates_ast::untyped::Parameter { + id: untyped::Variable::new("x", UnresolvedType::FieldElement.mock()).mock(), private: false, } .mock()], @@ -5007,11 +5007,11 @@ mod tests { let main_statements: Vec = vec![ Statement::Declaration( - absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), Statement::Declaration( - absy::Variable::new("b", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("b", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), Statement::MultipleDefinition( @@ -5201,7 +5201,7 @@ mod tests { let main_statements: Vec = vec![ Statement::Declaration( - absy::Variable::new( + untyped::Variable::new( "a", UnresolvedType::array( UnresolvedType::FieldElement.mock(), @@ -5214,7 +5214,7 @@ mod tests { .mock(), Statement::Definition( Assignee::Identifier("a").mock(), - Expression::InlineArray(vec![absy::SpreadOrExpression::Expression( + Expression::InlineArray(vec![untyped::SpreadOrExpression::Expression( Expression::IntConstant(0usize.into()).mock(), )]) .mock(), @@ -5224,7 +5224,7 @@ mod tests { vec![Assignee::Select( box Assignee::Identifier("a").mock(), box RangeOrExpression::Expression( - absy::Expression::IntConstant(0usize.into()).mock(), + untyped::Expression::IntConstant(0usize.into()).mock(), ), ) .mock()], @@ -5373,11 +5373,11 @@ mod tests { // should pass let bar_statements: Vec = vec![ Statement::Declaration( - absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), Statement::Declaration( - absy::Variable::new("b", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("b", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), Statement::MultipleDefinition( @@ -5403,12 +5403,12 @@ mod tests { ]; let bar_statements_checked: Vec> = vec![ - TypedStatement::Declaration(typed_absy::Variable::field_element("a")), - TypedStatement::Declaration(typed_absy::Variable::field_element("b")), + TypedStatement::Declaration(typed::Variable::field_element("a")), + TypedStatement::Declaration(typed::Variable::field_element("b")), TypedStatement::MultipleDefinition( vec![ - typed_absy::Variable::field_element("a").into(), - typed_absy::Variable::field_element("b").into(), + typed::Variable::field_element("a").into(), + typed::Variable::field_element("b").into(), ], TypedExpressionList::function_call( DeclarationFunctionKey::with_location((*MODULE_ID).clone(), "foo").signature( @@ -5477,12 +5477,12 @@ mod tests { let mut f = function0(); f.value.arguments = vec![ - absy::Parameter::private( - absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + untyped::Parameter::private( + untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), - absy::Parameter::private( - absy::Variable::new("a", UnresolvedType::Boolean.mock()).mock(), + untyped::Parameter::private( + untyped::Variable::new("a", UnresolvedType::Boolean.mock()).mock(), ) .mock(), ]; @@ -5520,8 +5520,8 @@ mod tests { ) .mock()]; - let main1_arguments = vec![crate::absy::Parameter { - id: absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + let main1_arguments = vec![zokrates_ast::untyped::Parameter { + id: untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), private: false, } .mock()]; @@ -5599,7 +5599,7 @@ mod tests { let mut checker: Checker = Checker::default(); let _: Result, Vec> = checker.check_statement( Statement::Declaration( - absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), &*MODULE_ID, @@ -5608,7 +5608,7 @@ mod tests { let s2_checked: Result, Vec> = checker .check_statement( Statement::Declaration( - absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), &*MODULE_ID, @@ -5633,7 +5633,7 @@ mod tests { let mut checker: Checker = Checker::default(); let _: Result, Vec> = checker.check_statement( Statement::Declaration( - absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), &*MODULE_ID, @@ -5642,7 +5642,7 @@ mod tests { let s2_checked: Result, Vec> = checker .check_statement( Statement::Declaration( - absy::Variable::new("a", UnresolvedType::Boolean.mock()).mock(), + untyped::Variable::new("a", UnresolvedType::Boolean.mock()).mock(), ) .mock(), &*MODULE_ID, @@ -5659,7 +5659,7 @@ mod tests { mod structs { use super::*; - use crate::typed_absy::types::StructMember; + use zokrates_ast::typed::types::StructMember; /// solver function to create a module at location "" with a single symbol `Foo { foo: field }` fn create_module_with_foo( @@ -6395,8 +6395,8 @@ mod tests { let mut foo_field = function0(); - foo_field.value.arguments = vec![absy::Parameter::private( - absy::Variable { + foo_field.value.arguments = vec![untyped::Parameter::private( + untyped::Variable { id: "a", _type: UnresolvedType::FieldElement.mock(), } @@ -6416,8 +6416,8 @@ mod tests { let mut foo_u32 = function0(); - foo_u32.value.arguments = vec![absy::Parameter::private( - absy::Variable { + foo_u32.value.arguments = vec![untyped::Parameter::private( + untyped::Variable { id: "a", _type: UnresolvedType::Uint(32).mock(), } @@ -6453,17 +6453,17 @@ mod tests { UnresolvedSignature::new().outputs(vec![UnresolvedType::FieldElement.mock()]); let m = Module::with_symbols(vec![ - absy::SymbolDeclaration { + untyped::SymbolDeclaration { id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(foo_field)), } .mock(), - absy::SymbolDeclaration { + untyped::SymbolDeclaration { id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(foo_u32)), } .mock(), - absy::SymbolDeclaration { + untyped::SymbolDeclaration { id: "main", symbol: Symbol::Here(SymbolDefinition::Function(main)), } @@ -6502,7 +6502,7 @@ mod tests { checker .check_statement( Statement::Declaration( - absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), + untyped::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(), ) .mock(), &*MODULE_ID, @@ -6512,9 +6512,9 @@ mod tests { assert_eq!( checker.check_assignee(a, &*MODULE_ID, &TypeMap::new()), - Ok(TypedAssignee::Identifier( - typed_absy::Variable::field_element("a") - )) + Ok(TypedAssignee::Identifier(typed::Variable::field_element( + "a" + ))) ); } @@ -6534,7 +6534,7 @@ mod tests { checker .check_statement( Statement::Declaration( - absy::Variable::new( + untyped::Variable::new( "a", UnresolvedType::array( UnresolvedType::FieldElement.mock(), @@ -6553,9 +6553,10 @@ mod tests { assert_eq!( checker.check_assignee(a, &*MODULE_ID, &TypeMap::new()), Ok(TypedAssignee::Select( - box TypedAssignee::Identifier(typed_absy::Variable::field_array( + box TypedAssignee::Identifier(typed::Variable::array( "a", - 33u32.into() + GType::FieldElement, + 33u32 )), box 2u32.into() )) @@ -6584,7 +6585,7 @@ mod tests { checker .check_statement( Statement::Declaration( - absy::Variable::new( + untyped::Variable::new( "a", UnresolvedType::array( UnresolvedType::array( @@ -6608,7 +6609,7 @@ mod tests { checker.check_assignee(a, &*MODULE_ID, &TypeMap::new()), Ok(TypedAssignee::Select( box TypedAssignee::Select( - box TypedAssignee::Identifier(typed_absy::Variable::array( + box TypedAssignee::Identifier(typed::Variable::array( "a", Type::array((Type::FieldElement, 33u32)), 42u32, diff --git a/zokrates_core/src/static_analysis/branch_isolator.rs b/zokrates_core/src/static_analysis/branch_isolator.rs index 4ad54d28..ee41233a 100644 --- a/zokrates_core/src/static_analysis/branch_isolator.rs +++ b/zokrates_core/src/static_analysis/branch_isolator.rs @@ -3,8 +3,8 @@ // `if c then a else b fi` becomes `if c then { a } else { b } fi`, and down the line any statements resulting from trating `a` and `b` can be safely kept inside the respective blocks. -use crate::typed_absy::*; use zokrates_ast::typed::folder::*; +use zokrates_ast::typed::*; use zokrates_field::Field; pub struct Isolator; diff --git a/zokrates_core/src/static_analysis/condition_redefiner.rs b/zokrates_core/src/static_analysis/condition_redefiner.rs index b09f68ba..b4a5fc70 100644 --- a/zokrates_core/src/static_analysis/condition_redefiner.rs +++ b/zokrates_core/src/static_analysis/condition_redefiner.rs @@ -1,4 +1,4 @@ -use crate::typed_absy::{ +use zokrates_ast::typed::{ folder::*, BlockExpression, BooleanExpression, Conditional, ConditionalExpression, ConditionalOrExpression, CoreIdentifier, Expr, Identifier, TypedProgram, TypedStatement, Variable, @@ -89,7 +89,7 @@ impl<'ast, T: Field> Folder<'ast, T> for ConditionRedefiner<'ast, T> { #[cfg(test)] mod tests { use super::*; - use crate::typed_absy::{ + use zokrates_ast::typed::{ Block, BooleanExpression, Conditional, ConditionalKind, FieldElementExpression, Type, }; use zokrates_field::Bn128Field; diff --git a/zokrates_core/src/static_analysis/constant_argument_checker.rs b/zokrates_core/src/static_analysis/constant_argument_checker.rs index 160eb806..5846073e 100644 --- a/zokrates_core/src/static_analysis/constant_argument_checker.rs +++ b/zokrates_core/src/static_analysis/constant_argument_checker.rs @@ -1,11 +1,11 @@ -use crate::typed_absy::TypedProgram; -use crate::typed_absy::{ +use std::fmt; +use zokrates_ast::common::FlatEmbed; +use zokrates_ast::typed::TypedProgram; +use zokrates_ast::typed::{ result_folder::ResultFolder, result_folder::{fold_expression_list_inner, fold_uint_expression_inner}, Constant, TypedExpressionListInner, Types, UBitwidth, UExpressionInner, }; -use std::fmt; -use zokrates_ast::common::FlatEmbed; use zokrates_field::Field; pub struct ConstantArgumentChecker; diff --git a/zokrates_core/src/static_analysis/constant_inliner.rs b/zokrates_core/src/static_analysis/constant_inliner.rs deleted file mode 100644 index d2b803e8..00000000 --- a/zokrates_core/src/static_analysis/constant_inliner.rs +++ /dev/null @@ -1,973 +0,0 @@ -use crate::static_analysis::Propagator; -use crate::typed_absy::result_folder::*; -use crate::typed_absy::types::DeclarationConstant; -use crate::typed_absy::*; -use std::collections::HashMap; -use std::convert::TryInto; -use std::fmt; -use zokrates_field::Field; - -type ProgramConstants<'ast, T> = - HashMap, TypedExpression<'ast, T>>>; - -#[derive(Debug, PartialEq)] -pub enum Error { - Type(String), -} - -impl fmt::Display for Error { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self { - Error::Type(s) => write!(f, "{}", s), - } - } -} -pub struct ConstantInliner<'ast, T> { - modules: TypedModules<'ast, T>, - location: OwnedTypedModuleId, - constants: ProgramConstants<'ast, T>, -} - -impl<'ast, 'a, T: Field> ConstantInliner<'ast, T> { - pub fn new( - modules: TypedModules<'ast, T>, - location: OwnedTypedModuleId, - constants: ProgramConstants<'ast, T>, - ) -> Self { - ConstantInliner { - modules, - location, - constants, - } - } - pub fn inline(p: TypedProgram<'ast, T>) -> Result, Error> { - let constants = ProgramConstants::new(); - let mut inliner = ConstantInliner::new(p.modules.clone(), p.main.clone(), constants); - inliner.fold_program(p) - } - - fn change_location(&mut self, location: OwnedTypedModuleId) -> OwnedTypedModuleId { - let prev = self.location.clone(); - self.location = location; - self.constants.entry(self.location.clone()).or_default(); - prev - } - - fn treated(&self, id: &TypedModuleId) -> bool { - self.constants.contains_key(id) - } - - fn get_constant( - &self, - id: &CanonicalConstantIdentifier<'ast>, - ) -> Option> { - self.constants - .get(&id.module) - .and_then(|constants| constants.get(&id.id.into())) - .cloned() - } - - fn get_constant_for_identifier( - &self, - id: &Identifier<'ast>, - ) -> Option> { - self.constants - .get(&self.location) - .and_then(|constants| constants.get(&id)) - .cloned() - } -} - -impl<'ast, T: Field> ResultFolder<'ast, T> for ConstantInliner<'ast, T> { - type Error = Error; - - fn fold_program( - &mut self, - p: TypedProgram<'ast, T>, - ) -> Result, Self::Error> { - self.fold_module_id(p.main.clone())?; - - Ok(TypedProgram { - modules: std::mem::take(&mut self.modules), - ..p - }) - } - - fn fold_module_id( - &mut self, - id: OwnedTypedModuleId, - ) -> Result { - // anytime we encounter a module id, visit the corresponding module if it hasn't been done yet - if !self.treated(&id) { - let current_m_id = self.change_location(id.clone()); - let m = self.modules.remove(&id).unwrap(); - let m = self.fold_module(m)?; - self.modules.insert(id.clone(), m); - self.change_location(current_m_id); - } - Ok(id) - } - - fn fold_module( - &mut self, - m: TypedModule<'ast, T>, - ) -> Result, Self::Error> { - Ok(TypedModule { - constants: m - .constants - .into_iter() - .map(|(id, tc)| { - - let id = self.fold_canonical_constant_identifier(id)?; - - let constant = match tc { - TypedConstantSymbol::There(imported_id) => { - // visit the imported symbol. This triggers visiting the corresponding module if needed - let imported_id = self.fold_canonical_constant_identifier(imported_id)?; - // after that, the constant must have been defined defined in the global map. It is already reduced - // to a literal, so running propagation isn't required - self.get_constant(&imported_id).unwrap() - } - TypedConstantSymbol::Here(c) => { - let non_propagated_constant = fold_constant(self, c)?.expression; - // folding the constant above only reduces it to an expression containing only literals, not to a single literal. - // propagating with an empty map of constants reduces it to a single literal - Propagator::with_constants(&mut HashMap::default()) - .fold_expression(non_propagated_constant) - .unwrap() - } - }; - - if crate::typed_absy::types::try_from_g_type::<_, UExpression<'ast, T>>(*id.ty.clone()).unwrap() == constant.get_type() { - // add to the constant map. The value added is always a single litteral - self.constants - .get_mut(&self.location) - .unwrap() - .insert(id.id.into(), constant.clone()); - - Ok(( - id, - TypedConstantSymbol::Here(TypedConstant { - expression: constant, - }), - )) - } else { - Err(Error::Type(format!("Expression of type `{}` cannot be assigned to constant `{}` of type `{}`", constant.get_type(), id.id, id.ty))) - } - }) - .collect::, _>>()?, - functions: m - .functions - .into_iter() - .map::, _>(|(key, fun)| { - Ok(( - self.fold_declaration_function_key(key)?, - self.fold_function_symbol(fun)?, - )) - }) - .collect::, _>>() - .into_iter() - .flatten() - .collect(), - }) - } - - fn fold_declaration_constant( - &mut self, - c: DeclarationConstant<'ast>, - ) -> Result, Self::Error> { - match c { - // replace constants by their concrete value in declaration types - DeclarationConstant::Constant(id) => { - let id = CanonicalConstantIdentifier { - module: self.fold_module_id(id.module)?, - ..id - }; - - Ok(DeclarationConstant::Concrete(match self.get_constant(&id).unwrap() { - TypedExpression::Uint(UExpression { - inner: UExpressionInner::Value(v), - .. - }) => v as u32, - _ => unreachable!("all constants found in declaration types should be reduceable to u32 literals"), - })) - } - c => Ok(c), - } - } - - fn fold_field_expression( - &mut self, - e: FieldElementExpression<'ast, T>, - ) -> Result, Self::Error> { - match e { - FieldElementExpression::Identifier(ref id) => { - match self.get_constant_for_identifier(id) { - Some(c) => Ok(c.try_into().unwrap()), - None => fold_field_expression(self, e), - } - } - e => fold_field_expression(self, e), - } - } - - fn fold_boolean_expression( - &mut self, - e: BooleanExpression<'ast, T>, - ) -> Result, Self::Error> { - match e { - BooleanExpression::Identifier(ref id) => match self.get_constant_for_identifier(id) { - Some(c) => Ok(c.try_into().unwrap()), - None => fold_boolean_expression(self, e), - }, - e => fold_boolean_expression(self, e), - } - } - - fn fold_uint_expression_inner( - &mut self, - size: UBitwidth, - e: UExpressionInner<'ast, T>, - ) -> Result, Self::Error> { - match e { - UExpressionInner::Identifier(ref id) => match self.get_constant_for_identifier(id) { - Some(c) => { - let e: UExpression<'ast, T> = c.try_into().unwrap(); - Ok(e.into_inner()) - } - None => fold_uint_expression_inner(self, size, e), - }, - e => fold_uint_expression_inner(self, size, e), - } - } - - fn fold_array_expression_inner( - &mut self, - ty: &ArrayType<'ast, T>, - e: ArrayExpressionInner<'ast, T>, - ) -> Result, Self::Error> { - match e { - ArrayExpressionInner::Identifier(ref id) => { - match self.get_constant_for_identifier(id) { - Some(c) => { - let e: ArrayExpression<'ast, T> = c.try_into().unwrap(); - Ok(e.into_inner()) - } - None => fold_array_expression_inner(self, ty, e), - } - } - e => fold_array_expression_inner(self, ty, e), - } - } - - fn fold_struct_expression_inner( - &mut self, - ty: &StructType<'ast, T>, - e: StructExpressionInner<'ast, T>, - ) -> Result, Self::Error> { - match e { - StructExpressionInner::Identifier(ref id) => match self.get_constant_for_identifier(id) - { - Some(c) => { - let e: StructExpression<'ast, T> = c.try_into().unwrap(); - Ok(e.into_inner()) - } - None => fold_struct_expression_inner(self, ty, e), - }, - e => fold_struct_expression_inner(self, ty, e), - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::typed_absy::types::DeclarationSignature; - use crate::typed_absy::{ - DeclarationArrayType, DeclarationFunctionKey, DeclarationType, FieldElementExpression, - GType, Identifier, TypedConstant, TypedExpression, TypedFunction, TypedFunctionSymbol, - TypedStatement, - }; - use zokrates_field::Bn128Field; - - #[test] - fn inline_const_field() { - // const field a = 1 - // - // def main() -> field: - // return a - - let const_id = "a"; - let main: TypedFunction = TypedFunction { - arguments: vec![], - statements: vec![TypedStatement::Return(vec![ - FieldElementExpression::Identifier(Identifier::from(const_id)).into(), - ])], - signature: DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - }; - - let constants: TypedConstantSymbols<_> = vec![( - CanonicalConstantIdentifier::new( - const_id, - "main".into(), - DeclarationType::FieldElement, - ), - TypedConstantSymbol::Here(TypedConstant::new(TypedExpression::FieldElement( - FieldElementExpression::Number(Bn128Field::from(1)), - ))), - )] - .into_iter() - .collect(); - - let program = TypedProgram { - main: "main".into(), - modules: vec![( - "main".into(), - TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main").signature( - DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - ), - TypedFunctionSymbol::Here(main), - )] - .into_iter() - .collect(), - constants: constants.clone(), - }, - )] - .into_iter() - .collect(), - }; - - let program = ConstantInliner::inline(program); - - let expected_main = TypedFunction { - arguments: vec![], - statements: vec![TypedStatement::Return(vec![ - FieldElementExpression::Number(Bn128Field::from(1)).into(), - ])], - signature: DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - }; - - let expected_program: TypedProgram = TypedProgram { - main: "main".into(), - modules: vec![( - "main".into(), - TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main").signature( - DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - ), - TypedFunctionSymbol::Here(expected_main), - )] - .into_iter() - .collect(), - constants, - }, - )] - .into_iter() - .collect(), - }; - - assert_eq!(program, Ok(expected_program)) - } - - #[test] - fn inline_const_boolean() { - // const bool a = true - // - // def main() -> bool: - // return a - - let const_id = "a"; - let main: TypedFunction = TypedFunction { - arguments: vec![], - statements: vec![TypedStatement::Return(vec![BooleanExpression::Identifier( - Identifier::from(const_id), - ) - .into()])], - signature: DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::Boolean]), - }; - - let constants: TypedConstantSymbols<_> = vec![( - CanonicalConstantIdentifier::new(const_id, "main".into(), DeclarationType::Boolean), - TypedConstantSymbol::Here(TypedConstant::new(TypedExpression::Boolean( - BooleanExpression::Value(true), - ))), - )] - .into_iter() - .collect(); - - let program = TypedProgram { - main: "main".into(), - modules: vec![( - "main".into(), - TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main").signature( - DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::Boolean]), - ), - TypedFunctionSymbol::Here(main), - )] - .into_iter() - .collect(), - constants: constants.clone(), - }, - )] - .into_iter() - .collect(), - }; - - let program = ConstantInliner::inline(program); - - let expected_main = TypedFunction { - arguments: vec![], - statements: vec![TypedStatement::Return(vec![ - BooleanExpression::Value(true).into() - ])], - signature: DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::Boolean]), - }; - - let expected_program: TypedProgram = TypedProgram { - main: "main".into(), - modules: vec![( - "main".into(), - TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main").signature( - DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::Boolean]), - ), - TypedFunctionSymbol::Here(expected_main), - )] - .into_iter() - .collect(), - constants, - }, - )] - .into_iter() - .collect(), - }; - - assert_eq!(program, Ok(expected_program)) - } - - #[test] - fn inline_const_uint() { - // const u32 a = 0x00000001 - // - // def main() -> u32: - // return a - - let const_id = "a"; - let main: TypedFunction = TypedFunction { - arguments: vec![], - statements: vec![TypedStatement::Return(vec![UExpressionInner::Identifier( - Identifier::from(const_id), - ) - .annotate(UBitwidth::B32) - .into()])], - signature: DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::Uint(UBitwidth::B32)]), - }; - - let constants: TypedConstantSymbols<_> = vec![( - CanonicalConstantIdentifier::new( - const_id, - "main".into(), - DeclarationType::Uint(UBitwidth::B32), - ), - TypedConstantSymbol::Here(TypedConstant::new( - UExpressionInner::Value(1u128) - .annotate(UBitwidth::B32) - .into(), - )), - )] - .into_iter() - .collect(); - - let program = TypedProgram { - main: "main".into(), - modules: vec![( - "main".into(), - TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main").signature( - DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::Uint(UBitwidth::B32)]), - ), - TypedFunctionSymbol::Here(main), - )] - .into_iter() - .collect(), - constants: constants.clone(), - }, - )] - .into_iter() - .collect(), - }; - - let program = ConstantInliner::inline(program); - - let expected_main = TypedFunction { - arguments: vec![], - statements: vec![TypedStatement::Return(vec![UExpressionInner::Value(1u128) - .annotate(UBitwidth::B32) - .into()])], - signature: DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::Uint(UBitwidth::B32)]), - }; - - let expected_program: TypedProgram = TypedProgram { - main: "main".into(), - modules: vec![( - "main".into(), - TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main").signature( - DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::Uint(UBitwidth::B32)]), - ), - TypedFunctionSymbol::Here(expected_main), - )] - .into_iter() - .collect(), - constants, - }, - )] - .into_iter() - .collect(), - }; - - assert_eq!(program, Ok(expected_program)) - } - - #[test] - fn inline_const_field_array() { - // const field[2] a = [2, 2] - // - // def main() -> field: - // return a[0] + a[1] - - let const_id = "a"; - let main: TypedFunction = TypedFunction { - arguments: vec![], - statements: vec![TypedStatement::Return(vec![FieldElementExpression::Add( - FieldElementExpression::select( - ArrayExpressionInner::Identifier(Identifier::from(const_id)) - .annotate(GType::FieldElement, 2u32), - UExpressionInner::Value(0u128).annotate(UBitwidth::B32), - ) - .into(), - FieldElementExpression::select( - ArrayExpressionInner::Identifier(Identifier::from(const_id)) - .annotate(GType::FieldElement, 2u32), - UExpressionInner::Value(1u128).annotate(UBitwidth::B32), - ) - .into(), - ) - .into()])], - signature: DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - }; - - let constants: TypedConstantSymbols<_> = vec![( - CanonicalConstantIdentifier::new( - const_id, - "main".into(), - DeclarationType::Array(DeclarationArrayType::new( - DeclarationType::FieldElement, - 2u32, - )), - ), - TypedConstantSymbol::Here(TypedConstant::new(TypedExpression::Array( - ArrayExpressionInner::Value( - vec![ - FieldElementExpression::Number(Bn128Field::from(2)).into(), - FieldElementExpression::Number(Bn128Field::from(2)).into(), - ] - .into(), - ) - .annotate(GType::FieldElement, 2u32), - ))), - )] - .into_iter() - .collect(); - - let program = TypedProgram { - main: "main".into(), - modules: vec![( - "main".into(), - TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main").signature( - DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - ), - TypedFunctionSymbol::Here(main), - )] - .into_iter() - .collect(), - constants: constants.clone(), - }, - )] - .into_iter() - .collect(), - }; - - let program = ConstantInliner::inline(program); - - let expected_main = TypedFunction { - arguments: vec![], - statements: vec![TypedStatement::Return(vec![FieldElementExpression::Add( - FieldElementExpression::select( - ArrayExpressionInner::Value( - vec![ - FieldElementExpression::Number(Bn128Field::from(2)).into(), - FieldElementExpression::Number(Bn128Field::from(2)).into(), - ] - .into(), - ) - .annotate(GType::FieldElement, 2u32), - UExpressionInner::Value(0u128).annotate(UBitwidth::B32), - ) - .into(), - FieldElementExpression::select( - ArrayExpressionInner::Value( - vec![ - FieldElementExpression::Number(Bn128Field::from(2)).into(), - FieldElementExpression::Number(Bn128Field::from(2)).into(), - ] - .into(), - ) - .annotate(GType::FieldElement, 2u32), - UExpressionInner::Value(1u128).annotate(UBitwidth::B32), - ) - .into(), - ) - .into()])], - signature: DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - }; - - let expected_program: TypedProgram = TypedProgram { - main: "main".into(), - modules: vec![( - "main".into(), - TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main").signature( - DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - ), - TypedFunctionSymbol::Here(expected_main), - )] - .into_iter() - .collect(), - constants, - }, - )] - .into_iter() - .collect(), - }; - - assert_eq!(program, Ok(expected_program)) - } - - #[test] - fn inline_nested_const_field() { - // const field a = 1 - // const field b = a + 1 - // - // def main() -> field: - // return b - - let const_a_id = "a"; - let const_b_id = "b"; - - let main: TypedFunction = TypedFunction { - arguments: vec![], - statements: vec![TypedStatement::Return(vec![ - FieldElementExpression::Identifier(Identifier::from(const_b_id)).into(), - ])], - signature: DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - }; - - let program = TypedProgram { - main: "main".into(), - modules: vec![( - "main".into(), - TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main").signature( - DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - ), - TypedFunctionSymbol::Here(main), - )] - .into_iter() - .collect(), - constants: vec![ - ( - CanonicalConstantIdentifier::new( - const_a_id, - "main".into(), - DeclarationType::FieldElement, - ), - TypedConstantSymbol::Here(TypedConstant::new( - TypedExpression::FieldElement(FieldElementExpression::Number( - Bn128Field::from(1), - )), - )), - ), - ( - CanonicalConstantIdentifier::new( - const_b_id, - "main".into(), - DeclarationType::FieldElement, - ), - TypedConstantSymbol::Here(TypedConstant::new( - TypedExpression::FieldElement(FieldElementExpression::Add( - box FieldElementExpression::Identifier(Identifier::from( - const_a_id, - )), - box FieldElementExpression::Number(Bn128Field::from(1)), - )), - )), - ), - ] - .into_iter() - .collect(), - }, - )] - .into_iter() - .collect(), - }; - - let program = ConstantInliner::inline(program); - - let expected_main = TypedFunction { - arguments: vec![], - statements: vec![TypedStatement::Return(vec![ - FieldElementExpression::Number(Bn128Field::from(2)).into(), - ])], - signature: DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - }; - - let expected_program: TypedProgram = TypedProgram { - main: "main".into(), - modules: vec![( - "main".into(), - TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main").signature( - DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - ), - TypedFunctionSymbol::Here(expected_main), - )] - .into_iter() - .collect(), - constants: vec![ - ( - CanonicalConstantIdentifier::new( - const_a_id, - "main".into(), - DeclarationType::FieldElement, - ), - TypedConstantSymbol::Here(TypedConstant::new( - TypedExpression::FieldElement(FieldElementExpression::Number( - Bn128Field::from(1), - )), - )), - ), - ( - CanonicalConstantIdentifier::new( - const_b_id, - "main".into(), - DeclarationType::FieldElement, - ), - TypedConstantSymbol::Here(TypedConstant::new( - TypedExpression::FieldElement(FieldElementExpression::Number( - Bn128Field::from(2), - )), - )), - ), - ] - .into_iter() - .collect(), - }, - )] - .into_iter() - .collect(), - }; - - assert_eq!(program, Ok(expected_program)) - } - - #[test] - fn inline_imported_constant() { - // --------------------- - // module `foo` - // -------------------- - // const field FOO = 42 - // - // def main(): - // return - // - // --------------------- - // module `main` - // --------------------- - // from "foo" import FOO - // - // def main() -> field: - // return FOO - - let foo_const_id = "FOO"; - let foo_module = TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main") - .signature(DeclarationSignature::new().inputs(vec![]).outputs(vec![])), - TypedFunctionSymbol::Here(TypedFunction { - arguments: vec![], - statements: vec![], - signature: DeclarationSignature::new().inputs(vec![]).outputs(vec![]), - }), - )] - .into_iter() - .collect(), - constants: vec![( - CanonicalConstantIdentifier::new( - foo_const_id, - "foo".into(), - DeclarationType::FieldElement, - ), - TypedConstantSymbol::Here(TypedConstant::new(TypedExpression::FieldElement( - FieldElementExpression::Number(Bn128Field::from(42)), - ))), - )] - .into_iter() - .collect(), - }; - - let main_module = TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main").signature( - DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - ), - TypedFunctionSymbol::Here(TypedFunction { - arguments: vec![], - statements: vec![TypedStatement::Return(vec![ - FieldElementExpression::Identifier(Identifier::from(foo_const_id)).into(), - ])], - signature: DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - }), - )] - .into_iter() - .collect(), - constants: vec![( - CanonicalConstantIdentifier::new( - foo_const_id, - "main".into(), - DeclarationType::FieldElement, - ), - TypedConstantSymbol::There(CanonicalConstantIdentifier::new( - foo_const_id, - "foo".into(), - DeclarationType::FieldElement, - )), - )] - .into_iter() - .collect(), - }; - - let program = TypedProgram { - main: "main".into(), - modules: vec![ - ("main".into(), main_module), - ("foo".into(), foo_module.clone()), - ] - .into_iter() - .collect(), - }; - - let program = ConstantInliner::inline(program); - let expected_main_module = TypedModule { - functions: vec![( - DeclarationFunctionKey::with_location("main", "main").signature( - DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - ), - TypedFunctionSymbol::Here(TypedFunction { - arguments: vec![], - statements: vec![TypedStatement::Return(vec![ - FieldElementExpression::Number(Bn128Field::from(42)).into(), - ])], - signature: DeclarationSignature::new() - .inputs(vec![]) - .outputs(vec![DeclarationType::FieldElement]), - }), - )] - .into_iter() - .collect(), - constants: vec![( - CanonicalConstantIdentifier::new( - foo_const_id, - "main".into(), - DeclarationType::FieldElement, - ), - TypedConstantSymbol::Here(TypedConstant::new(TypedExpression::FieldElement( - FieldElementExpression::Number(Bn128Field::from(42)), - ))), - )] - .into_iter() - .collect(), - }; - - let expected_program: TypedProgram = TypedProgram { - main: "main".into(), - modules: vec![ - ("main".into(), expected_main_module), - ("foo".into(), foo_module), - ] - .into_iter() - .collect(), - }; - - assert_eq!(program, Ok(expected_program)) - } -} diff --git a/zokrates_core/src/static_analysis/constant_resolver.rs b/zokrates_core/src/static_analysis/constant_resolver.rs index 62fe07cc..b4d7fdac 100644 --- a/zokrates_core/src/static_analysis/constant_resolver.rs +++ b/zokrates_core/src/static_analysis/constant_resolver.rs @@ -2,9 +2,9 @@ // This does *not* reduce constants to their literal value // This step cannot fail as the imports were checked during semantics -use crate::typed_absy::*; use std::collections::HashMap; use zokrates_ast::typed::folder::*; +use zokrates_ast::typed::*; use zokrates_field::Field; // a map of the canonical constants in this program. with all imported constants reduced to their canonical value @@ -109,8 +109,8 @@ impl<'ast, T: Field> Folder<'ast, T> for ConstantResolver<'ast, T> { #[cfg(test)] mod tests { use super::*; - use crate::typed_absy::types::DeclarationSignature; - use crate::typed_absy::{ + use zokrates_ast::typed::types::DeclarationSignature; + use zokrates_ast::typed::{ DeclarationArrayType, DeclarationFunctionKey, DeclarationType, FieldElementExpression, GType, Identifier, TypedConstant, TypedExpression, TypedFunction, TypedFunctionSymbol, TypedStatement, diff --git a/zokrates_core/src/static_analysis/flat_propagation.rs b/zokrates_core/src/static_analysis/flat_propagation.rs index 36d9a72e..f69b9313 100644 --- a/zokrates_core/src/static_analysis/flat_propagation.rs +++ b/zokrates_core/src/static_analysis/flat_propagation.rs @@ -4,11 +4,12 @@ //! @author Thibaut Schaeffer //! @date 2018 -use crate::flat_absy::*; use std::collections::HashMap; use zokrates_ast::flat::folder::*; +use zokrates_ast::flat::*; use zokrates_field::Field; +#[derive(Default)] struct Propagator { constants: HashMap, } @@ -77,39 +78,45 @@ mod tests { #[test] fn add() { + let mut propagator = Propagator::default(); + let e = FlatExpression::Add( box FlatExpression::Number(Bn128Field::from(2)), box FlatExpression::Number(Bn128Field::from(3)), ); assert_eq!( - e.propagate(&mut HashMap::new()), + propagator.fold_expression(e), FlatExpression::Number(Bn128Field::from(5)) ); } #[test] fn sub() { + let mut propagator = Propagator::default(); + let e = FlatExpression::Sub( box FlatExpression::Number(Bn128Field::from(3)), box FlatExpression::Number(Bn128Field::from(2)), ); assert_eq!( - e.propagate(&mut HashMap::new()), + propagator.fold_expression(e), FlatExpression::Number(Bn128Field::from(1)) ); } #[test] fn mult() { + let mut propagator = Propagator::default(); + let e = FlatExpression::Mult( box FlatExpression::Number(Bn128Field::from(3)), box FlatExpression::Number(Bn128Field::from(2)), ); assert_eq!( - e.propagate(&mut HashMap::new()), + propagator.fold_expression(e), FlatExpression::Number(Bn128Field::from(6)) ); } diff --git a/zokrates_core/src/static_analysis/flatten_complex_types.rs b/zokrates_core/src/static_analysis/flatten_complex_types.rs index 1d8ab686..cdbe2367 100644 --- a/zokrates_core/src/static_analysis/flatten_complex_types.rs +++ b/zokrates_core/src/static_analysis/flatten_complex_types.rs @@ -1,7 +1,7 @@ -use crate::typed_absy::types::UBitwidth; -use crate::typed_absy::{self, Expr}; -use crate::zir; use std::marker::PhantomData; +use zokrates_ast::typed::types::UBitwidth; +use zokrates_ast::typed::{self, Expr}; +use zokrates_ast::zir; use zokrates_field::Field; use std::convert::{TryFrom, TryInto}; @@ -13,23 +13,23 @@ pub struct Flattener { fn flatten_identifier_rec<'ast>( id: zir::SourceIdentifier<'ast>, - ty: &typed_absy::types::ConcreteType, + ty: &typed::types::ConcreteType, ) -> Vec> { match ty { - typed_absy::ConcreteType::Int => unreachable!(), - typed_absy::ConcreteType::FieldElement => vec![zir::Variable { + typed::ConcreteType::Int => unreachable!(), + typed::ConcreteType::FieldElement => vec![zir::Variable { id: zir::Identifier::Source(id), _type: zir::Type::FieldElement, }], - typed_absy::types::ConcreteType::Boolean => vec![zir::Variable { + typed::types::ConcreteType::Boolean => vec![zir::Variable { id: zir::Identifier::Source(id), _type: zir::Type::Boolean, }], - typed_absy::types::ConcreteType::Uint(bitwidth) => vec![zir::Variable { + typed::types::ConcreteType::Uint(bitwidth) => vec![zir::Variable { id: zir::Identifier::Source(id), _type: zir::Type::uint(bitwidth.to_usize()), }], - typed_absy::types::ConcreteType::Array(array_type) => (0..array_type.size) + typed::types::ConcreteType::Array(array_type) => (0..array_type.size) .flat_map(|i| { flatten_identifier_rec( zir::SourceIdentifier::Select(box id.clone(), i), @@ -37,7 +37,7 @@ fn flatten_identifier_rec<'ast>( ) }) .collect(), - typed_absy::types::ConcreteType::Struct(members) => members + typed::types::ConcreteType::Struct(members) => members .iter() .flat_map(|struct_member| { flatten_identifier_rec( @@ -46,7 +46,7 @@ fn flatten_identifier_rec<'ast>( ) }) .collect(), - typed_absy::types::ConcreteType::Tuple(tuple_ty) => tuple_ty + typed::types::ConcreteType::Tuple(tuple_ty) => tuple_ty .elements .iter() .enumerate() @@ -65,7 +65,7 @@ trait Flatten<'ast, T: Field> { ) -> Vec>; } -impl<'ast, T: Field> Flatten<'ast, T> for typed_absy::FieldElementExpression<'ast, T> { +impl<'ast, T: Field> Flatten<'ast, T> for typed::FieldElementExpression<'ast, T> { fn flatten( self, f: &mut Flattener, @@ -75,7 +75,7 @@ impl<'ast, T: Field> Flatten<'ast, T> for typed_absy::FieldElementExpression<'as } } -impl<'ast, T: Field> Flatten<'ast, T> for typed_absy::BooleanExpression<'ast, T> { +impl<'ast, T: Field> Flatten<'ast, T> for typed::BooleanExpression<'ast, T> { fn flatten( self, f: &mut Flattener, @@ -85,7 +85,7 @@ impl<'ast, T: Field> Flatten<'ast, T> for typed_absy::BooleanExpression<'ast, T> } } -impl<'ast, T: Field> Flatten<'ast, T> for typed_absy::UExpression<'ast, T> { +impl<'ast, T: Field> Flatten<'ast, T> for typed::UExpression<'ast, T> { fn flatten( self, f: &mut Flattener, @@ -95,7 +95,7 @@ impl<'ast, T: Field> Flatten<'ast, T> for typed_absy::UExpression<'ast, T> { } } -impl<'ast, T: Field> Flatten<'ast, T> for typed_absy::ArrayExpression<'ast, T> { +impl<'ast, T: Field> Flatten<'ast, T> for typed::ArrayExpression<'ast, T> { fn flatten( self, f: &mut Flattener, @@ -105,7 +105,7 @@ impl<'ast, T: Field> Flatten<'ast, T> for typed_absy::ArrayExpression<'ast, T> { } } -impl<'ast, T: Field> Flatten<'ast, T> for typed_absy::StructExpression<'ast, T> { +impl<'ast, T: Field> Flatten<'ast, T> for typed::StructExpression<'ast, T> { fn flatten( self, f: &mut Flattener, @@ -115,7 +115,7 @@ impl<'ast, T: Field> Flatten<'ast, T> for typed_absy::StructExpression<'ast, T> } } -impl<'ast, T: Field> Flatten<'ast, T> for typed_absy::TupleExpression<'ast, T> { +impl<'ast, T: Field> Flatten<'ast, T> for typed::TupleExpression<'ast, T> { fn flatten( self, f: &mut Flattener, @@ -126,84 +126,78 @@ impl<'ast, T: Field> Flatten<'ast, T> for typed_absy::TupleExpression<'ast, T> { } impl<'ast, T: Field> Flattener { - pub fn flatten(p: typed_absy::TypedProgram) -> zir::ZirProgram { + pub fn flatten(p: typed::TypedProgram) -> zir::ZirProgram { let mut f = Flattener::default(); f.fold_program(p) } - fn fold_program(&mut self, p: typed_absy::TypedProgram<'ast, T>) -> zir::ZirProgram<'ast, T> { + fn fold_program(&mut self, p: typed::TypedProgram<'ast, T>) -> zir::ZirProgram<'ast, T> { fold_program(self, p) } - fn fold_function( - &mut self, - f: typed_absy::TypedFunction<'ast, T>, - ) -> zir::ZirFunction<'ast, T> { + fn fold_function(&mut self, f: typed::TypedFunction<'ast, T>) -> zir::ZirFunction<'ast, T> { fold_function(self, f) } fn fold_declaration_parameter( &mut self, - p: typed_absy::DeclarationParameter<'ast, T>, + p: typed::DeclarationParameter<'ast, T>, ) -> Vec> { let private = p.private; - self.fold_variable(crate::typed_absy::variable::try_from_g_variable(p.id).unwrap()) + self.fold_variable(zokrates_ast::typed::variable::try_from_g_variable(p.id).unwrap()) .into_iter() .map(|v| zir::Parameter { id: v, private }) .collect() } - fn fold_name(&mut self, n: typed_absy::Identifier<'ast>) -> zir::SourceIdentifier<'ast> { + fn fold_name(&mut self, n: typed::Identifier<'ast>) -> zir::SourceIdentifier<'ast> { zir::SourceIdentifier::Basic(n) } - fn fold_variable(&mut self, v: typed_absy::Variable<'ast, T>) -> Vec> { + fn fold_variable(&mut self, v: typed::Variable<'ast, T>) -> Vec> { let ty = v.get_type(); let id = self.fold_name(v.id); - let ty = typed_absy::types::ConcreteType::try_from(ty).unwrap(); + let ty = typed::types::ConcreteType::try_from(ty).unwrap(); flatten_identifier_rec(id, &ty) } - fn fold_assignee( - &mut self, - a: typed_absy::TypedAssignee<'ast, T>, - ) -> Vec> { + fn fold_assignee(&mut self, a: typed::TypedAssignee<'ast, T>) -> Vec> { match a { - typed_absy::TypedAssignee::Identifier(v) => self.fold_variable(v), - typed_absy::TypedAssignee::Select(box a, box i) => { - use typed_absy::Typed; - let count = match typed_absy::ConcreteType::try_from(a.get_type()).unwrap() { - typed_absy::ConcreteType::Array(array_ty) => array_ty.ty.get_primitive_count(), + typed::TypedAssignee::Identifier(v) => self.fold_variable(v), + typed::TypedAssignee::Select(box a, box i) => { + use typed::Typed; + let count = match typed::ConcreteType::try_from(a.get_type()).unwrap() { + typed::ConcreteType::Array(array_ty) => array_ty.ty.get_primitive_count(), _ => unreachable!(), }; let a = self.fold_assignee(a); match i.as_inner() { - typed_absy::UExpressionInner::Value(index) => { + typed::UExpressionInner::Value(index) => { a[*index as usize * count..(*index as usize + 1) * count].to_vec() } i => unreachable!("index {:?} not allowed, should be a constant", i), } } - typed_absy::TypedAssignee::Member(box a, m) => { - use typed_absy::Typed; + typed::TypedAssignee::Member(box a, m) => { + use typed::Typed; - let (offset, size) = match typed_absy::ConcreteType::try_from(a.get_type()).unwrap() - { - typed_absy::ConcreteType::Struct(struct_type) => struct_type - .members - .iter() - .fold((0, None), |(offset, size), member| match size { - Some(_) => (offset, size), - None => match m == member.id { - true => (offset, Some(member.ty.get_primitive_count())), - false => (offset + member.ty.get_primitive_count(), None), - }, - }), - _ => unreachable!(), - }; + let (offset, size) = + match typed::ConcreteType::try_from(a.get_type()).unwrap() { + typed::ConcreteType::Struct(struct_type) => struct_type + .members + .iter() + .fold((0, None), |(offset, size), member| match size { + Some(_) => (offset, size), + None => match m == member.id { + true => (offset, Some(member.ty.get_primitive_count())), + false => (offset + member.ty.get_primitive_count(), None), + }, + }), + _ => unreachable!(), + }; let size = size.unwrap(); @@ -211,11 +205,11 @@ impl<'ast, T: Field> Flattener { a[offset..offset + size].to_vec() } - typed_absy::TypedAssignee::Element(box a, index) => { - use typed_absy::Typed; + typed::TypedAssignee::Element(box a, index) => { + use typed::Typed; - let tuple_ty = typed_absy::ConcreteTupleType::try_from( - typed_absy::ConcreteType::try_from(a.get_type()).unwrap(), + let tuple_ty = typed::ConcreteTupleType::try_from( + typed::ConcreteType::try_from(a.get_type()).unwrap(), ) .unwrap(); @@ -238,7 +232,7 @@ impl<'ast, T: Field> Flattener { fn fold_statement( &mut self, statements_buffer: &mut Vec>, - s: typed_absy::TypedStatement<'ast, T>, + s: typed::TypedStatement<'ast, T>, ) { fold_statement(self, statements_buffer, s) } @@ -246,13 +240,13 @@ impl<'ast, T: Field> Flattener { fn fold_expression_or_spread( &mut self, statements_buffer: &mut Vec>, - e: typed_absy::TypedExpressionOrSpread<'ast, T>, + e: typed::TypedExpressionOrSpread<'ast, T>, ) -> Vec> { match e { - typed_absy::TypedExpressionOrSpread::Expression(e) => { + typed::TypedExpressionOrSpread::Expression(e) => { self.fold_expression(statements_buffer, e) } - typed_absy::TypedExpressionOrSpread::Spread(s) => { + typed::TypedExpressionOrSpread::Spread(s) => { self.fold_array_expression(statements_buffer, s.array) } } @@ -261,35 +255,29 @@ impl<'ast, T: Field> Flattener { fn fold_expression( &mut self, statements_buffer: &mut Vec>, - e: typed_absy::TypedExpression<'ast, T>, + e: typed::TypedExpression<'ast, T>, ) -> Vec> { match e { - typed_absy::TypedExpression::FieldElement(e) => { + typed::TypedExpression::FieldElement(e) => { vec![self.fold_field_expression(statements_buffer, e).into()] } - typed_absy::TypedExpression::Boolean(e) => { + typed::TypedExpression::Boolean(e) => { vec![self.fold_boolean_expression(statements_buffer, e).into()] } - typed_absy::TypedExpression::Uint(e) => { + typed::TypedExpression::Uint(e) => { vec![self.fold_uint_expression(statements_buffer, e).into()] } - typed_absy::TypedExpression::Array(e) => { - self.fold_array_expression(statements_buffer, e) - } - typed_absy::TypedExpression::Struct(e) => { - self.fold_struct_expression(statements_buffer, e) - } - typed_absy::TypedExpression::Tuple(e) => { - self.fold_tuple_expression(statements_buffer, e) - } - typed_absy::TypedExpression::Int(_) => unreachable!(), + typed::TypedExpression::Array(e) => self.fold_array_expression(statements_buffer, e), + typed::TypedExpression::Struct(e) => self.fold_struct_expression(statements_buffer, e), + typed::TypedExpression::Tuple(e) => self.fold_tuple_expression(statements_buffer, e), + typed::TypedExpression::Int(_) => unreachable!(), } } fn fold_array_expression( &mut self, statements_buffer: &mut Vec>, - e: typed_absy::ArrayExpression<'ast, T>, + e: typed::ArrayExpression<'ast, T>, ) -> Vec> { fold_array_expression(self, statements_buffer, e) } @@ -297,7 +285,7 @@ impl<'ast, T: Field> Flattener { fn fold_struct_expression( &mut self, statements_buffer: &mut Vec>, - e: typed_absy::StructExpression<'ast, T>, + e: typed::StructExpression<'ast, T>, ) -> Vec> { fold_struct_expression(self, statements_buffer, e) } @@ -305,7 +293,7 @@ impl<'ast, T: Field> Flattener { fn fold_tuple_expression( &mut self, statements_buffer: &mut Vec>, - e: typed_absy::TupleExpression<'ast, T>, + e: typed::TupleExpression<'ast, T>, ) -> Vec> { fold_tuple_expression(self, statements_buffer, e) } @@ -313,10 +301,10 @@ impl<'ast, T: Field> Flattener { fn fold_expression_list( &mut self, statements_buffer: &mut Vec>, - es: typed_absy::TypedExpressionList<'ast, T>, + es: typed::TypedExpressionList<'ast, T>, ) -> zir::ZirExpressionList<'ast, T> { match es.into_inner() { - typed_absy::TypedExpressionListInner::EmbedCall(embed, generics, arguments) => { + typed::TypedExpressionListInner::EmbedCall(embed, generics, arguments) => { zir::ZirExpressionList::EmbedCall( embed, generics, @@ -333,7 +321,7 @@ impl<'ast, T: Field> Flattener { fn fold_conditional_expression>( &mut self, statements_buffer: &mut Vec>, - c: typed_absy::ConditionalExpression<'ast, T, E>, + c: typed::ConditionalExpression<'ast, T, E>, ) -> Vec> { fold_conditional_expression(self, statements_buffer, c) } @@ -341,7 +329,7 @@ impl<'ast, T: Field> Flattener { fn fold_member_expression( &mut self, statements_buffer: &mut Vec>, - m: typed_absy::MemberExpression<'ast, T, E>, + m: typed::MemberExpression<'ast, T, E>, ) -> Vec> { fold_member_expression(self, statements_buffer, m) } @@ -349,7 +337,7 @@ impl<'ast, T: Field> Flattener { fn fold_element_expression( &mut self, statements_buffer: &mut Vec>, - e: typed_absy::ElementExpression<'ast, T, E>, + e: typed::ElementExpression<'ast, T, E>, ) -> Vec> { fold_element_expression(self, statements_buffer, e) } @@ -357,7 +345,7 @@ impl<'ast, T: Field> Flattener { fn fold_select_expression( &mut self, statements_buffer: &mut Vec>, - select: typed_absy::SelectExpression<'ast, T, E>, + select: typed::SelectExpression<'ast, T, E>, ) -> Vec> { fold_select_expression(self, statements_buffer, select) } @@ -365,7 +353,7 @@ impl<'ast, T: Field> Flattener { fn fold_eq_expression>( &mut self, statements_buffer: &mut Vec>, - eq: typed_absy::EqExpression, + eq: typed::EqExpression, ) -> zir::BooleanExpression<'ast, T> { fold_eq_expression(self, statements_buffer, eq) } @@ -373,21 +361,21 @@ impl<'ast, T: Field> Flattener { fn fold_field_expression( &mut self, statements_buffer: &mut Vec>, - e: typed_absy::FieldElementExpression<'ast, T>, + e: typed::FieldElementExpression<'ast, T>, ) -> zir::FieldElementExpression<'ast, T> { fold_field_expression(self, statements_buffer, e) } fn fold_boolean_expression( &mut self, statements_buffer: &mut Vec>, - e: typed_absy::BooleanExpression<'ast, T>, + e: typed::BooleanExpression<'ast, T>, ) -> zir::BooleanExpression<'ast, T> { fold_boolean_expression(self, statements_buffer, e) } fn fold_uint_expression( &mut self, statements_buffer: &mut Vec>, - e: typed_absy::UExpression<'ast, T>, + e: typed::UExpression<'ast, T>, ) -> zir::UExpression<'ast, T> { fold_uint_expression(self, statements_buffer, e) } @@ -396,7 +384,7 @@ impl<'ast, T: Field> Flattener { &mut self, statements_buffer: &mut Vec>, bitwidth: UBitwidth, - e: typed_absy::UExpressionInner<'ast, T>, + e: typed::UExpressionInner<'ast, T>, ) -> zir::UExpressionInner<'ast, T> { fold_uint_expression_inner(self, statements_buffer, bitwidth, e) } @@ -404,9 +392,9 @@ impl<'ast, T: Field> Flattener { fn fold_array_expression_inner( &mut self, statements_buffer: &mut Vec>, - ty: &typed_absy::types::ConcreteType, + ty: &typed::types::ConcreteType, size: u32, - e: typed_absy::ArrayExpressionInner<'ast, T>, + e: typed::ArrayExpressionInner<'ast, T>, ) -> Vec> { fold_array_expression_inner(self, statements_buffer, ty, size, e) } @@ -414,8 +402,8 @@ impl<'ast, T: Field> Flattener { fn fold_struct_expression_inner( &mut self, statements_buffer: &mut Vec>, - ty: &typed_absy::types::ConcreteStructType, - e: typed_absy::StructExpressionInner<'ast, T>, + ty: &typed::types::ConcreteStructType, + e: typed::StructExpressionInner<'ast, T>, ) -> Vec> { fold_struct_expression_inner(self, statements_buffer, ty, e) } @@ -423,8 +411,8 @@ impl<'ast, T: Field> Flattener { fn fold_tuple_expression_inner( &mut self, statements_buffer: &mut Vec>, - ty: &typed_absy::types::ConcreteTupleType, - e: typed_absy::TupleExpressionInner<'ast, T>, + ty: &typed::types::ConcreteTupleType, + e: typed::TupleExpressionInner<'ast, T>, ) -> Vec> { fold_tuple_expression_inner(self, statements_buffer, ty, e) } @@ -433,16 +421,16 @@ impl<'ast, T: Field> Flattener { fn fold_statement<'ast, T: Field>( f: &mut Flattener, statements_buffer: &mut Vec>, - s: typed_absy::TypedStatement<'ast, T>, + s: typed::TypedStatement<'ast, T>, ) { let res = match s { - typed_absy::TypedStatement::Return(expressions) => vec![zir::ZirStatement::Return( + typed::TypedStatement::Return(expressions) => vec![zir::ZirStatement::Return( expressions .into_iter() .flat_map(|e| f.fold_expression(statements_buffer, e)) .collect(), )], - typed_absy::TypedStatement::Definition(a, e) => { + typed::TypedStatement::Definition(a, e) => { let a = f.fold_assignee(a); let e = f.fold_expression(statements_buffer, e); assert_eq!(a.len(), e.len()); @@ -451,21 +439,21 @@ fn fold_statement<'ast, T: Field>( .map(|(a, e)| zir::ZirStatement::Definition(a, e)) .collect() } - typed_absy::TypedStatement::Declaration(..) => { + typed::TypedStatement::Declaration(..) => { unreachable!() } - typed_absy::TypedStatement::Assertion(e, error) => { + typed::TypedStatement::Assertion(e, error) => { let e = f.fold_boolean_expression(statements_buffer, e); let error = match error { - typed_absy::RuntimeError::SourceAssertion(metadata) => { + typed::RuntimeError::SourceAssertion(metadata) => { zir::RuntimeError::SourceAssertion(metadata.to_string()) } - typed_absy::RuntimeError::SelectRangeCheck => zir::RuntimeError::SelectRangeCheck, + typed::RuntimeError::SelectRangeCheck => zir::RuntimeError::SelectRangeCheck, }; vec![zir::ZirStatement::Assertion(e, error)] } - typed_absy::TypedStatement::For(..) => unreachable!(), - typed_absy::TypedStatement::MultipleDefinition(variables, elist) => { + typed::TypedStatement::For(..) => unreachable!(), + typed::TypedStatement::MultipleDefinition(variables, elist) => { vec![zir::ZirStatement::MultipleDefinition( variables .into_iter() @@ -474,8 +462,8 @@ fn fold_statement<'ast, T: Field>( f.fold_expression_list(statements_buffer, elist), )] } - typed_absy::TypedStatement::PushCallLog(..) => vec![], - typed_absy::TypedStatement::PopCallLog => vec![], + typed::TypedStatement::PushCallLog(..) => vec![], + typed::TypedStatement::PopCallLog => vec![], }; statements_buffer.extend(res); @@ -484,22 +472,22 @@ fn fold_statement<'ast, T: Field>( fn fold_array_expression_inner<'ast, T: Field>( f: &mut Flattener, statements_buffer: &mut Vec>, - ty: &typed_absy::types::ConcreteType, + ty: &typed::types::ConcreteType, size: u32, - array: typed_absy::ArrayExpressionInner<'ast, T>, + array: typed::ArrayExpressionInner<'ast, T>, ) -> Vec> { match array { - typed_absy::ArrayExpressionInner::Block(block) => { + typed::ArrayExpressionInner::Block(block) => { block .statements .into_iter() .for_each(|s| f.fold_statement(statements_buffer, s)); f.fold_array_expression(statements_buffer, *block.value) } - typed_absy::ArrayExpressionInner::Identifier(id) => { + typed::ArrayExpressionInner::Identifier(id) => { let variables = flatten_identifier_rec( f.fold_name(id), - &typed_absy::types::ConcreteType::array((ty.clone(), size)), + &typed::types::ConcreteType::array((ty.clone(), size)), ); variables .into_iter() @@ -512,7 +500,7 @@ fn fold_array_expression_inner<'ast, T: Field>( }) .collect() } - typed_absy::ArrayExpressionInner::Value(exprs) => { + typed::ArrayExpressionInner::Value(exprs) => { let exprs: Vec<_> = exprs .into_iter() .flat_map(|e| f.fold_expression_or_spread(statements_buffer, e)) @@ -522,17 +510,15 @@ fn fold_array_expression_inner<'ast, T: Field>( exprs } - typed_absy::ArrayExpressionInner::FunctionCall(..) => unreachable!(), - typed_absy::ArrayExpressionInner::Conditional(c) => { + typed::ArrayExpressionInner::FunctionCall(..) => unreachable!(), + typed::ArrayExpressionInner::Conditional(c) => { f.fold_conditional_expression(statements_buffer, c) } - typed_absy::ArrayExpressionInner::Member(m) => { - f.fold_member_expression(statements_buffer, m) - } - typed_absy::ArrayExpressionInner::Select(select) => { + typed::ArrayExpressionInner::Member(m) => f.fold_member_expression(statements_buffer, m), + typed::ArrayExpressionInner::Select(select) => { f.fold_select_expression(statements_buffer, select) } - typed_absy::ArrayExpressionInner::Slice(box array, box from, box to) => { + typed::ArrayExpressionInner::Slice(box array, box from, box to) => { let array = f.fold_array_expression(statements_buffer, array); let from = f.fold_uint_expression(statements_buffer, from); let to = f.fold_uint_expression(statements_buffer, to); @@ -549,7 +535,7 @@ fn fold_array_expression_inner<'ast, T: Field>( _ => unreachable!(), } } - typed_absy::ArrayExpressionInner::Repeat(box e, box count) => { + typed::ArrayExpressionInner::Repeat(box e, box count) => { let e = f.fold_expression(statements_buffer, e); let count = f.fold_uint_expression(statements_buffer, count); @@ -560,7 +546,7 @@ fn fold_array_expression_inner<'ast, T: Field>( _ => unreachable!(), } } - typed_absy::ArrayExpressionInner::Element(element) => { + typed::ArrayExpressionInner::Element(element) => { f.fold_element_expression(statements_buffer, element) } } @@ -569,21 +555,21 @@ fn fold_array_expression_inner<'ast, T: Field>( fn fold_struct_expression_inner<'ast, T: Field>( f: &mut Flattener, statements_buffer: &mut Vec>, - ty: &typed_absy::types::ConcreteStructType, - struc: typed_absy::StructExpressionInner<'ast, T>, + ty: &typed::types::ConcreteStructType, + struc: typed::StructExpressionInner<'ast, T>, ) -> Vec> { match struc { - typed_absy::StructExpressionInner::Block(block) => { + typed::StructExpressionInner::Block(block) => { block .statements .into_iter() .for_each(|s| f.fold_statement(statements_buffer, s)); f.fold_struct_expression(statements_buffer, *block.value) } - typed_absy::StructExpressionInner::Identifier(id) => { + typed::StructExpressionInner::Identifier(id) => { let variables = flatten_identifier_rec( f.fold_name(id), - &typed_absy::types::ConcreteType::struc(ty.clone()), + &typed::types::ConcreteType::struc(ty.clone()), ); variables .into_iter() @@ -596,21 +582,19 @@ fn fold_struct_expression_inner<'ast, T: Field>( }) .collect() } - typed_absy::StructExpressionInner::Value(exprs) => exprs + typed::StructExpressionInner::Value(exprs) => exprs .into_iter() .flat_map(|e| f.fold_expression(statements_buffer, e)) .collect(), - typed_absy::StructExpressionInner::FunctionCall(..) => unreachable!(), - typed_absy::StructExpressionInner::Conditional(c) => { + typed::StructExpressionInner::FunctionCall(..) => unreachable!(), + typed::StructExpressionInner::Conditional(c) => { f.fold_conditional_expression(statements_buffer, c) } - typed_absy::StructExpressionInner::Member(m) => { - f.fold_member_expression(statements_buffer, m) - } - typed_absy::StructExpressionInner::Select(select) => { + typed::StructExpressionInner::Member(m) => f.fold_member_expression(statements_buffer, m), + typed::StructExpressionInner::Select(select) => { f.fold_select_expression(statements_buffer, select) } - typed_absy::StructExpressionInner::Element(element) => { + typed::StructExpressionInner::Element(element) => { f.fold_element_expression(statements_buffer, element) } } @@ -619,21 +603,21 @@ fn fold_struct_expression_inner<'ast, T: Field>( fn fold_tuple_expression_inner<'ast, T: Field>( f: &mut Flattener, statements_buffer: &mut Vec>, - ty: &typed_absy::types::ConcreteTupleType, - tuple: typed_absy::TupleExpressionInner<'ast, T>, + ty: &typed::types::ConcreteTupleType, + tuple: typed::TupleExpressionInner<'ast, T>, ) -> Vec> { match tuple { - typed_absy::TupleExpressionInner::Block(block) => { + typed::TupleExpressionInner::Block(block) => { block .statements .into_iter() .for_each(|s| f.fold_statement(statements_buffer, s)); f.fold_tuple_expression(statements_buffer, *block.value) } - typed_absy::TupleExpressionInner::Identifier(id) => { + typed::TupleExpressionInner::Identifier(id) => { let variables = flatten_identifier_rec( f.fold_name(id), - &typed_absy::types::ConcreteType::tuple(ty.clone()), + &typed::types::ConcreteType::tuple(ty.clone()), ); variables .into_iter() @@ -646,21 +630,19 @@ fn fold_tuple_expression_inner<'ast, T: Field>( }) .collect() } - typed_absy::TupleExpressionInner::Value(exprs) => exprs + typed::TupleExpressionInner::Value(exprs) => exprs .into_iter() .flat_map(|e| f.fold_expression(statements_buffer, e)) .collect(), - typed_absy::TupleExpressionInner::FunctionCall(..) => unreachable!(), - typed_absy::TupleExpressionInner::Conditional(c) => { + typed::TupleExpressionInner::FunctionCall(..) => unreachable!(), + typed::TupleExpressionInner::Conditional(c) => { f.fold_conditional_expression(statements_buffer, c) } - typed_absy::TupleExpressionInner::Member(m) => { - f.fold_member_expression(statements_buffer, m) - } - typed_absy::TupleExpressionInner::Select(select) => { + typed::TupleExpressionInner::Member(m) => f.fold_member_expression(statements_buffer, m), + typed::TupleExpressionInner::Select(select) => { f.fold_select_expression(statements_buffer, select) } - typed_absy::TupleExpressionInner::Element(element) => { + typed::TupleExpressionInner::Element(element) => { f.fold_element_expression(statements_buffer, element) } } @@ -669,14 +651,14 @@ fn fold_tuple_expression_inner<'ast, T: Field>( fn fold_member_expression<'ast, T: Field, E>( f: &mut Flattener, statements_buffer: &mut Vec>, - m: typed_absy::MemberExpression<'ast, T, E>, + m: typed::MemberExpression<'ast, T, E>, ) -> Vec> { let s = *m.struc; let id = m.id; let members = s.ty(); - let size = typed_absy::types::ConcreteType::try_from( + let size = typed::types::ConcreteType::try_from( *members .iter() .find(|member| member.id == id) @@ -691,7 +673,7 @@ fn fold_member_expression<'ast, T: Field, E>( .iter() .take_while(|member| member.id != id) .map(|member| { - typed_absy::types::ConcreteType::try_from(*member.ty.clone()) + typed::types::ConcreteType::try_from(*member.ty.clone()) .unwrap() .get_primitive_count() }) @@ -705,14 +687,14 @@ fn fold_member_expression<'ast, T: Field, E>( fn fold_element_expression<'ast, T: Field, E>( f: &mut Flattener, statements_buffer: &mut Vec>, - e: typed_absy::ElementExpression<'ast, T, E>, + e: typed::ElementExpression<'ast, T, E>, ) -> Vec> { let t = *e.tuple; let id = e.index; let tuple_ty = t.ty(); - let size = typed_absy::types::ConcreteType::try_from( + let size = typed::types::ConcreteType::try_from( tuple_ty .elements .iter() @@ -730,7 +712,7 @@ fn fold_element_expression<'ast, T: Field, E>( .iter() .take(id as usize) .map(|ty| { - typed_absy::types::ConcreteType::try_from(ty.clone()) + typed::types::ConcreteType::try_from(ty.clone()) .unwrap() .get_primitive_count() }) @@ -744,9 +726,9 @@ fn fold_element_expression<'ast, T: Field, E>( fn fold_select_expression<'ast, T: Field, E>( f: &mut Flattener, statements_buffer: &mut Vec>, - select: typed_absy::SelectExpression<'ast, T, E>, + select: typed::SelectExpression<'ast, T, E>, ) -> Vec> { - let size = typed_absy::types::ConcreteType::try_from(*select.array.ty().clone().ty) + let size = typed::types::ConcreteType::try_from(*select.array.ty().clone().ty) .unwrap() .get_primitive_count(); @@ -774,7 +756,7 @@ fn fold_select_expression<'ast, T: Field, E>( }) .into_iter() .map(|a| { - use crate::zir::Typed; + use zokrates_ast::zir::Typed; let ty = a[0].get_type(); @@ -819,7 +801,7 @@ fn fold_select_expression<'ast, T: Field, E>( fn fold_conditional_expression<'ast, T: Field, E: Flatten<'ast, T>>( f: &mut Flattener, statements_buffer: &mut Vec>, - c: typed_absy::ConditionalExpression<'ast, T, E>, + c: typed::ConditionalExpression<'ast, T, E>, ) -> Vec> { let mut consequence_statements = vec![]; let mut alternative_statements = vec![]; @@ -838,7 +820,7 @@ fn fold_conditional_expression<'ast, T: Field, E: Flatten<'ast, T>>( )); } - use crate::zir::IfElse; + use zokrates_ast::zir::IfElse; consequence .into_iter() @@ -861,47 +843,42 @@ fn fold_conditional_expression<'ast, T: Field, E: Flatten<'ast, T>>( fn fold_field_expression<'ast, T: Field>( f: &mut Flattener, statements_buffer: &mut Vec>, - e: typed_absy::FieldElementExpression<'ast, T>, + e: typed::FieldElementExpression<'ast, T>, ) -> zir::FieldElementExpression<'ast, T> { match e { - typed_absy::FieldElementExpression::Number(n) => zir::FieldElementExpression::Number(n), - typed_absy::FieldElementExpression::Identifier(id) => { - zir::FieldElementExpression::Identifier( - flatten_identifier_rec( - f.fold_name(id), - &typed_absy::types::ConcreteType::FieldElement, - ) + typed::FieldElementExpression::Number(n) => zir::FieldElementExpression::Number(n), + typed::FieldElementExpression::Identifier(id) => zir::FieldElementExpression::Identifier( + flatten_identifier_rec(f.fold_name(id), &typed::types::ConcreteType::FieldElement) .pop() .unwrap() .id, - ) - } - typed_absy::FieldElementExpression::Add(box e1, box e2) => { + ), + typed::FieldElementExpression::Add(box e1, box e2) => { let e1 = f.fold_field_expression(statements_buffer, e1); let e2 = f.fold_field_expression(statements_buffer, e2); zir::FieldElementExpression::Add(box e1, box e2) } - typed_absy::FieldElementExpression::Sub(box e1, box e2) => { + typed::FieldElementExpression::Sub(box e1, box e2) => { let e1 = f.fold_field_expression(statements_buffer, e1); let e2 = f.fold_field_expression(statements_buffer, e2); zir::FieldElementExpression::Sub(box e1, box e2) } - typed_absy::FieldElementExpression::Mult(box e1, box e2) => { + typed::FieldElementExpression::Mult(box e1, box e2) => { let e1 = f.fold_field_expression(statements_buffer, e1); let e2 = f.fold_field_expression(statements_buffer, e2); zir::FieldElementExpression::Mult(box e1, box e2) } - typed_absy::FieldElementExpression::Div(box e1, box e2) => { + typed::FieldElementExpression::Div(box e1, box e2) => { let e1 = f.fold_field_expression(statements_buffer, e1); let e2 = f.fold_field_expression(statements_buffer, e2); zir::FieldElementExpression::Div(box e1, box e2) } - typed_absy::FieldElementExpression::Pow(box e1, box e2) => { + typed::FieldElementExpression::Pow(box e1, box e2) => { let e1 = f.fold_field_expression(statements_buffer, e1); let e2 = f.fold_uint_expression(statements_buffer, e2); zir::FieldElementExpression::Pow(box e1, box e2) } - typed_absy::FieldElementExpression::Neg(box e) => { + typed::FieldElementExpression::Neg(box e) => { let e = f.fold_field_expression(statements_buffer, e); zir::FieldElementExpression::Sub( @@ -909,35 +886,33 @@ fn fold_field_expression<'ast, T: Field>( box e, ) } - typed_absy::FieldElementExpression::Pos(box e) => { - f.fold_field_expression(statements_buffer, e) - } - typed_absy::FieldElementExpression::Conditional(c) => f + typed::FieldElementExpression::Pos(box e) => f.fold_field_expression(statements_buffer, e), + typed::FieldElementExpression::Conditional(c) => f .fold_conditional_expression(statements_buffer, c) .pop() .unwrap() .try_into() .unwrap(), - typed_absy::FieldElementExpression::FunctionCall(..) => unreachable!(""), - typed_absy::FieldElementExpression::Select(select) => f + typed::FieldElementExpression::FunctionCall(..) => unreachable!(""), + typed::FieldElementExpression::Select(select) => f .fold_select_expression(statements_buffer, select) .pop() .unwrap() .try_into() .unwrap(), - typed_absy::FieldElementExpression::Member(m) => f + typed::FieldElementExpression::Member(m) => f .fold_member_expression(statements_buffer, m) .pop() .unwrap() .try_into() .unwrap(), - typed_absy::FieldElementExpression::Element(element) => f + typed::FieldElementExpression::Element(element) => f .fold_element_expression(statements_buffer, element) .pop() .unwrap() .try_into() .unwrap(), - typed_absy::FieldElementExpression::Block(block) => { + typed::FieldElementExpression::Block(block) => { block .statements .into_iter() @@ -981,7 +956,7 @@ fn conjunction_tree<'ast, T: Field>( fn fold_eq_expression<'ast, T: Field, E: Flatten<'ast, T>>( f: &mut Flattener, statements_buffer: &mut Vec>, - e: typed_absy::EqExpression, + e: typed::EqExpression, ) -> zir::BooleanExpression<'ast, T> { let left = e.left.flatten(f, statements_buffer); let right = e.right.flatten(f, statements_buffer); @@ -991,103 +966,103 @@ fn fold_eq_expression<'ast, T: Field, E: Flatten<'ast, T>>( fn fold_boolean_expression<'ast, T: Field>( f: &mut Flattener, statements_buffer: &mut Vec>, - e: typed_absy::BooleanExpression<'ast, T>, + e: typed::BooleanExpression<'ast, T>, ) -> zir::BooleanExpression<'ast, T> { match e { - typed_absy::BooleanExpression::Block(block) => { + typed::BooleanExpression::Block(block) => { block .statements .into_iter() .for_each(|s| f.fold_statement(statements_buffer, s)); f.fold_boolean_expression(statements_buffer, *block.value) } - typed_absy::BooleanExpression::Value(v) => zir::BooleanExpression::Value(v), - typed_absy::BooleanExpression::Identifier(id) => zir::BooleanExpression::Identifier( - flatten_identifier_rec(f.fold_name(id), &typed_absy::types::ConcreteType::Boolean) + typed::BooleanExpression::Value(v) => zir::BooleanExpression::Value(v), + typed::BooleanExpression::Identifier(id) => zir::BooleanExpression::Identifier( + flatten_identifier_rec(f.fold_name(id), &typed::types::ConcreteType::Boolean) .pop() .unwrap() .id, ), - typed_absy::BooleanExpression::FieldEq(e) => f.fold_eq_expression(statements_buffer, e), - typed_absy::BooleanExpression::BoolEq(e) => f.fold_eq_expression(statements_buffer, e), - typed_absy::BooleanExpression::ArrayEq(e) => f.fold_eq_expression(statements_buffer, e), - typed_absy::BooleanExpression::StructEq(e) => f.fold_eq_expression(statements_buffer, e), - typed_absy::BooleanExpression::TupleEq(e) => f.fold_eq_expression(statements_buffer, e), - typed_absy::BooleanExpression::UintEq(e) => f.fold_eq_expression(statements_buffer, e), - typed_absy::BooleanExpression::FieldLt(box e1, box e2) => { + typed::BooleanExpression::FieldEq(e) => f.fold_eq_expression(statements_buffer, e), + typed::BooleanExpression::BoolEq(e) => f.fold_eq_expression(statements_buffer, e), + typed::BooleanExpression::ArrayEq(e) => f.fold_eq_expression(statements_buffer, e), + typed::BooleanExpression::StructEq(e) => f.fold_eq_expression(statements_buffer, e), + typed::BooleanExpression::TupleEq(e) => f.fold_eq_expression(statements_buffer, e), + typed::BooleanExpression::UintEq(e) => f.fold_eq_expression(statements_buffer, e), + typed::BooleanExpression::FieldLt(box e1, box e2) => { let e1 = f.fold_field_expression(statements_buffer, e1); let e2 = f.fold_field_expression(statements_buffer, e2); zir::BooleanExpression::FieldLt(box e1, box e2) } - typed_absy::BooleanExpression::FieldLe(box e1, box e2) => { + typed::BooleanExpression::FieldLe(box e1, box e2) => { let e1 = f.fold_field_expression(statements_buffer, e1); let e2 = f.fold_field_expression(statements_buffer, e2); zir::BooleanExpression::FieldLe(box e1, box e2) } - typed_absy::BooleanExpression::FieldGt(box e1, box e2) => { + typed::BooleanExpression::FieldGt(box e1, box e2) => { let e1 = f.fold_field_expression(statements_buffer, e1); let e2 = f.fold_field_expression(statements_buffer, e2); zir::BooleanExpression::FieldGt(box e1, box e2) } - typed_absy::BooleanExpression::FieldGe(box e1, box e2) => { + typed::BooleanExpression::FieldGe(box e1, box e2) => { let e1 = f.fold_field_expression(statements_buffer, e1); let e2 = f.fold_field_expression(statements_buffer, e2); zir::BooleanExpression::FieldGe(box e1, box e2) } - typed_absy::BooleanExpression::UintLt(box e1, box e2) => { + typed::BooleanExpression::UintLt(box e1, box e2) => { let e1 = f.fold_uint_expression(statements_buffer, e1); let e2 = f.fold_uint_expression(statements_buffer, e2); zir::BooleanExpression::UintLt(box e1, box e2) } - typed_absy::BooleanExpression::UintLe(box e1, box e2) => { + typed::BooleanExpression::UintLe(box e1, box e2) => { let e1 = f.fold_uint_expression(statements_buffer, e1); let e2 = f.fold_uint_expression(statements_buffer, e2); zir::BooleanExpression::UintLe(box e1, box e2) } - typed_absy::BooleanExpression::UintGt(box e1, box e2) => { + typed::BooleanExpression::UintGt(box e1, box e2) => { let e1 = f.fold_uint_expression(statements_buffer, e1); let e2 = f.fold_uint_expression(statements_buffer, e2); zir::BooleanExpression::UintGt(box e1, box e2) } - typed_absy::BooleanExpression::UintGe(box e1, box e2) => { + typed::BooleanExpression::UintGe(box e1, box e2) => { let e1 = f.fold_uint_expression(statements_buffer, e1); let e2 = f.fold_uint_expression(statements_buffer, e2); zir::BooleanExpression::UintGe(box e1, box e2) } - typed_absy::BooleanExpression::Or(box e1, box e2) => { + typed::BooleanExpression::Or(box e1, box e2) => { let e1 = f.fold_boolean_expression(statements_buffer, e1); let e2 = f.fold_boolean_expression(statements_buffer, e2); zir::BooleanExpression::Or(box e1, box e2) } - typed_absy::BooleanExpression::And(box e1, box e2) => { + typed::BooleanExpression::And(box e1, box e2) => { let e1 = f.fold_boolean_expression(statements_buffer, e1); let e2 = f.fold_boolean_expression(statements_buffer, e2); zir::BooleanExpression::And(box e1, box e2) } - typed_absy::BooleanExpression::Not(box e) => { + typed::BooleanExpression::Not(box e) => { let e = f.fold_boolean_expression(statements_buffer, e); zir::BooleanExpression::Not(box e) } - typed_absy::BooleanExpression::Conditional(c) => f + typed::BooleanExpression::Conditional(c) => f .fold_conditional_expression(statements_buffer, c) .pop() .unwrap() .try_into() .unwrap(), - typed_absy::BooleanExpression::FunctionCall(..) => unreachable!(), - typed_absy::BooleanExpression::Select(select) => f + typed::BooleanExpression::FunctionCall(..) => unreachable!(), + typed::BooleanExpression::Select(select) => f .fold_select_expression(statements_buffer, select) .pop() .unwrap() .try_into() .unwrap(), - typed_absy::BooleanExpression::Member(m) => f + typed::BooleanExpression::Member(m) => f .fold_member_expression(statements_buffer, m) .pop() .unwrap() .try_into() .unwrap(), - typed_absy::BooleanExpression::Element(m) => f + typed::BooleanExpression::Element(m) => f .fold_element_expression(statements_buffer, m) .pop() .unwrap() @@ -1099,7 +1074,7 @@ fn fold_boolean_expression<'ast, T: Field>( fn fold_uint_expression<'ast, T: Field>( f: &mut Flattener, statements_buffer: &mut Vec>, - e: typed_absy::UExpression<'ast, T>, + e: typed::UExpression<'ast, T>, ) -> zir::UExpression<'ast, T> { f.fold_uint_expression_inner(statements_buffer, e.bitwidth, e.inner) .annotate(e.bitwidth.to_usize()) @@ -1109,10 +1084,10 @@ fn fold_uint_expression_inner<'ast, T: Field>( f: &mut Flattener, statements_buffer: &mut Vec>, bitwidth: UBitwidth, - e: typed_absy::UExpressionInner<'ast, T>, + e: typed::UExpressionInner<'ast, T>, ) -> zir::UExpressionInner<'ast, T> { match e { - typed_absy::UExpressionInner::Block(block) => { + typed::UExpressionInner::Block(block) => { block .statements .into_iter() @@ -1120,130 +1095,127 @@ fn fold_uint_expression_inner<'ast, T: Field>( f.fold_uint_expression(statements_buffer, *block.value) .into_inner() } - typed_absy::UExpressionInner::Value(v) => zir::UExpressionInner::Value(v), - typed_absy::UExpressionInner::Identifier(id) => zir::UExpressionInner::Identifier( - flatten_identifier_rec( - f.fold_name(id), - &typed_absy::types::ConcreteType::Uint(bitwidth), - ) - .pop() - .unwrap() - .id, + typed::UExpressionInner::Value(v) => zir::UExpressionInner::Value(v), + typed::UExpressionInner::Identifier(id) => zir::UExpressionInner::Identifier( + flatten_identifier_rec(f.fold_name(id), &typed::types::ConcreteType::Uint(bitwidth)) + .pop() + .unwrap() + .id, ), - typed_absy::UExpressionInner::Add(box left, box right) => { + typed::UExpressionInner::Add(box left, box right) => { let left = f.fold_uint_expression(statements_buffer, left); let right = f.fold_uint_expression(statements_buffer, right); zir::UExpressionInner::Add(box left, box right) } - typed_absy::UExpressionInner::Sub(box left, box right) => { + typed::UExpressionInner::Sub(box left, box right) => { let left = f.fold_uint_expression(statements_buffer, left); let right = f.fold_uint_expression(statements_buffer, right); zir::UExpressionInner::Sub(box left, box right) } - typed_absy::UExpressionInner::FloorSub(..) => unreachable!(), - typed_absy::UExpressionInner::Mult(box left, box right) => { + typed::UExpressionInner::FloorSub(..) => unreachable!(), + typed::UExpressionInner::Mult(box left, box right) => { let left = f.fold_uint_expression(statements_buffer, left); let right = f.fold_uint_expression(statements_buffer, right); zir::UExpressionInner::Mult(box left, box right) } - typed_absy::UExpressionInner::Div(box left, box right) => { + typed::UExpressionInner::Div(box left, box right) => { let left = f.fold_uint_expression(statements_buffer, left); let right = f.fold_uint_expression(statements_buffer, right); zir::UExpressionInner::Div(box left, box right) } - typed_absy::UExpressionInner::Rem(box left, box right) => { + typed::UExpressionInner::Rem(box left, box right) => { let left = f.fold_uint_expression(statements_buffer, left); let right = f.fold_uint_expression(statements_buffer, right); zir::UExpressionInner::Rem(box left, box right) } - typed_absy::UExpressionInner::Xor(box left, box right) => { + typed::UExpressionInner::Xor(box left, box right) => { let left = f.fold_uint_expression(statements_buffer, left); let right = f.fold_uint_expression(statements_buffer, right); zir::UExpressionInner::Xor(box left, box right) } - typed_absy::UExpressionInner::And(box left, box right) => { + typed::UExpressionInner::And(box left, box right) => { let left = f.fold_uint_expression(statements_buffer, left); let right = f.fold_uint_expression(statements_buffer, right); zir::UExpressionInner::And(box left, box right) } - typed_absy::UExpressionInner::Or(box left, box right) => { + typed::UExpressionInner::Or(box left, box right) => { let left = f.fold_uint_expression(statements_buffer, left); let right = f.fold_uint_expression(statements_buffer, right); zir::UExpressionInner::Or(box left, box right) } - typed_absy::UExpressionInner::LeftShift(box e, box by) => { + typed::UExpressionInner::LeftShift(box e, box by) => { let e = f.fold_uint_expression(statements_buffer, e); let by = match by.as_inner() { - typed_absy::UExpressionInner::Value(by) => by, + typed::UExpressionInner::Value(by) => by, _ => unreachable!("static analysis should have made sure that this is constant"), }; zir::UExpressionInner::LeftShift(box e, *by as u32) } - typed_absy::UExpressionInner::RightShift(box e, box by) => { + typed::UExpressionInner::RightShift(box e, box by) => { let e = f.fold_uint_expression(statements_buffer, e); let by = match by.as_inner() { - typed_absy::UExpressionInner::Value(by) => by, + typed::UExpressionInner::Value(by) => by, _ => unreachable!("static analysis should have made sure that this is constant"), }; zir::UExpressionInner::RightShift(box e, *by as u32) } - typed_absy::UExpressionInner::Not(box e) => { + typed::UExpressionInner::Not(box e) => { let e = f.fold_uint_expression(statements_buffer, e); zir::UExpressionInner::Not(box e) } - typed_absy::UExpressionInner::Neg(box e) => { + typed::UExpressionInner::Neg(box e) => { let bitwidth = e.bitwidth(); f.fold_uint_expression( statements_buffer, - typed_absy::UExpressionInner::Value(0).annotate(bitwidth) - e, + typed::UExpressionInner::Value(0).annotate(bitwidth) - e, ) .into_inner() } - typed_absy::UExpressionInner::Pos(box e) => { + typed::UExpressionInner::Pos(box e) => { let e = f.fold_uint_expression(statements_buffer, e); e.into_inner() } - typed_absy::UExpressionInner::FunctionCall(..) => { + typed::UExpressionInner::FunctionCall(..) => { unreachable!("function calls should have been removed") } - typed_absy::UExpressionInner::Select(select) => zir::UExpression::try_from( + typed::UExpressionInner::Select(select) => zir::UExpression::try_from( f.fold_select_expression(statements_buffer, select) .pop() .unwrap(), ) .unwrap() .into_inner(), - typed_absy::UExpressionInner::Member(m) => zir::UExpression::try_from( + typed::UExpressionInner::Member(m) => zir::UExpression::try_from( f.fold_member_expression(statements_buffer, m) .pop() .unwrap(), ) .unwrap() .into_inner(), - typed_absy::UExpressionInner::Element(m) => zir::UExpression::try_from( + typed::UExpressionInner::Element(m) => zir::UExpression::try_from( f.fold_element_expression(statements_buffer, m) .pop() .unwrap(), ) .unwrap() .into_inner(), - typed_absy::UExpressionInner::Conditional(c) => zir::UExpression::try_from( + typed::UExpressionInner::Conditional(c) => zir::UExpression::try_from( f.fold_conditional_expression(statements_buffer, c) .pop() .unwrap(), @@ -1255,7 +1227,7 @@ fn fold_uint_expression_inner<'ast, T: Field>( fn fold_function<'ast, T: Field>( f: &mut Flattener, - fun: typed_absy::TypedFunction<'ast, T>, + fun: typed::TypedFunction<'ast, T>, ) -> zir::ZirFunction<'ast, T> { let mut main_statements_buffer = vec![]; @@ -1270,10 +1242,10 @@ fn fold_function<'ast, T: Field>( .flat_map(|a| f.fold_declaration_parameter(a)) .collect(), statements: main_statements_buffer, - signature: typed_absy::types::ConcreteSignature::try_from( - crate::typed_absy::types::try_from_g_signature::< - crate::typed_absy::types::DeclarationConstant<'ast, T>, - crate::typed_absy::UExpression<'ast, T>, + signature: typed::types::ConcreteSignature::try_from( + zokrates_ast::typed::types::try_from_g_signature::< + zokrates_ast::typed::types::DeclarationConstant<'ast, T>, + zokrates_ast::typed::UExpression<'ast, T>, >(fun.signature) .unwrap(), ) @@ -1285,12 +1257,12 @@ fn fold_function<'ast, T: Field>( fn fold_array_expression<'ast, T: Field>( f: &mut Flattener, statements_buffer: &mut Vec>, - e: typed_absy::ArrayExpression<'ast, T>, + e: typed::ArrayExpression<'ast, T>, ) -> Vec> { let size: u32 = e.size().try_into().unwrap(); f.fold_array_expression_inner( statements_buffer, - &typed_absy::types::ConcreteType::try_from(e.inner_type().clone()).unwrap(), + &typed::types::ConcreteType::try_from(e.inner_type().clone()).unwrap(), size, e.into_inner(), ) @@ -1299,11 +1271,11 @@ fn fold_array_expression<'ast, T: Field>( fn fold_struct_expression<'ast, T: Field>( f: &mut Flattener, statements_buffer: &mut Vec>, - e: typed_absy::StructExpression<'ast, T>, + e: typed::StructExpression<'ast, T>, ) -> Vec> { f.fold_struct_expression_inner( statements_buffer, - &typed_absy::types::ConcreteStructType::try_from(e.ty().clone()).unwrap(), + &typed::types::ConcreteStructType::try_from(e.ty().clone()).unwrap(), e.into_inner(), ) } @@ -1311,18 +1283,18 @@ fn fold_struct_expression<'ast, T: Field>( fn fold_tuple_expression<'ast, T: Field>( f: &mut Flattener, statements_buffer: &mut Vec>, - e: typed_absy::TupleExpression<'ast, T>, + e: typed::TupleExpression<'ast, T>, ) -> Vec> { f.fold_tuple_expression_inner( statements_buffer, - &typed_absy::types::ConcreteTupleType::try_from(e.ty().clone()).unwrap(), + &typed::types::ConcreteTupleType::try_from(e.ty().clone()).unwrap(), e.into_inner(), ) } fn fold_program<'ast, T: Field>( f: &mut Flattener, - mut p: typed_absy::TypedProgram<'ast, T>, + mut p: typed::TypedProgram<'ast, T>, ) -> zir::ZirProgram<'ast, T> { let main_module = p.modules.remove(&p.main).unwrap(); @@ -1332,7 +1304,7 @@ fn fold_program<'ast, T: Field>( .unwrap() .symbol; let main_function = match main_function { - typed_absy::TypedFunctionSymbol::Here(main) => main, + typed::TypedFunctionSymbol::Here(main) => main, _ => unreachable!(), }; diff --git a/zokrates_core/src/static_analysis/mod.rs b/zokrates_core/src/static_analysis/mod.rs index 2629f0e1..3a54df89 100644 --- a/zokrates_core/src/static_analysis/mod.rs +++ b/zokrates_core/src/static_analysis/mod.rs @@ -15,7 +15,6 @@ mod propagation; mod reducer; mod struct_concretizer; mod uint_optimizer; -mod unconstrained_vars; mod variable_write_remover; mod zir_propagation; @@ -32,10 +31,9 @@ use self::variable_write_remover::VariableWriteRemover; use crate::compile::CompileConfig; use crate::static_analysis::constant_resolver::ConstantResolver; use crate::static_analysis::zir_propagation::ZirPropagator; -use crate::typed_absy::{abi::Abi, TypedProgram}; -use crate::zir::ZirProgram; use std::fmt; -pub use unconstrained_vars::UnconstrainedVariableDetector; +use zokrates_ast::typed::{abi::Abi, TypedProgram}; +use zokrates_ast::zir::ZirProgram; use zokrates_field::Field; #[derive(Debug)] diff --git a/zokrates_core/src/static_analysis/out_of_bounds.rs b/zokrates_core/src/static_analysis/out_of_bounds.rs index 679ca152..7cdc88b6 100644 --- a/zokrates_core/src/static_analysis/out_of_bounds.rs +++ b/zokrates_core/src/static_analysis/out_of_bounds.rs @@ -1,8 +1,8 @@ -use crate::typed_absy::{ +use std::fmt; +use zokrates_ast::typed::{ result_folder::*, Expr, SelectExpression, SelectOrExpression, Type, TypedAssignee, TypedProgram, UExpressionInner, }; -use std::fmt; use zokrates_field::Field; #[derive(Default)] @@ -47,7 +47,7 @@ impl<'ast, T: Field> ResultFolder<'ast, T> for OutOfBoundsChecker { ) -> Result, Error> { match a { TypedAssignee::Select(box array, box index) => { - use crate::typed_absy::Typed; + use zokrates_ast::typed::Typed; let array = self.fold_assignee(array)?; diff --git a/zokrates_core/src/static_analysis/propagation.rs b/zokrates_core/src/static_analysis/propagation.rs index 33ce5ca6..d73962b3 100644 --- a/zokrates_core/src/static_analysis/propagation.rs +++ b/zokrates_core/src/static_analysis/propagation.rs @@ -7,13 +7,13 @@ //! @author Thibaut Schaeffer //! @date 2018 -use crate::typed_absy::result_folder::*; -use crate::typed_absy::types::Type; -use crate::typed_absy::*; use std::collections::HashMap; use std::convert::{TryFrom, TryInto}; use std::fmt; use zokrates_ast::common::FlatEmbed; +use zokrates_ast::typed::result_folder::*; +use zokrates_ast::typed::types::Type; +use zokrates_ast::typed::*; use zokrates_field::Field; pub type Constants<'ast, T> = HashMap, TypedExpression<'ast, T>>; diff --git a/zokrates_core/src/static_analysis/reducer/constants_reader.rs b/zokrates_core/src/static_analysis/reducer/constants_reader.rs index 8fb1d4a1..5e62a6eb 100644 --- a/zokrates_core/src/static_analysis/reducer/constants_reader.rs +++ b/zokrates_core/src/static_analysis/reducer/constants_reader.rs @@ -1,7 +1,7 @@ // given a (partial) map of values for program constants, replace where applicable constants by their value use crate::static_analysis::reducer::ConstantDefinitions; -use crate::typed_absy::{ +use zokrates_ast::typed::{ folder::*, ArrayExpression, ArrayExpressionInner, ArrayType, BooleanExpression, CoreIdentifier, DeclarationConstant, Expr, FieldElementExpression, Identifier, StructExpression, StructExpressionInner, StructType, TypedProgram, TypedSymbolDeclaration, UBitwidth, diff --git a/zokrates_core/src/static_analysis/reducer/constants_writer.rs b/zokrates_core/src/static_analysis/reducer/constants_writer.rs index f84c24b0..6a5a05d0 100644 --- a/zokrates_core/src/static_analysis/reducer/constants_writer.rs +++ b/zokrates_core/src/static_analysis/reducer/constants_writer.rs @@ -3,12 +3,12 @@ use crate::static_analysis::reducer::{ constants_reader::ConstantsReader, reduce_function, ConstantDefinitions, Error, }; -use crate::typed_absy::{ +use std::collections::{BTreeMap, HashSet}; +use zokrates_ast::typed::{ result_folder::*, types::ConcreteGenericsAssignment, OwnedTypedModuleId, TypedConstant, TypedConstantSymbol, TypedConstantSymbolDeclaration, TypedModuleId, TypedProgram, TypedSymbolDeclaration, UExpression, }; -use std::collections::{BTreeMap, HashSet}; use zokrates_field::Field; pub struct ConstantsWriter<'ast, T> { @@ -105,11 +105,11 @@ impl<'ast, T: Field> ResultFolder<'ast, T> for ConstantsWriter<'ast, T> { // if constants were used in the rhs, they are now defined in the map // replace them in the expression - use crate::typed_absy::folder::Folder; + use zokrates_ast::typed::folder::Folder; let c = ConstantsReader::with_constants(&self.constants).fold_constant(c); - use crate::typed_absy::{DeclarationSignature, TypedFunction, TypedStatement}; + use zokrates_ast::typed::{DeclarationSignature, TypedFunction, TypedStatement}; // wrap this expression in a function let wrapper = TypedFunction { @@ -130,13 +130,13 @@ impl<'ast, T: Field> ResultFolder<'ast, T> for ConstantsWriter<'ast, T> { assert_eq!(expressions.len(), 1); let constant_expression = expressions.pop().unwrap(); - use crate::typed_absy::Constant; + use zokrates_ast::typed::Constant; if !constant_expression.is_constant() { return Err(Error::ConstantReduction(id.id.to_string(), id.module)); }; - use crate::typed_absy::Typed; - if crate::typed_absy::types::try_from_g_type::<_, UExpression<'ast, T>>( + use zokrates_ast::typed::Typed; + if zokrates_ast::typed::types::try_from_g_type::<_, UExpression<'ast, T>>( c.ty.clone(), ) .unwrap() diff --git a/zokrates_core/src/static_analysis/reducer/inline.rs b/zokrates_core/src/static_analysis/reducer/inline.rs index 3303766f..c0160839 100644 --- a/zokrates_core/src/static_analysis/reducer/inline.rs +++ b/zokrates_core/src/static_analysis/reducer/inline.rs @@ -28,16 +28,16 @@ use crate::static_analysis::reducer::Output; use crate::static_analysis::reducer::ShallowTransformer; use crate::static_analysis::reducer::Versions; -use crate::typed_absy::types::{ConcreteGenericsAssignment, IntoTypes}; -use crate::typed_absy::CoreIdentifier; -use crate::typed_absy::Identifier; -use crate::typed_absy::TypedAssignee; -use crate::typed_absy::{ +use zokrates_ast::common::FlatEmbed; +use zokrates_ast::typed::types::{ConcreteGenericsAssignment, IntoTypes}; +use zokrates_ast::typed::CoreIdentifier; +use zokrates_ast::typed::Identifier; +use zokrates_ast::typed::TypedAssignee; +use zokrates_ast::typed::{ ConcreteFunctionKey, ConcreteSignature, ConcreteVariable, DeclarationFunctionKey, Expr, Signature, TypedExpression, TypedFunctionSymbol, TypedFunctionSymbolDeclaration, TypedProgram, TypedStatement, Types, UExpression, UExpressionInner, Variable, }; -use zokrates_ast::common::FlatEmbed; use zokrates_field::Field; pub enum InlineError<'ast, T> { @@ -89,7 +89,7 @@ pub fn inline_call<'a, 'ast, T: Field, E: Expr<'ast, T>>( ) -> InlineResult<'ast, T> { use std::convert::TryFrom; - use crate::typed_absy::Typed; + use zokrates_ast::typed::Typed; let output_types = output.clone().into_types(); diff --git a/zokrates_core/src/static_analysis/reducer/mod.rs b/zokrates_core/src/static_analysis/reducer/mod.rs index 943ae036..094033c5 100644 --- a/zokrates_core/src/static_analysis/reducer/mod.rs +++ b/zokrates_core/src/static_analysis/reducer/mod.rs @@ -17,14 +17,14 @@ mod inline; mod shallow_ssa; use self::inline::{inline_call, InlineError}; -use crate::typed_absy::result_folder::*; -use crate::typed_absy::types::ConcreteGenericsAssignment; -use crate::typed_absy::types::GGenericsAssignment; -use crate::typed_absy::CanonicalConstantIdentifier; -use crate::typed_absy::Folder; use std::collections::HashMap; +use zokrates_ast::typed::result_folder::*; +use zokrates_ast::typed::types::ConcreteGenericsAssignment; +use zokrates_ast::typed::types::GGenericsAssignment; +use zokrates_ast::typed::CanonicalConstantIdentifier; +use zokrates_ast::typed::Folder; -use crate::typed_absy::{ +use zokrates_ast::typed::{ ArrayExpressionInner, ArrayType, BlockExpression, CoreIdentifier, Expr, FunctionCall, FunctionCallExpression, FunctionCallOrExpression, Id, Identifier, OwnedTypedModuleId, TypedExpression, TypedExpressionList, TypedExpressionListInner, TypedFunction, @@ -640,9 +640,9 @@ fn compute_hash(f: &TypedFunction) -> u64 { #[cfg(test)] mod tests { use super::*; - use crate::typed_absy::types::DeclarationConstant; - use crate::typed_absy::types::DeclarationSignature; - use crate::typed_absy::{ + use zokrates_ast::typed::types::DeclarationConstant; + use zokrates_ast::typed::types::DeclarationSignature; + use zokrates_ast::typed::{ ArrayExpression, ArrayExpressionInner, DeclarationFunctionKey, DeclarationType, DeclarationVariable, FieldElementExpression, GenericIdentifier, Identifier, OwnedTypedModuleId, Select, Type, TypedExpression, TypedExpressionList, diff --git a/zokrates_core/src/static_analysis/reducer/shallow_ssa.rs b/zokrates_core/src/static_analysis/reducer/shallow_ssa.rs index 44ef2922..b82d70ad 100644 --- a/zokrates_core/src/static_analysis/reducer/shallow_ssa.rs +++ b/zokrates_core/src/static_analysis/reducer/shallow_ssa.rs @@ -24,10 +24,10 @@ // endfor // return b_3 // we leave versions b_1 and b_2 to make b accessible and modifiable inside the for-loop -use crate::typed_absy::types::ConcreteGenericsAssignment; -use crate::typed_absy::types::Type; -use crate::typed_absy::*; use zokrates_ast::typed::folder::*; +use zokrates_ast::typed::types::ConcreteGenericsAssignment; +use zokrates_ast::typed::types::Type; +use zokrates_ast::typed::*; use zokrates_field::Field; @@ -192,7 +192,7 @@ impl<'ast, 'a, T: Field> Folder<'ast, T> for ShallowTransformer<'ast, 'a> { #[cfg(test)] mod tests { use super::*; - use crate::typed_absy::types::DeclarationSignature; + use zokrates_ast::typed::types::DeclarationSignature; use zokrates_field::Bn128Field; mod normal { use super::*; @@ -336,7 +336,7 @@ mod tests { #[test] fn incremental_multiple_definition() { - use crate::typed_absy::types::Type; + use zokrates_ast::typed::types::Type; // field a // a = 2 @@ -575,7 +575,7 @@ mod tests { mod for_loop { use super::*; - use crate::typed_absy::types::GGenericsAssignment; + use zokrates_ast::typed::types::GGenericsAssignment; #[test] fn treat_loop() { // def main(field a) -> field: @@ -773,7 +773,7 @@ mod tests { mod function_call { use super::*; - use crate::typed_absy::types::GGenericsAssignment; + use zokrates_ast::typed::types::GGenericsAssignment; // test that function calls are left in #[test] fn treat_calls() { diff --git a/zokrates_core/src/static_analysis/struct_concretizer.rs b/zokrates_core/src/static_analysis/struct_concretizer.rs index e3d30f14..208a472a 100644 --- a/zokrates_core/src/static_analysis/struct_concretizer.rs +++ b/zokrates_core/src/static_analysis/struct_concretizer.rs @@ -5,15 +5,15 @@ // for structs, `Foo { field[N] a }` is propagated to `Foo<42> { field[N] a }`. The missing step is replacing `N` by `42` // *inside* the canonical type, so that it can be concretized in the same way arrays are. -use crate::typed_absy::{ +use std::marker::PhantomData; +use zokrates_ast::typed::folder::*; +use zokrates_ast::typed::{ types::{ ConcreteGenericsAssignment, DeclarationArrayType, DeclarationConstant, DeclarationStructMember, GGenericsAssignment, }, DeclarationStructType, GenericIdentifier, TypedProgram, }; -use std::marker::PhantomData; -use zokrates_ast::typed::folder::*; use zokrates_field::Field; pub struct StructConcretizer<'ast, T> { diff --git a/zokrates_core/src/static_analysis/trimmer.rs b/zokrates_core/src/static_analysis/trimmer.rs index 1db07400..f4a2f406 100644 --- a/zokrates_core/src/static_analysis/trimmer.rs +++ b/zokrates_core/src/static_analysis/trimmer.rs @@ -1,5 +1,5 @@ -use crate::typed_absy::TypedModule; -use crate::typed_absy::{TypedFunctionSymbol, TypedProgram}; +use zokrates_ast::typed::TypedModule; +use zokrates_ast::typed::{TypedFunctionSymbol, TypedProgram}; use zokrates_field::Field; pub struct Trimmer; diff --git a/zokrates_core/src/static_analysis/uint_optimizer.rs b/zokrates_core/src/static_analysis/uint_optimizer.rs index 65796bd2..7bcf6069 100644 --- a/zokrates_core/src/static_analysis/uint_optimizer.rs +++ b/zokrates_core/src/static_analysis/uint_optimizer.rs @@ -1,8 +1,8 @@ -use crate::zir::folder::*; -use crate::zir::*; use std::collections::HashMap; use std::ops::{BitAnd, Shl, Shr}; use zokrates_ast::common::FlatEmbed; +use zokrates_ast::zir::folder::*; +use zokrates_ast::zir::*; use zokrates_field::Field; #[derive(Default)] diff --git a/zokrates_core/src/static_analysis/variable_write_remover.rs b/zokrates_core/src/static_analysis/variable_write_remover.rs index 4a6040d4..0dfbf61c 100644 --- a/zokrates_core/src/static_analysis/variable_write_remover.rs +++ b/zokrates_core/src/static_analysis/variable_write_remover.rs @@ -4,10 +4,10 @@ //! @author Thibaut Schaeffer //! @date 2018 -use crate::typed_absy::types::{MemberId, Type}; -use crate::typed_absy::*; use std::collections::HashSet; use zokrates_ast::typed::folder::*; +use zokrates_ast::typed::types::{MemberId, Type}; +use zokrates_ast::typed::*; use zokrates_field::Field; pub struct VariableWriteRemover; diff --git a/zokrates_core/src/static_analysis/zir_propagation.rs b/zokrates_core/src/static_analysis/zir_propagation.rs index d06ba04d..0b2fc5cc 100644 --- a/zokrates_core/src/static_analysis/zir_propagation.rs +++ b/zokrates_core/src/static_analysis/zir_propagation.rs @@ -1,12 +1,12 @@ -use crate::zir::result_folder::fold_statement; -use crate::zir::result_folder::ResultFolder; -use crate::zir::types::UBitwidth; -use crate::zir::{ +use std::collections::HashMap; +use std::fmt; +use zokrates_ast::zir::result_folder::fold_statement; +use zokrates_ast::zir::result_folder::ResultFolder; +use zokrates_ast::zir::types::UBitwidth; +use zokrates_ast::zir::{ BooleanExpression, FieldElementExpression, Identifier, RuntimeError, UExpression, UExpressionInner, ZirExpression, ZirProgram, ZirStatement, }; -use std::collections::HashMap; -use std::fmt; use zokrates_field::Field; type Constants<'ast, T> = HashMap, ZirExpression<'ast, T>>; @@ -704,13 +704,9 @@ impl<'ast, T: Field> ResultFolder<'ast, T> for ZirPropagator<'ast, T> { #[cfg(test)] mod tests { use super::*; - use crate::zir::RuntimeError; + use zokrates_ast::zir::RuntimeError; use zokrates_field::Bn128Field; - pub fn mock() -> RuntimeError { - RuntimeError::SourceAssertion(String::default()) - } - #[test] fn propagation() { // assert([x, 1] == [y, 1]) @@ -725,7 +721,7 @@ mod tests { box FieldElementExpression::Number(Bn128Field::from(1)), ), ), - mock(), + RuntimeError::mock(), )]; let mut propagator = ZirPropagator::default(); @@ -745,7 +741,7 @@ mod tests { box FieldElementExpression::Identifier("x".into()), box FieldElementExpression::Identifier("y".into()), ), - mock() + RuntimeError::mock() )] ); } diff --git a/zokrates_interpreter/Cargo.toml b/zokrates_interpreter/Cargo.toml index f18876b0..9f7b4bbd 100644 --- a/zokrates_interpreter/Cargo.toml +++ b/zokrates_interpreter/Cargo.toml @@ -3,8 +3,18 @@ name = "zokrates_interpreter" version = "0.1.0" edition = "2021" +[features] +default = ["bellman", "ark"] +bellman = ["zokrates_field/bellman", "pairing_ce"] +ark = ["ark-bls12-377"] + [dependencies] zokrates_field = { version = "0.5", path = "../zokrates_field", default-features = false } zokrates_ast = { version = "0.1", path = "../zokrates_ast", default-features = false } num = { version = "0.1.36", default-features = false } num-bigint = { version = "0.2", default-features = false } +pairing_ce = { version = "^0.21", optional = true } +ark-bls12-377 = { version = "^0.3.0", features = ["curve"], default-features = false, optional = true } +zokrates_embed = { version = "0.1.0", path = "../zokrates_embed" } +serde = { version = "1.0", features = ["derive"] } + diff --git a/zokrates_interpreter/src/lib.rs b/zokrates_interpreter/src/lib.rs index ea6cabcb..bedf3d16 100644 --- a/zokrates_interpreter/src/lib.rs +++ b/zokrates_interpreter/src/lib.rs @@ -1,4 +1,4 @@ -use num::traits::ops::checked::CheckedDiv; +use serde::{Deserialize, Serialize}; use std::fmt; use zokrates_ast::ir::{ LinComb, ProgIterator, QuadComb, RuntimeError, Solver, Statement, Variable, Witness, @@ -207,7 +207,7 @@ impl Interpreter { generate_sha256_round_witness::(&i, &h) .into_iter() .map(|x| { - use bellman_ce::pairing::ff::{PrimeField, PrimeFieldRepr}; + use pairing_ce::ff::{PrimeField, PrimeFieldRepr}; let mut res: Vec = vec![]; x.into_repr().write_le(&mut res).unwrap(); T::from_byte_vector(res) @@ -237,7 +237,7 @@ impl Interpreter { #[derive(Debug)] pub struct EvaluationError; -#[derive(PartialEq, Clone)] +#[derive(PartialEq, Clone, Serialize, Deserialize)] pub enum Error { UnsatisfiedConstraint { error: Option }, Solver, diff --git a/zokrates_libsnark/Cargo.toml b/zokrates_libsnark/Cargo.toml new file mode 100644 index 00000000..e755747e --- /dev/null +++ b/zokrates_libsnark/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "zokrates_libsnark" +version = "0.1.0" +edition = "2021" +build = "build.rs" + +[dependencies] +zokrates_proof_systems = { version = "0.1", path = "../zokrates_proof_systems" } + +[dev-dependencies] +zokrates_interpreter = { version = "0.1", path = "../zokrates_interpreter" } + +[build-dependencies] +cc = { version = "1.0", features = ["parallel"] } +cmake = { version = "=0.1.45" } \ No newline at end of file diff --git a/zokrates_core/build.rs b/zokrates_libsnark/build.rs similarity index 96% rename from zokrates_core/build.rs rename to zokrates_libsnark/build.rs index 7f48be14..20242705 100644 --- a/zokrates_core/build.rs +++ b/zokrates_libsnark/build.rs @@ -1,10 +1,4 @@ -#[cfg(feature = "libsnark")] -extern crate cc; -#[cfg(feature = "libsnark")] -extern crate cmake; - fn main() { - #[cfg(feature = "libsnark")] { use std::env; use std::path::PathBuf; diff --git a/zokrates_core/lib/ffi.cpp b/zokrates_libsnark/lib/ffi.cpp similarity index 100% rename from zokrates_core/lib/ffi.cpp rename to zokrates_libsnark/lib/ffi.cpp diff --git a/zokrates_core/lib/ffi.hpp b/zokrates_libsnark/lib/ffi.hpp similarity index 100% rename from zokrates_core/lib/ffi.hpp rename to zokrates_libsnark/lib/ffi.hpp diff --git a/zokrates_core/lib/gm17.cpp b/zokrates_libsnark/lib/gm17.cpp similarity index 100% rename from zokrates_core/lib/gm17.cpp rename to zokrates_libsnark/lib/gm17.cpp diff --git a/zokrates_core/lib/gm17.hpp b/zokrates_libsnark/lib/gm17.hpp similarity index 100% rename from zokrates_core/lib/gm17.hpp rename to zokrates_libsnark/lib/gm17.hpp diff --git a/zokrates_core/lib/pghr13.cpp b/zokrates_libsnark/lib/pghr13.cpp similarity index 100% rename from zokrates_core/lib/pghr13.cpp rename to zokrates_libsnark/lib/pghr13.cpp diff --git a/zokrates_core/lib/pghr13.hpp b/zokrates_libsnark/lib/pghr13.hpp similarity index 100% rename from zokrates_core/lib/pghr13.hpp rename to zokrates_libsnark/lib/pghr13.hpp diff --git a/zokrates_core/lib/util.tcc b/zokrates_libsnark/lib/util.tcc similarity index 100% rename from zokrates_core/lib/util.tcc rename to zokrates_libsnark/lib/util.tcc diff --git a/zokrates_core/src/proof_system/libsnark/ffi.rs b/zokrates_libsnark/src/ffi.rs similarity index 100% rename from zokrates_core/src/proof_system/libsnark/ffi.rs rename to zokrates_libsnark/src/ffi.rs diff --git a/zokrates_core/src/proof_system/libsnark/gm17.rs b/zokrates_libsnark/src/gm17.rs similarity index 100% rename from zokrates_core/src/proof_system/libsnark/gm17.rs rename to zokrates_libsnark/src/gm17.rs diff --git a/zokrates_core/src/proof_system/libsnark/mod.rs b/zokrates_libsnark/src/lib.rs similarity index 100% rename from zokrates_core/src/proof_system/libsnark/mod.rs rename to zokrates_libsnark/src/lib.rs diff --git a/zokrates_core/src/proof_system/libsnark/pghr13.rs b/zokrates_libsnark/src/pghr13.rs similarity index 100% rename from zokrates_core/src/proof_system/libsnark/pghr13.rs rename to zokrates_libsnark/src/pghr13.rs diff --git a/zokrates_proof_systems/Cargo.toml b/zokrates_proof_systems/Cargo.toml new file mode 100644 index 00000000..c323d612 --- /dev/null +++ b/zokrates_proof_systems/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "zokrates_proof_systems" +version = "0.1.0" +edition = "2021" + +[dependencies] +zokrates_ast = { version = "0.1", path = "../zokrates_ast" } +serde = { version = "1.0", features = ["derive"] } +zokrates_field = { version = "0.5.0", path = "../zokrates_field", default-features = false } +hex = "0.4.2" +regex = "0.2" +cfg-if = "0.1" +ethabi = "17.0.0" +primitive-types = { version = "0.11", features = ["rlp"] } +rand_0_4 = { version = "0.4", package = "rand" } diff --git a/zokrates_core/src/proof_system/mod.rs b/zokrates_proof_systems/src/lib.rs similarity index 80% rename from zokrates_core/src/proof_system/mod.rs rename to zokrates_proof_systems/src/lib.rs index 64e30928..87afaae0 100644 --- a/zokrates_core/src/proof_system/mod.rs +++ b/zokrates_proof_systems/src/lib.rs @@ -1,8 +1,3 @@ -#[cfg(feature = "bellman")] -pub mod bellman; -#[cfg(feature = "libsnark")] -pub mod libsnark; - pub mod to_token; mod scheme; @@ -15,20 +10,11 @@ use zokrates_ast::ir; use serde::de::DeserializeOwned; use serde::{Deserialize, Serialize}; -use zokrates_field::{Bls12_377Field, Bls12_381Field, Bn128Field, Field}; -cfg_if::cfg_if! { - if #[cfg(feature = "bellman")] { - use rand_0_4::Rng; - use std::io::{Read, Write}; - use zokrates_field::BellmanFieldExtensions; - } -} +use rand_0_4::Rng; +use std::io::{Read, Write}; -pub trait NotBw6_761Field {} -impl NotBw6_761Field for Bls12_377Field {} -impl NotBw6_761Field for Bls12_381Field {} -impl NotBw6_761Field for Bn128Field {} +use zokrates_field::Field; #[derive(Serialize)] pub struct SetupKeypair { @@ -50,7 +36,7 @@ pub struct Proof> { #[allow(dead_code)] impl> Proof { - fn new(proof: S::ProofPoints, inputs: Vec) -> Self { + pub fn new(proof: S::ProofPoints, inputs: Vec) -> Self { Proof { proof, inputs } } } @@ -62,13 +48,29 @@ pub type Fq2 = (String, String); #[derive(Serialize, Deserialize, Clone, Debug)] pub struct G1Affine(pub Fq, pub Fq); +#[derive(Serialize, Deserialize, Clone)] +#[serde(untagged)] +pub enum G2Affine { + Fq2(G2AffineFq2), + Fq(G2AffineFq), +} + +impl ToString for G2Affine { + fn to_string(&self) -> String { + match self { + G2Affine::Fq(e) => e.to_string(), + G2Affine::Fq2(e) => e.to_string(), + } + } +} + // When G2 is defined on Fq2 field #[derive(Serialize, Deserialize, Clone)] -pub struct G2Affine(Fq2, Fq2); +pub struct G2AffineFq2(pub Fq2, pub Fq2); // When G2 is defined on a Fq field (BW6_761 curve) #[derive(Serialize, Deserialize, Clone)] -pub struct G2AffineFq(Fq, Fq); +pub struct G2AffineFq(pub Fq, pub Fq); impl ToString for G1Affine { fn to_string(&self) -> String { @@ -81,7 +83,7 @@ impl ToString for G2AffineFq { format!("{}, {}", self.0, self.1) } } -impl ToString for G2Affine { +impl ToString for G2AffineFq2 { fn to_string(&self) -> String { format!( "[{}, {}], [{}, {}]", @@ -117,8 +119,7 @@ pub trait UniversalBackend>: Backend { ) -> Result, String>; } -#[cfg(feature = "bellman")] -pub trait MpcBackend> { +pub trait MpcBackend> { fn initialize>>( program: ir::ProgIterator, phase1_radix: &mut R, diff --git a/zokrates_core/src/proof_system/scheme/gm17.rs b/zokrates_proof_systems/src/scheme/gm17.rs similarity index 89% rename from zokrates_core/src/proof_system/scheme/gm17.rs rename to zokrates_proof_systems/src/scheme/gm17.rs index 6882e243..1a4dd00f 100644 --- a/zokrates_core/src/proof_system/scheme/gm17.rs +++ b/zokrates_proof_systems/src/scheme/gm17.rs @@ -1,12 +1,9 @@ -use crate::proof_system::scheme::{NonUniversalScheme, Scheme}; -use crate::proof_system::solidity::{solidity_pairing_lib, SOLIDITY_G2_ADDITION_LIB}; -use crate::proof_system::{ - G1Affine, G2Affine, G2AffineFq, NotBw6_761Field, SolidityCompatibleField, - SolidityCompatibleScheme, -}; +use crate::scheme::{NonUniversalScheme, Scheme}; +use crate::solidity::{solidity_pairing_lib, SOLIDITY_G2_ADDITION_LIB}; +use crate::{G1Affine, G2Affine, SolidityCompatibleField, SolidityCompatibleScheme}; use regex::Regex; use serde::{Deserialize, Serialize}; -use zokrates_field::{Bw6_761Field, Field}; +use zokrates_field::Field; #[allow(clippy::upper_case_acronyms)] pub struct GM17; @@ -28,21 +25,14 @@ pub struct VerificationKey { pub query: Vec, } -impl NonUniversalScheme for GM17 {} +impl NonUniversalScheme for GM17 {} -impl NonUniversalScheme for GM17 {} - -impl Scheme for GM17 { +impl Scheme for GM17 { type VerificationKey = VerificationKey; type ProofPoints = ProofPoints; } -impl Scheme for GM17 { - type VerificationKey = VerificationKey; - type ProofPoints = ProofPoints; -} - -impl SolidityCompatibleScheme for GM17 { +impl SolidityCompatibleScheme for GM17 { type Proof = Self::ProofPoints; fn export_solidity_verifier(vk: >::VerificationKey) -> String { diff --git a/zokrates_core/src/proof_system/scheme/groth16.rs b/zokrates_proof_systems/src/scheme/groth16.rs similarity index 96% rename from zokrates_core/src/proof_system/scheme/groth16.rs rename to zokrates_proof_systems/src/scheme/groth16.rs index c1f526a9..953efa12 100644 --- a/zokrates_core/src/proof_system/scheme/groth16.rs +++ b/zokrates_proof_systems/src/scheme/groth16.rs @@ -1,8 +1,6 @@ -use crate::proof_system::scheme::{NonUniversalScheme, Scheme}; -use crate::proof_system::solidity::solidity_pairing_lib; -use crate::proof_system::{ - G1Affine, G2Affine, MpcScheme, SolidityCompatibleField, SolidityCompatibleScheme, -}; +use crate::scheme::{NonUniversalScheme, Scheme}; +use crate::solidity::solidity_pairing_lib; +use crate::{G1Affine, G2Affine, MpcScheme, SolidityCompatibleField, SolidityCompatibleScheme}; use regex::Regex; use serde::{Deserialize, Serialize}; use zokrates_field::Field; diff --git a/zokrates_core/src/proof_system/scheme/marlin.rs b/zokrates_proof_systems/src/scheme/marlin.rs similarity index 98% rename from zokrates_core/src/proof_system/scheme/marlin.rs rename to zokrates_proof_systems/src/scheme/marlin.rs index 75b32d68..caeeedd1 100644 --- a/zokrates_core/src/proof_system/scheme/marlin.rs +++ b/zokrates_proof_systems/src/scheme/marlin.rs @@ -1,8 +1,6 @@ -use crate::proof_system::scheme::{Scheme, UniversalScheme}; -use crate::proof_system::solidity::{ - solidity_pairing_lib, SolidityCompatibleField, SolidityCompatibleScheme, -}; -use crate::proof_system::{Fr, G1Affine, G2Affine, NotBw6_761Field}; +use crate::scheme::{Scheme, UniversalScheme}; +use crate::solidity::{solidity_pairing_lib, SolidityCompatibleField, SolidityCompatibleScheme}; +use crate::{Fr, G1Affine, G2Affine}; use serde::{Deserialize, Serialize}; use zokrates_field::Field; @@ -86,7 +84,7 @@ impl Scheme for Marlin { impl UniversalScheme for Marlin {} -impl SolidityCompatibleScheme for Marlin { +impl SolidityCompatibleScheme for Marlin { type Proof = SolidityProof; fn export_solidity_verifier(vk: >::VerificationKey) -> String { diff --git a/zokrates_core/src/proof_system/scheme/mod.rs b/zokrates_proof_systems/src/scheme/mod.rs similarity index 100% rename from zokrates_core/src/proof_system/scheme/mod.rs rename to zokrates_proof_systems/src/scheme/mod.rs diff --git a/zokrates_core/src/proof_system/scheme/pghr13.rs b/zokrates_proof_systems/src/scheme/pghr13.rs similarity index 97% rename from zokrates_core/src/proof_system/scheme/pghr13.rs rename to zokrates_proof_systems/src/scheme/pghr13.rs index 1dcf2184..581a83e9 100644 --- a/zokrates_core/src/proof_system/scheme/pghr13.rs +++ b/zokrates_proof_systems/src/scheme/pghr13.rs @@ -1,6 +1,6 @@ -use crate::proof_system::scheme::{NonUniversalScheme, Scheme}; -use crate::proof_system::solidity::solidity_pairing_lib; -use crate::proof_system::{G1Affine, G2Affine, SolidityCompatibleField, SolidityCompatibleScheme}; +use crate::scheme::{NonUniversalScheme, Scheme}; +use crate::solidity::solidity_pairing_lib; +use crate::{G1Affine, G2Affine, SolidityCompatibleField, SolidityCompatibleScheme}; use regex::Regex; use serde::{Deserialize, Serialize}; use zokrates_field::Field; diff --git a/zokrates_core/src/proof_system/solidity.rs b/zokrates_proof_systems/src/solidity.rs similarity index 99% rename from zokrates_core/src/proof_system/solidity.rs rename to zokrates_proof_systems/src/solidity.rs index 5bc93326..f30e27f8 100644 --- a/zokrates_core/src/proof_system/solidity.rs +++ b/zokrates_proof_systems/src/solidity.rs @@ -1,4 +1,4 @@ -use crate::proof_system::Scheme; +use crate::Scheme; use serde::{de::DeserializeOwned, Serialize}; use zokrates_field::{Bn128Field, Field}; diff --git a/zokrates_core/src/proof_system/to_token.rs b/zokrates_proof_systems/src/to_token.rs similarity index 90% rename from zokrates_core/src/proof_system/to_token.rs rename to zokrates_proof_systems/src/to_token.rs index e813e1cb..3c3dae53 100644 --- a/zokrates_core/src/proof_system/to_token.rs +++ b/zokrates_proof_systems/src/to_token.rs @@ -2,8 +2,8 @@ use ethabi::Token; use primitive_types::U256; use super::{ - Fr, G1Affine, G2Affine, Marlin, NotBw6_761Field, SolidityCompatibleField, - SolidityCompatibleScheme, G16, GM17, PGHR13, + Fr, G1Affine, G2Affine, Marlin, SolidityCompatibleField, SolidityCompatibleScheme, G16, GM17, + PGHR13, }; /// Helper methods for parsing group structure @@ -15,16 +15,19 @@ pub fn encode_g1_element(g: &G1Affine) -> (U256, U256) { } pub fn encode_g2_element(g: &G2Affine) -> ((U256, U256), (U256, U256)) { - ( - ( - U256::from(&hex::decode(&g.0 .0.trim_start_matches("0x")).unwrap()[..]), - U256::from(&hex::decode(&g.0 .1.trim_start_matches("0x")).unwrap()[..]), + match g { + G2Affine::Fq2(g) => ( + ( + U256::from(&hex::decode(&g.0 .0.trim_start_matches("0x")).unwrap()[..]), + U256::from(&hex::decode(&g.0 .1.trim_start_matches("0x")).unwrap()[..]), + ), + ( + U256::from(&hex::decode(&g.1 .0.trim_start_matches("0x")).unwrap()[..]), + U256::from(&hex::decode(&g.1 .1.trim_start_matches("0x")).unwrap()[..]), + ), ), - ( - U256::from(&hex::decode(&g.1 .0.trim_start_matches("0x")).unwrap()[..]), - U256::from(&hex::decode(&g.1 .1.trim_start_matches("0x")).unwrap()[..]), - ), - ) + _ => unreachable!(), + } } pub fn encode_fr_element(f: &Fr) -> U256 { @@ -124,7 +127,7 @@ impl ToToken for G16 { } } -impl ToToken for GM17 { +impl ToToken for GM17 { fn to_token(proof: Self::Proof) -> Token { let a = { let (x, y) = encode_g1_element(&proof.a); @@ -155,7 +158,7 @@ impl ToToken for GM17 { } } -impl ToToken for Marlin { +impl ToToken for Marlin { fn to_token(proof: Self::Proof) -> Token { let comms_1_token = Token::Array( proof diff --git a/zokrates_test/Cargo.toml b/zokrates_test/Cargo.toml index a12ba340..30fb5e7a 100644 --- a/zokrates_test/Cargo.toml +++ b/zokrates_test/Cargo.toml @@ -7,11 +7,20 @@ edition = "2018" [dependencies] zokrates_field = { version = "0.5.0", path = "../zokrates_field" } zokrates_core = { version = "0.6", path = "../zokrates_core" } +zokrates_ast = { version = "0.1", path = "../zokrates_ast" } +zokrates_interpreter = { version = "0.1", path = "../zokrates_interpreter" } zokrates_fs_resolver = { version = "0.5", path = "../zokrates_fs_resolver" } zokrates_abi = { version = "0.1", path = "../zokrates_abi" } +zokrates_common = { version = "0.1", path = "../zokrates_common" } serde = "1.0" serde_derive = "1.0" serde_json = { version = "1.0", features = ["preserve_order"] } typed-arena = "1.4.1" +[dev-dependencies] +wasm-bindgen-test = "^0.3.0" +zokrates_ark = { version = "0.1", path = "../zokrates_ark" } +zokrates_proof_systems = { version = "0.1", path = "../zokrates_proof_systems" } + + [lib] diff --git a/zokrates_test/src/lib.rs b/zokrates_test/src/lib.rs index 7ddbaf09..10e5ff65 100644 --- a/zokrates_test/src/lib.rs +++ b/zokrates_test/src/lib.rs @@ -5,11 +5,8 @@ use std::fs::File; use std::io::BufReader; use std::path::{Path, PathBuf}; -use zokrates_core::ir; -use zokrates_core::{ - compile::{compile, CompileConfig}, - typed_absy::ConcreteType, -}; +use zokrates_ast::typed::ConcreteType; +use zokrates_core::compile::{compile, CompileConfig}; use zokrates_field::{Bls12_377Field, Bls12_381Field, Bn128Field, Bw6_761Field, Field}; use zokrates_fs_resolver::FileSystemResolver; @@ -43,7 +40,7 @@ struct Test { pub output: TestResult, } -type TestResult = Result; +type TestResult = Result; #[derive(Serialize, Deserialize, Clone, PartialEq, Debug)] struct Output { @@ -67,7 +64,10 @@ fn try_parse_abi_val( zokrates_abi::parse_strict_json(s, types).map(|v| v.encode()) } -fn compare(result: Result, expected: TestResult) -> Result<(), String> { +fn compare( + result: Result, + expected: TestResult, +) -> Result<(), String> { if result != expected { return Err(format!("Expected {:?} but found {:?}", expected, result)); } @@ -146,7 +146,7 @@ fn compile_and_run(t: Tests) { ); }; - let interpreter = zokrates_core::ir::Interpreter::default(); + let interpreter = zokrates_interpreter::Interpreter::default(); let with_abi = t.abi.unwrap_or(true); for test in t.tests.into_iter() { @@ -167,7 +167,7 @@ fn compile_and_run(t: Tests) { let output = interpreter.execute(bin.clone(), &input); use zokrates_abi::Decode; - let output: Result = output.map(|witness| Output { + let output: Result = output.map(|witness| Output { values: zokrates_abi::Values::decode( witness.return_values(), if with_abi { @@ -178,7 +178,7 @@ fn compile_and_run(t: Tests) { .iter() .flat_map(|t| { (0..t.get_primitive_count()) - .map(|_| zokrates_core::typed_absy::ConcreteType::FieldElement) + .map(|_| zokrates_ast::typed::ConcreteType::FieldElement) }) .collect() }, diff --git a/zokrates_core/tests/out_of_range.rs b/zokrates_test/tests/out_of_range.rs similarity index 97% rename from zokrates_core/tests/out_of_range.rs rename to zokrates_test/tests/out_of_range.rs index 723aec0a..565c96cf 100644 --- a/zokrates_core/tests/out_of_range.rs +++ b/zokrates_test/tests/out_of_range.rs @@ -6,12 +6,10 @@ use std::io; use typed_arena::Arena; use zokrates_common::Resolver; use zokrates_core::compile::CompileConfig; -use zokrates_core::{ - compile::{compile, CompilationArtifacts}, - ir::Interpreter, -}; +use zokrates_core::compile::{compile, CompilationArtifacts}; use zokrates_field::Bn128Field; use zokrates_fs_resolver::FileSystemResolver; +use zokrates_interpreter::Interpreter; #[test] fn lt_field() { diff --git a/zokrates_core/tests/wasm.rs b/zokrates_test/tests/wasm.rs similarity index 58% rename from zokrates_core/tests/wasm.rs rename to zokrates_test/tests/wasm.rs index 123a2028..32efefd3 100644 --- a/zokrates_core/tests/wasm.rs +++ b/zokrates_test/tests/wasm.rs @@ -4,23 +4,21 @@ extern crate wasm_bindgen_test; extern crate zokrates_core; extern crate zokrates_field; use wasm_bindgen_test::*; -use zokrates_core::flat_absy::{FlatParameter, FlatVariable}; -use zokrates_core::ir::{Interpreter, Prog, Statement}; -use zokrates_core::proof_system::{Backend, NonUniversalBackend}; +use zokrates_ast::flat::{Parameter, Variable}; +use zokrates_ast::ir::{Prog, Statement}; use zokrates_field::Bn128Field; +use zokrates_interpreter::Interpreter; +use zokrates_proof_systems::{Backend, NonUniversalBackend}; -use zokrates_core::proof_system::ark::Ark; -use zokrates_core::proof_system::groth16::G16; +use zokrates_ark::Ark; +use zokrates_proof_systems::groth16::G16; #[wasm_bindgen_test] fn generate_proof() { let program: Prog = Prog { - arguments: vec![FlatParameter::public(FlatVariable::new(0))], + arguments: vec![Parameter::public(Variable::new(0))], return_count: 1, - statements: vec![Statement::constraint( - FlatVariable::new(0), - FlatVariable::new(0), - )], + statements: vec![Statement::constraint(Variable::new(0), Variable::new(0))], }; let interpreter = Interpreter::default();