[WIP] Split bellman crate

.circleci/config.yml

@@ -45,7 +45,7 @@ jobs:
       - run:
           name: Run tests
           no_output_timeout: 1h
-          command: RUSTFLAGS="-D warnings" ./test.sh
+          command: RUSTFLAGS="-D warnings" RUST_BACKTRACE=1 ./test.sh
       - save-sccache-cache
   wasm_test:
     docker:
@@ -79,7 +79,7 @@ jobs:
       - run:
           name: Run integration tests
           no_output_timeout: "30m"
-          command: RUSTFLAGS="-D warnings" ./integration_test.sh
+          command: RUSTFLAGS="-D warnings" RUST_BACKTRACE=1 ./integration_test.sh
       - save-sccache-cache
   deploy:
     docker:

Cargo.toml

@@ -16,6 +16,7 @@ members = [
     "zokrates_interpreter",
     "zokrates_embed",
     "zokrates_bellman",
+    "zokrates_bellman_plonk",
     "zokrates_proof_systems",
     "zokrates_js",
     "zokrates_circom"

zokrates_bellman/Cargo.toml

@@ -4,16 +4,16 @@ version = "0.1.0"
 edition = "2021"
 
 [features]
-wasm = ["bellman_ce/nolog", "bellman_ce/wasm"]
-multicore = ["bellman_ce/multicore", "phase2/multicore"]
+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_ce = { git = "https://github.com/georgwiese/bellman", rev="b356c7001f30da23bfad2b43eb0b7ca9804c8252", default-features = false, features = ["plonk", "multicore"] }
-# pairing = { package = "pairing_ce", version = "^0.21" }
+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"] }

zokrates_bellman/src/groth16.rs

@@ -2,17 +2,20 @@ use bellman::groth16::{
     prepare_verifying_key, verify_proof, Parameters, PreparedVerifyingKey, Proof as BellmanProof,
     VerifyingKey,
 };
-use bellman::pairing::{ff::to_hex, CurveAffine, Engine};
+use pairing::{ff::to_hex, CurveAffine, Engine};
 
 use zokrates_field::BellmanFieldExtensions;
 use zokrates_field::Field;
 use zokrates_proof_systems::{
-    Backend, G1Affine, G2Affine, NonUniversalBackend, Proof, SetupKeypair,
+    Backend, G1Affine, G2Affine, MpcBackend, NonUniversalBackend, Proof, SetupKeypair,
 };
 
 use crate::Bellman;
 use crate::Computation;
 use crate::{parse_g1, parse_g2, serialization};
+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;
@@ -97,60 +100,60 @@ impl<T: Field + BellmanFieldExtensions> NonUniversalBackend<T, G16> for Bellman
     }
 }
 
