Plonk: Add solidity verifier

zokrates_ark/src/lib.rs

@@ -157,7 +157,7 @@ mod parse {
     use super::*;
     use ark_ff::ToBytes;
     use zokrates_field::G2Type;
-    use zokrates_proof_systems::{Fq2, Fr, G1Affine, G2Affine, G2AffineFq, G2AffineFq2, GAffine};
+    use zokrates_proof_systems::{Fq2, Fr, G1Affine, G2Affine, G2AffineFq, GAffine};
 
     pub fn parse_g1<T: Field + ArkFieldExtensions>(
         e: &<T::ArkEngine as PairingEngine>::G1Affine,

zokrates_bellman/src/groth16.rs

@@ -7,15 +7,12 @@ use bellman::pairing::{ff::to_hex, CurveAffine, Engine};
 use zokrates_field::BellmanFieldExtensions;
 use zokrates_field::Field;
 use zokrates_proof_systems::{
-    Backend, G1Affine, G2Affine, MpcBackend, NonUniversalBackend, Proof, SetupKeypair,
+    Backend, G1Affine, G2Affine, 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;

zokrates_bellman/src/plonk.rs

@@ -172,6 +172,12 @@ fn deserialize_vk<T: Field + BellmanFieldExtensions>(
 fn serialize_vk<T: Field + BellmanFieldExtensions>(
     vk: BellmanVerificationKey<T::BellmanEngine, PlonkCsWidth4WithNextStepParams>,
 ) -> <Plonk as Scheme<T>>::VerificationKey {
+    let domain = bellman::plonk::domains::Domain::<
+        <T::BellmanEngine as bellman::pairing::ff::ScalarEngine>::Fr,
+    >::new_for_size(vk.n.next_power_of_two() as u64)
+    .unwrap();
+    let omega = parse_fr::<T>(&domain.generator);
+
     VerificationKey {
         n: vk.n as u32,
         num_inputs: vk.num_inputs as u32,
@@ -195,6 +201,7 @@ fn serialize_vk<T: Field + BellmanFieldExtensions>(
             .try_into()
             .map_err(|_| ())
             .unwrap(),
+        omega: omega,
     }
 }
 

zokrates_cli/src/ops/export_verifier.rs

@@ -68,6 +68,9 @@ pub fn exec(sub_matches: &ArgMatches) -> Result<(), String> {
         (CurveParameter::Bn128, SchemeParameter::MARLIN) => {
             cli_export_verifier::<Bn128Field, Marlin>(sub_matches, vk)
         }
+        (CurveParameter::Bn128, SchemeParameter::PLONK) => {
+            cli_export_verifier::<Bn128Field, Plonk>(sub_matches, vk)
+        }
         (curve_parameter, scheme_parameter) => Err(format!("Could not export verifier with given parameters (curve: {}, scheme: {}): not supported", curve_parameter, scheme_parameter))
     }
 }

zokrates_cli/src/ops/mpc/beacon.rs

@@ -3,10 +3,9 @@ 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_field::{BellmanFieldExtensions, Bls12_381Field, Bn128Field, Field};
-use zokrates_proof_systems::{MpcBackend, MpcScheme, G16};
+use zokrates_field::{BellmanFieldExtensions, Field};
+use zokrates_proof_systems::{MpcBackend, MpcScheme};
 
 pub fn subcommand() -> App<'static, 'static> {
     SubCommand::with_name("beacon")

zokrates_cli/src/ops/mpc/contribute.rs

@@ -3,10 +3,9 @@ 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_field::{BellmanFieldExtensions, Bls12_381Field, Bn128Field, Field};
-use zokrates_proof_systems::{MpcBackend, MpcScheme, G16};
+use zokrates_field::{BellmanFieldExtensions, Field};
+use zokrates_proof_systems::{MpcBackend, MpcScheme};
 
 pub fn subcommand() -> App<'static, 'static> {
     SubCommand::with_name("contribute")

zokrates_cli/src/ops/mpc/export.rs

@@ -3,10 +3,9 @@ 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_field::{BellmanFieldExtensions, Bls12_381Field, Bn128Field, Field};
-use zokrates_proof_systems::{MpcBackend, MpcScheme, TaggedVerificationKey, G16};
+use zokrates_field::{BellmanFieldExtensions, Field};
+use zokrates_proof_systems::{MpcBackend, MpcScheme, TaggedVerificationKey};
 
 pub fn subcommand() -> App<'static, 'static> {
     SubCommand::with_name("export")

zokrates_cli/src/ops/mpc/init.rs

@@ -4,9 +4,8 @@ use std::fs::File;
 use std::io::{BufReader, BufWriter};
 use std::path::Path;
 use zokrates_ast::ir::{self, ProgEnum};
-use zokrates_bellman::Bellman;
 use zokrates_field::{BellmanFieldExtensions, Field};
-use zokrates_proof_systems::{MpcBackend, MpcScheme, G16};
+use zokrates_proof_systems::{MpcBackend, MpcScheme};
 
 pub fn subcommand() -> App<'static, 'static> {
     SubCommand::with_name("init")

zokrates_cli/src/ops/mpc/verify.rs

@@ -4,9 +4,8 @@ use std::fs::File;
 use std::io::BufReader;
 use std::path::Path;
 use zokrates_ast::ir::{self, ProgEnum};
-use zokrates_bellman::Bellman;
 use zokrates_field::{BellmanFieldExtensions, Field};
-use zokrates_proof_systems::{MpcBackend, MpcScheme, G16};
+use zokrates_proof_systems::{MpcBackend, MpcScheme};
 
 pub fn subcommand() -> App<'static, 'static> {
     SubCommand::with_name("verify")

zokrates_cli/tests/integration.rs

@@ -23,7 +23,7 @@ mod integration {
     use zokrates_ast::typed::abi::Abi;
     use zokrates_field::Bn128Field;
     use zokrates_proof_systems::{
-        to_token::ToToken, Marlin, Proof, SolidityCompatibleScheme, G16, GM17,
+        to_token::ToToken, Marlin, Plonk, Proof, SolidityCompatibleScheme, G16, GM17,
         SOLIDITY_G2_ADDITION_LIB,
     };
 
@@ -43,7 +43,6 @@ mod integration {
     fn test_compile_and_witness_dir() {
         let global_dir = TempDir::new("global").unwrap();
         let global_base = global_dir.path();
-        let universal_setup_path = global_base.join("universal_setup.dat");
 
         // GENERATE A UNIVERSAL SETUP
         assert_cli::Assert::main_binary()
@@ -54,7 +53,27 @@ mod integration {
                 "--proving-scheme",
                 "marlin",
                 "--universal-setup-path",
-                universal_setup_path.to_str().unwrap(),
+                global_base
+                    .join("universal_setup_marlin.dat")
+                    .to_str()
+                    .unwrap(),
+            ])
+            .succeeds()
+            .unwrap();
+        assert_cli::Assert::main_binary()
+            .with_args(&[
+                "universal-setup",
+                "--backend",
+                "bellman",
+                "--size",
+                "10",
+                "--proving-scheme",
+                "plonk",
+                "--universal-setup-path",
+                global_base
+                    .join("universal_setup_plonk.dat")
+                    .to_str()
+                    .unwrap(),
             ])
             .succeeds()
             .unwrap();
@@ -89,6 +108,8 @@ mod integration {
         expected_witness_path: &Path,
         global_path: &Path,
     ) {
+        println!("Running test for program: {:?}", program_name);
+
         let tmp_dir = TempDir::new(program_name).unwrap();
         let tmp_base = tmp_dir.path();
         let test_case_path = tmp_base.join(program_name);
@@ -97,7 +118,6 @@ mod integration {
         let witness_path = tmp_base.join(program_name).join("witness");
         let inline_witness_path = tmp_base.join(program_name).join("inline_witness");
         let proof_path = tmp_base.join(program_name).join("proof.json");
-        let universal_setup_path = global_path.join("universal_setup.dat");
         let verification_key_path = tmp_base
             .join(program_name)
             .join("verification")
@@ -235,14 +255,16 @@ mod integration {
         }
 
         let backends = map! {
-            "bellman" => vec!["g16"],
+            "bellman" => vec!["g16", "plonk"],
             "ark" => vec!["g16", "gm17", "marlin"]
         };
 
         for (backend, schemes) in backends {
             for scheme in &schemes {
                 println!("test with {}, {}", backend, scheme);
                 // SETUP
+                let universal_setup_path =
+                    global_path.join(format!("universal_setup_{}.dat", scheme));
                 let setup = assert_cli::Assert::main_binary()
                     .with_args(&[
                         "setup",
@@ -264,6 +286,10 @@ mod integration {
                     .doesnt_contain("This program is too small to generate a setup with Marlin")
                     .execute();
 
+                if let Err(e) = &setup {
+                    eprint!("{}", e);
+                }
+
                 if setup.is_ok() {
                     // GENERATE-PROOF
                     assert_cli::Assert::main_binary()
@@ -318,16 +344,22 @@ mod integration {
                             .unwrap();
                     match *scheme {
                         "marlin" => {
-                            // Get the proof
                             let proof: Proof<Bn128Field, Marlin> = serde_json::from_reader(
                                 File::open(proof_path.to_str().unwrap()).unwrap(),
                             )
                             .unwrap();
 
                             test_solidity_verifier(contract_str, proof);
                         }
+                        "plonk" => {
+                            let proof: Proof<Bn128Field, Plonk> = serde_json::from_reader(
+                                File::open(proof_path.to_str().unwrap()).unwrap(),
+                            )
+                            .unwrap();
+
+                            test_solidity_verifier(contract_str, proof);
+                        }
                         "g16" => {
-                            // Get the proof
                             let proof: Proof<Bn128Field, G16> = serde_json::from_reader(
                                 File::open(proof_path.to_str().unwrap()).unwrap(),
                             )
@@ -336,7 +368,6 @@ mod integration {
                             test_solidity_verifier(contract_str, proof);
                         }
                         "gm17" => {
-                            // Get the proof
                             let proof: Proof<Bn128Field, GM17> = serde_json::from_reader(
                                 File::open(proof_path.to_str().unwrap()).unwrap(),
                             )
@@ -411,7 +442,6 @@ mod integration {
                 })
                 .collect::<Vec<_>>(),
         );
-
         let inputs = [proof_token, input_token.clone()];
 
         // Call verify function on contract
@@ -445,7 +475,7 @@ mod integration {
             )
             .unwrap();
 
-        assert_eq!(result.op_out, Return::InvalidOpcode);
+        assert!(result.op_out == Return::InvalidOpcode || result.op_out == Return::Revert);
     }
 
     fn test_compile_and_smtlib2(

zokrates_proof_systems/Cargo.toml

@@ -13,4 +13,8 @@ cfg-if = "0.1"
 ethabi = "17.0.0"
 primitive-types = { version = "0.11", features = ["rlp"] }
 rand_0_4 = { version = "0.4", package = "rand" }
-getrandom = { version = "0.2", features = ["js"] }
+getrandom = { version = "0.2", features = ["js"] }
+
+# Used by solidity renderer
+handlebars = "3.*"
+serde_json = "1.*"