-// impl<T: Field + BellmanFieldExtensions> MpcBackend<T, G16> for Bellman {
-//     fn initialize<R: Read, W: Write, I: IntoIterator<Item = Statement<T>>>(
-//         program: ProgIterator<T, I>,
-//         phase1_radix: &mut R,
-//         output: &mut W,
-//     ) -> Result<(), String> {
-//         let circuit = Computation::without_witness(program);
-//         let params = MPCParameters::new(circuit, phase1_radix).map_err(|e| e.to_string())?;
-//         params.write(output).map_err(|e| e.to_string())?;
-//         Ok(())
-//     }
-
-//     fn contribute<R: Read, W: Write, G: Rng>(
-//         params: &mut R,
-//         rng: &mut G,
-//         output: &mut W,
-//     ) -> Result<[u8; 64], String> {
-//         let mut params =
-//             MPCParameters::<T::BellmanEngine>::read(params, true).map_err(|e| e.to_string())?;
-
-//         let hash = params.contribute(rng);
-//         params.write(output).map_err(|e| e.to_string())?;
-
-//         Ok(hash)
-//     }
-
-//     fn verify<P: Read, R: Read, I: IntoIterator<Item = Statement<T>>>(
-//         params: &mut P,
-//         program: ProgIterator<T, I>,
-//         phase1_radix: &mut R,
-//     ) -> Result<Vec<[u8; 64]>, String> {
-//         let params =
-//             MPCParameters::<T::BellmanEngine>::read(params, true).map_err(|e| e.to_string())?;
-
-//         let circuit = Computation::without_witness(program);
-//         let hashes = params
-//             .verify(circuit, phase1_radix)
-//             .map_err(|_| "parameters malformed".to_string())?;
-
-//         Ok(hashes)
-//     }
-
-//     fn export_keypair<R: Read>(params: &mut R) -> Result<SetupKeypair<T, G16>, String> {
-//         let params =
-//             MPCParameters::<T::BellmanEngine>::read(params, true).map_err(|e| e.to_string())?;
-
-//         let params = params.get_params();
-//         let mut pk: Vec<u8> = Vec::new();
-//         params.write(&mut pk).map_err(|e| e.to_string())?;
-
-//         let vk = serialization::parameters_to_verification_key::<T>(params);
-//         Ok(SetupKeypair::new(vk, pk))
-//     }
-// }
+impl<T: Field + BellmanFieldExtensions> MpcBackend<T, G16> for Bellman {
+    fn initialize<R: Read, W: Write, I: IntoIterator<Item = Statement<T>>>(
+        program: ProgIterator<T, I>,
+        phase1_radix: &mut R,
+        output: &mut W,
+    ) -> Result<(), String> {
+        let circuit = Computation::without_witness(program);
+        let params = MPCParameters::new(circuit, phase1_radix).map_err(|e| e.to_string())?;
+        params.write(output).map_err(|e| e.to_string())?;
+        Ok(())
+    }
+
+    fn contribute<R: Read, W: Write, G: Rng>(
+        params: &mut R,
+        rng: &mut G,
+        output: &mut W,
+    ) -> Result<[u8; 64], String> {
+        let mut params =
+            MPCParameters::<T::BellmanEngine>::read(params, true).map_err(|e| e.to_string())?;
+
+        let hash = params.contribute(rng);
+        params.write(output).map_err(|e| e.to_string())?;
+
+        Ok(hash)
+    }
+
+    fn verify<P: Read, R: Read, I: IntoIterator<Item = Statement<T>>>(
+        params: &mut P,
+        program: ProgIterator<T, I>,
+        phase1_radix: &mut R,
+    ) -> Result<Vec<[u8; 64]>, String> {
+        let params =
+            MPCParameters::<T::BellmanEngine>::read(params, true).map_err(|e| e.to_string())?;
+
+        let circuit = Computation::without_witness(program);
+        let hashes = params
+            .verify(circuit, phase1_radix)
+            .map_err(|_| "parameters malformed".to_string())?;
+
+        Ok(hashes)
+    }
+
+    fn export_keypair<R: Read>(params: &mut R) -> Result<SetupKeypair<T, G16>, String> {
+        let params =
+            MPCParameters::<T::BellmanEngine>::read(params, true).map_err(|e| e.to_string())?;
+
+        let params = params.get_params();
+        let mut pk: Vec<u8> = Vec::new();
+        params.write(&mut pk).map_err(|e| e.to_string())?;
+
+        let vk = parameters_to_verification_key::<T>(params);
+        Ok(SetupKeypair::new(vk, pk))
+    }
+}
 
 pub fn parameters_to_verification_key<T: Field + BellmanFieldExtensions>(
     parameters: &Parameters<T::BellmanEngine>,

zokrates_bellman/src/lib.rs

@@ -1,7 +1,4 @@
 pub mod groth16;
-pub mod plonk;
-
-extern crate bellman_ce as bellman;
 
 use bellman::groth16::Proof;
 use bellman::groth16::{
@@ -200,7 +197,7 @@ impl<T: BellmanFieldExtensions + Field, I: IntoIterator<Item = Statement<T>>> Co
 
 pub mod serialization {
     use super::*;
-    use bellman::{pairing::from_hex, CurveAffine, Engine};
+    use bellman::{pairing::from_hex, pairing::CurveAffine, pairing::Engine};
     use zokrates_proof_systems::{G1Affine, G2Affine};
 
     pub fn to_g1<T: BellmanFieldExtensions>(
@@ -243,7 +240,7 @@ pub mod serialization {
 
 mod parse {
     use super::*;
-    use bellman::{pairing::CurveAffine, PrimeField};
+    use bellman::{pairing::ff::PrimeField, pairing::CurveAffine};
     use zokrates_proof_systems::{Fq2, Fr, G1Affine, G2Affine, GAffine};
 
     fn to_hex(bytes: &[u8]) -> String {
@@ -277,7 +274,7 @@ mod parse {
     pub fn parse_fr<T: BellmanFieldExtensions>(
         e: &<T::BellmanEngine as bellman::pairing::ff::ScalarEngine>::Fr,
     ) -> Fr {
-        use crate::bellman::PrimeFieldRepr;
+        use bellman::pairing::ff::PrimeFieldRepr;
         let mut bytes: Vec<u8> = Vec::new();
         e.into_repr().write_le(&mut bytes).unwrap();
         bytes.reverse();

zokrates_bellman_plonk/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "zokrates_bellman_plonk"
+version = "0.1.0"
+edition = "2021"
+
+[features]
+wasm = ["bellman_ce/nolog", "bellman_ce/wasm"]
+multicore = ["bellman_ce/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_ce = { git = "https://github.com/georgwiese/bellman", rev="dbed83d1971c29e8fdb07d341e8593fef8ba5eab", default-features = false, features = ["plonk", "multicore"] }
+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", features = ["bellman"] }
+
+
+
+
+