From f2481d3dec2d65e622f094c42e80f8a9373812a7 Mon Sep 17 00:00:00 2001 From: dark64 Date: Thu, 25 Nov 2021 20:07:17 +0100 Subject: [PATCH] refactor --- Cargo.lock | 1 + zokrates_cli/Cargo.toml | 1 + zokrates_cli/src/bin.rs | 1 - zokrates_cli/src/constants.rs | 43 -- zokrates_cli/src/ops/check.rs | 7 +- zokrates_cli/src/ops/compile.rs | 7 +- zokrates_cli/src/ops/export_verifier.rs | 11 +- zokrates_cli/src/ops/generate_proof.rs | 18 +- zokrates_cli/src/ops/setup.rs | 18 +- zokrates_cli/src/ops/universal_setup.rs | 13 +- zokrates_cli/src/ops/verify.rs | 13 +- zokrates_common/Cargo.toml | 7 + zokrates_common/src/constants.rs | 42 ++ .../src/helpers.rs | 0 zokrates_common/src/lib.rs | 3 + zokrates_core/src/ir/serialize.rs | 9 + zokrates_js/Cargo.toml | 5 +- zokrates_js/index.d.ts | 30 +- zokrates_js/src/lib.rs | 527 +++++++++++------- zokrates_js/tests/tests.js | 46 +- zokrates_js/wrapper.js | 38 +- 21 files changed, 498 insertions(+), 342 deletions(-) create mode 100644 zokrates_common/src/constants.rs rename {zokrates_cli => zokrates_common}/src/helpers.rs (100%) diff --git a/Cargo.lock b/Cargo.lock index 871121e2..fb9645d9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2396,6 +2396,7 @@ dependencies = [ "serde_json", "tempdir", "zokrates_abi", + "zokrates_common", "zokrates_core", "zokrates_field", "zokrates_fs_resolver", diff --git a/zokrates_cli/Cargo.toml b/zokrates_cli/Cargo.toml index 5c2b04cc..f001ea3a 100644 --- a/zokrates_cli/Cargo.toml +++ b/zokrates_cli/Cargo.toml @@ -22,6 +22,7 @@ zokrates_field = { version = "0.4", path = "../zokrates_field", default-features zokrates_abi = { version = "0.1", path = "../zokrates_abi" } zokrates_core = { version = "0.6", path = "../zokrates_core", default-features = false } zokrates_fs_resolver = { version = "0.5", path = "../zokrates_fs_resolver"} +zokrates_common = { version = "0.1", path = "../zokrates_common"} serde_json = "1.0" dirs = "3.0.1" lazy_static = "1.4.0" diff --git a/zokrates_cli/src/bin.rs b/zokrates_cli/src/bin.rs index 5f40f344..00dfde80 100644 --- a/zokrates_cli/src/bin.rs +++ b/zokrates_cli/src/bin.rs @@ -10,7 +10,6 @@ extern crate lazy_static; mod constants; -mod helpers; mod ops; use clap::{App, AppSettings, Arg}; diff --git a/zokrates_cli/src/constants.rs b/zokrates_cli/src/constants.rs index 19b2edf4..4bfd2b00 100644 --- a/zokrates_cli/src/constants.rs +++ b/zokrates_cli/src/constants.rs @@ -9,10 +9,6 @@ pub const UNIVERSAL_SETUP_DEFAULT_PATH: &str = "universal_setup.dat"; pub const UNIVERSAL_SETUP_DEFAULT_SIZE: &str = "10"; pub const SMTLIB2_DEFAULT_PATH: &str = "out.smt2"; -pub const BELLMAN: &str = "bellman"; -pub const LIBSNARK: &str = "libsnark"; -pub const ARK: &str = "ark"; - lazy_static! { pub static ref DEFAULT_STDLIB_PATH: String = dirs::home_dir() .map(|p| p.join(".zokrates/stdlib")) @@ -21,42 +17,3 @@ lazy_static! { .into_string() .unwrap(); } - -#[cfg(any(feature = "bellman", feature = "ark", feature = "libsnark"))] -pub const BACKENDS: &[&str] = if cfg!(feature = "libsnark") { - if cfg!(feature = "ark") { - if cfg!(feature = "bellman") { - &[BELLMAN, LIBSNARK, ARK] - } else { - &[LIBSNARK, ARK] - } - } else if cfg!(feature = "bellman") { - &[BELLMAN, LIBSNARK] - } else { - &[LIBSNARK] - } -} else if cfg!(feature = "ark") { - if cfg!(feature = "bellman") { - &[BELLMAN, ARK] - } else { - &[ARK] - } -} else if cfg!(feature = "bellman") { - &[BELLMAN] -} else { - &[] -}; - -pub const BN128: &str = "bn128"; -pub const BLS12_381: &str = "bls12_381"; -pub const BLS12_377: &str = "bls12_377"; -pub const BW6_761: &str = "bw6_761"; -pub const CURVES: &[&str] = &[BN128, BLS12_381, BLS12_377, BW6_761]; - -pub const G16: &str = "g16"; -pub const PGHR13: &str = "pghr13"; -pub const GM17: &str = "gm17"; -pub const MARLIN: &str = "marlin"; - -pub const SCHEMES: &[&str] = &[G16, PGHR13, GM17, MARLIN]; -pub const UNIVERSAL_SCHEMES: &[&str] = &[MARLIN]; diff --git a/zokrates_cli/src/ops/check.rs b/zokrates_cli/src/ops/check.rs index 324e8f2f..fd1a5a42 100644 --- a/zokrates_cli/src/ops/check.rs +++ b/zokrates_cli/src/ops/check.rs @@ -1,10 +1,11 @@ use crate::constants; -use crate::helpers::CurveParameter; use clap::{App, Arg, ArgMatches, SubCommand}; use std::convert::TryFrom; use std::fs::File; use std::io::{BufReader, Read}; use std::path::{Path, PathBuf}; +use zokrates_common::constants as common_constants; +use zokrates_common::helpers::CurveParameter; use zokrates_core::compile::{check, CompileConfig, CompileError}; use zokrates_field::{Bls12_377Field, Bls12_381Field, Bn128Field, Bw6_761Field, Field}; use zokrates_fs_resolver::FileSystemResolver; @@ -38,8 +39,8 @@ pub fn subcommand() -> App<'static, 'static> { .help("Curve to be used in the compilation") .takes_value(true) .required(false) - .possible_values(constants::CURVES) - .default_value(constants::BN128), + .possible_values(common_constants::CURVES) + .default_value(common_constants::BN128), ) .arg(Arg::with_name("isolate-branches") .long("isolate-branches") diff --git a/zokrates_cli/src/ops/compile.rs b/zokrates_cli/src/ops/compile.rs index cfe17781..42c3d744 100644 --- a/zokrates_cli/src/ops/compile.rs +++ b/zokrates_cli/src/ops/compile.rs @@ -1,11 +1,12 @@ use crate::constants; -use crate::helpers::CurveParameter; use clap::{App, Arg, ArgMatches, SubCommand}; use serde_json::to_writer_pretty; use std::convert::TryFrom; use std::fs::File; use std::io::{BufReader, BufWriter, Read, Write}; use std::path::{Path, PathBuf}; +use zokrates_common::constants as common_constants; +use zokrates_common::helpers::CurveParameter; use zokrates_core::compile::{compile, CompilationArtifacts, CompileConfig, CompileError}; use zokrates_field::{Bls12_377Field, Bls12_381Field, Bn128Field, Bw6_761Field, Field}; use zokrates_fs_resolver::FileSystemResolver; @@ -50,8 +51,8 @@ pub fn subcommand() -> App<'static, 'static> { .help("Curve to be used in the compilation") .takes_value(true) .required(false) - .possible_values(constants::CURVES) - .default_value(constants::BN128) + .possible_values(common_constants::CURVES) + .default_value(common_constants::BN128) ).arg(Arg::with_name("allow-unconstrained-variables") .long("allow-unconstrained-variables") .help("Allow unconstrained variables by inserting dummy constraints") diff --git a/zokrates_cli/src/ops/export_verifier.rs b/zokrates_cli/src/ops/export_verifier.rs index 8da06a76..a3debde5 100644 --- a/zokrates_cli/src/ops/export_verifier.rs +++ b/zokrates_cli/src/ops/export_verifier.rs @@ -1,10 +1,11 @@ use crate::constants; -use crate::helpers::{CurveParameter, SchemeParameter}; use clap::{App, Arg, ArgMatches, SubCommand}; use std::convert::TryFrom; use std::fs::File; use std::io::{BufReader, BufWriter, Write}; 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; @@ -38,8 +39,8 @@ pub fn subcommand() -> App<'static, 'static> { .help("Curve to be used to export the verifier") .takes_value(true) .required(false) - .possible_values(constants::CURVES) - .default_value(constants::BN128), + .possible_values(common_constants::CURVES) + .default_value(common_constants::BN128), ) .arg( Arg::with_name("proving-scheme") @@ -49,8 +50,8 @@ pub fn subcommand() -> App<'static, 'static> { .value_name("FILE") .takes_value(true) .required(false) - .possible_values(constants::SCHEMES) - .default_value(constants::G16), + .possible_values(common_constants::SCHEMES) + .default_value(common_constants::G16), ) } diff --git a/zokrates_cli/src/ops/generate_proof.rs b/zokrates_cli/src/ops/generate_proof.rs index 2900d8a8..4c4b7430 100644 --- a/zokrates_cli/src/ops/generate_proof.rs +++ b/zokrates_cli/src/ops/generate_proof.rs @@ -1,10 +1,11 @@ use crate::constants; -use crate::helpers::*; use clap::{App, Arg, ArgMatches, SubCommand}; use std::convert::TryFrom; use std::fs::File; use std::io::{BufReader, Read, Write}; use std::path::Path; +use zokrates_common::constants as common_constants; +use zokrates_common::helpers::*; use zokrates_core::ir; use zokrates_core::ir::ProgEnum; #[cfg(feature = "ark")] @@ -67,8 +68,8 @@ pub fn subcommand() -> App<'static, 'static> { .help("Backend to use") .takes_value(true) .required(false) - .possible_values(constants::BACKENDS) - .default_value(constants::BELLMAN), + .possible_values(common_constants::BACKENDS) + .default_value(common_constants::BELLMAN), ) .arg( Arg::with_name("proving-scheme") @@ -78,8 +79,8 @@ pub fn subcommand() -> App<'static, 'static> { .value_name("FILE") .takes_value(true) .required(false) - .possible_values(constants::SCHEMES) - .default_value(constants::G16), + .possible_values(common_constants::SCHEMES) + .default_value(common_constants::G16), ) } @@ -93,12 +94,7 @@ pub fn exec(sub_matches: &ArgMatches) -> Result<(), String> { let parameters = Parameters::try_from(( sub_matches.value_of("backend").unwrap(), - match prog { - ProgEnum::Bn128Program(_) => constants::BN128, - ProgEnum::Bls12_381Program(_) => constants::BLS12_381, - ProgEnum::Bls12_377Program(_) => constants::BLS12_377, - ProgEnum::Bw6_761Program(_) => constants::BW6_761, - }, + prog.curve(), sub_matches.value_of("proving-scheme").unwrap(), ))?; diff --git a/zokrates_cli/src/ops/setup.rs b/zokrates_cli/src/ops/setup.rs index 0e1eeae0..a1ac8617 100644 --- a/zokrates_cli/src/ops/setup.rs +++ b/zokrates_cli/src/ops/setup.rs @@ -1,10 +1,11 @@ use crate::constants; -use crate::helpers::*; use clap::{App, Arg, ArgMatches, SubCommand}; use std::convert::TryFrom; use std::fs::File; use std::io::{BufReader, Write}; use std::path::Path; +use zokrates_common::constants as common_constants; +use zokrates_common::helpers::*; use zokrates_core::ir; use zokrates_core::ir::ProgEnum; #[cfg(feature = "ark")] @@ -57,8 +58,8 @@ pub fn subcommand() -> App<'static, 'static> { .help("Backend to use") .takes_value(true) .required(false) - .possible_values(constants::BACKENDS) - .default_value(constants::BELLMAN), + .possible_values(common_constants::BACKENDS) + .default_value(common_constants::BELLMAN), ) .arg( Arg::with_name("proving-scheme") @@ -67,8 +68,8 @@ pub fn subcommand() -> App<'static, 'static> { .help("Proving scheme to use in the setup") .takes_value(true) .required(false) - .possible_values(constants::SCHEMES) - .default_value(constants::G16), + .possible_values(common_constants::SCHEMES) + .default_value(common_constants::G16), ) .arg( Arg::with_name("universal-setup-path") @@ -93,12 +94,7 @@ pub fn exec(sub_matches: &ArgMatches) -> Result<(), String> { let parameters = Parameters::try_from(( sub_matches.value_of("backend").unwrap(), - match prog { - ProgEnum::Bn128Program(_) => constants::BN128, - ProgEnum::Bls12_377Program(_) => constants::BLS12_377, - ProgEnum::Bls12_381Program(_) => constants::BLS12_381, - ProgEnum::Bw6_761Program(_) => constants::BW6_761, - }, + prog.curve(), sub_matches.value_of("proving-scheme").unwrap(), ))?; diff --git a/zokrates_cli/src/ops/universal_setup.rs b/zokrates_cli/src/ops/universal_setup.rs index 9e7674ce..696bb100 100644 --- a/zokrates_cli/src/ops/universal_setup.rs +++ b/zokrates_cli/src/ops/universal_setup.rs @@ -1,10 +1,11 @@ use crate::constants; -use crate::helpers::*; use clap::{App, Arg, ArgMatches, SubCommand}; use std::convert::TryFrom; use std::fs::File; use std::io::Write; use std::path::Path; +use zokrates_common::constants as common_constants; +use zokrates_common::helpers::*; #[cfg(feature = "ark")] use zokrates_core::proof_system::ark::Ark; #[cfg(any(feature = "bellman", feature = "ark", feature = "libsnark"))] @@ -21,8 +22,8 @@ pub fn subcommand() -> App<'static, 'static> { .help("Curve to be used in the universal setup") .takes_value(true) .required(false) - .possible_values(constants::CURVES) - .default_value(constants::BN128), + .possible_values(common_constants::CURVES) + .default_value(common_constants::BN128), ) .arg( Arg::with_name("universal-setup-path") @@ -41,8 +42,8 @@ pub fn subcommand() -> App<'static, 'static> { .help("Proving scheme to use in the setup") .takes_value(true) .required(false) - .possible_values(constants::UNIVERSAL_SCHEMES) - .default_value(constants::MARLIN), + .possible_values(common_constants::UNIVERSAL_SCHEMES) + .default_value(common_constants::MARLIN), ) .arg( Arg::with_name("size") @@ -57,7 +58,7 @@ pub fn subcommand() -> App<'static, 'static> { pub fn exec(sub_matches: &ArgMatches) -> Result<(), String> { let parameters = Parameters::try_from(( - constants::ARK, + common_constants::ARK, sub_matches.value_of("curve").unwrap(), sub_matches.value_of("proving-scheme").unwrap(), ))?; diff --git a/zokrates_cli/src/ops/verify.rs b/zokrates_cli/src/ops/verify.rs index 4a2cde55..cad4fd92 100644 --- a/zokrates_cli/src/ops/verify.rs +++ b/zokrates_cli/src/ops/verify.rs @@ -1,10 +1,11 @@ use crate::constants; -use crate::helpers::*; use clap::{App, Arg, ArgMatches, SubCommand}; use std::convert::TryFrom; use std::fs::File; use std::io::BufReader; use std::path::Path; +use zokrates_common::constants as common_constants; +use zokrates_common::helpers::*; #[cfg(feature = "ark")] use zokrates_core::proof_system::ark::Ark; #[cfg(feature = "bellman")] @@ -40,8 +41,8 @@ pub fn subcommand() -> App<'static, 'static> { .help("Backend to use") .takes_value(true) .required(false) - .possible_values(constants::BACKENDS) - .default_value(constants::BELLMAN) + .possible_values(common_constants::BACKENDS) + .default_value(common_constants::BELLMAN) ).arg(Arg::with_name("proving-scheme") .short("s") .long("proving-scheme") @@ -49,15 +50,15 @@ pub fn subcommand() -> App<'static, 'static> { .value_name("FILE") .takes_value(true) .required(false) - .default_value(constants::G16) + .default_value(common_constants::G16) ).arg(Arg::with_name("curve") .short("c") .long("curve") .help("Curve to be used in the verification") .takes_value(true) .required(false) - .possible_values(constants::CURVES) - .default_value(constants::BN128) + .possible_values(common_constants::CURVES) + .default_value(common_constants::BN128) ) } diff --git a/zokrates_common/Cargo.toml b/zokrates_common/Cargo.toml index 7caea4b8..bb36776b 100644 --- a/zokrates_common/Cargo.toml +++ b/zokrates_common/Cargo.toml @@ -6,4 +6,11 @@ edition = "2018" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html +[features] +default = ["bellman", "ark"] +bellman = [] +ark = [] +libsnark = [] + + [dependencies] \ No newline at end of file diff --git a/zokrates_common/src/constants.rs b/zokrates_common/src/constants.rs new file mode 100644 index 00000000..e678b321 --- /dev/null +++ b/zokrates_common/src/constants.rs @@ -0,0 +1,42 @@ +pub const BELLMAN: &str = "bellman"; +pub const ARK: &str = "ark"; +pub const LIBSNARK: &str = "libsnark"; + +pub const BN128: &str = "bn128"; +pub const BLS12_381: &str = "bls12_381"; +pub const BLS12_377: &str = "bls12_377"; +pub const BW6_761: &str = "bw6_761"; + +pub const G16: &str = "g16"; +pub const PGHR13: &str = "pghr13"; +pub const GM17: &str = "gm17"; +pub const MARLIN: &str = "marlin"; + +#[cfg(any(feature = "bellman", feature = "ark", feature = "libsnark"))] +pub const BACKENDS: &[&str] = if cfg!(feature = "libsnark") { + if cfg!(feature = "ark") { + if cfg!(feature = "bellman") { + &[BELLMAN, LIBSNARK, ARK] + } else { + &[LIBSNARK, ARK] + } + } else if cfg!(feature = "bellman") { + &[BELLMAN, LIBSNARK] + } else { + &[LIBSNARK] + } +} else if cfg!(feature = "ark") { + if cfg!(feature = "bellman") { + &[BELLMAN, ARK] + } else { + &[ARK] + } +} else if cfg!(feature = "bellman") { + &[BELLMAN] +} else { + &[] +}; + +pub const CURVES: &[&str] = &[BN128, BLS12_381, BLS12_377, BW6_761]; +pub const SCHEMES: &[&str] = &[G16, PGHR13, GM17, MARLIN]; +pub const UNIVERSAL_SCHEMES: &[&str] = &[MARLIN]; diff --git a/zokrates_cli/src/helpers.rs b/zokrates_common/src/helpers.rs similarity index 100% rename from zokrates_cli/src/helpers.rs rename to zokrates_common/src/helpers.rs diff --git a/zokrates_common/src/lib.rs b/zokrates_common/src/lib.rs index 17da58d7..9bfc0c79 100644 --- a/zokrates_common/src/lib.rs +++ b/zokrates_common/src/lib.rs @@ -1,3 +1,6 @@ +pub mod constants; +pub mod helpers; + use std::path::PathBuf; pub trait Resolver { diff --git a/zokrates_core/src/ir/serialize.rs b/zokrates_core/src/ir/serialize.rs index 0f247f5e..8b805e37 100644 --- a/zokrates_core/src/ir/serialize.rs +++ b/zokrates_core/src/ir/serialize.rs @@ -65,6 +65,15 @@ impl ProgEnum { Err(String::from("Wrong magic number")) } } + + pub fn curve(&self) -> &'static str { + match self { + ProgEnum::Bls12_381Program(_) => Bls12_377Field::name(), + ProgEnum::Bn128Program(_) => Bn128Field::name(), + ProgEnum::Bls12_377Program(_) => Bls12_377Field::name(), + ProgEnum::Bw6_761Program(_) => Bw6_761Field::name(), + } + } } #[cfg(test)] diff --git a/zokrates_js/Cargo.toml b/zokrates_js/Cargo.toml index fc51d484..be3d94e7 100644 --- a/zokrates_js/Cargo.toml +++ b/zokrates_js/Cargo.toml @@ -16,4 +16,7 @@ zokrates_core = { path = "../zokrates_core", features = ["wasm", "bellman", "ark zokrates_common = { path = "../zokrates_common" } zokrates_field = { path = "../zokrates_field", default-features = false, features = ["bellman"] } zokrates_abi = { path = "../zokrates_abi" } -console_error_panic_hook = "0.1.6" \ No newline at end of file +console_error_panic_hook = "0.1.6" + +[package.metadata.wasm-pack.profile.release] +wasm-opt = false \ No newline at end of file diff --git a/zokrates_js/index.d.ts b/zokrates_js/index.d.ts index b42049cc..02b21852 100644 --- a/zokrates_js/index.d.ts +++ b/zokrates_js/index.d.ts @@ -1,5 +1,9 @@ declare module 'zokrates-js' { + export type Curve = "bn128" | "bls12_381" | "bls12_377" | "bw6_761"; + export type Backend = "bellman" | "ark"; + export type Scheme = "g16" | "gm17" | "marlin"; + export type Fq = string; export type Fq2 = [Fq, Fq]; @@ -9,10 +13,10 @@ declare module 'zokrates-js' { export type ResolveCallback = (location: string, path: string) => ResolverResult; - export interface CompileConfig { - allow_unconstrained_variables?: boolean, - isolate_branches?: boolean - } + export interface CompileConfig { + allow_unconstrained_variables?: boolean, + isolate_branches?: boolean + } export interface CompileOptions { location?: string, @@ -59,13 +63,23 @@ declare module 'zokrates-js' { pk: ProvingKey, } + export type Options = { + curve: Scheme, + backend: Backend, + scheme: Curve, + } + + type AtLeast = Partial & Pick; + export interface ZoKratesProvider { compile(source: string, options?: CompileOptions): CompilationArtifacts; - setup(program: Uint8Array): SetupKeypair; computeWitness(artifacts: CompilationArtifacts, args: any[]): ComputationResult; - exportSolidityVerifier(verificationKey: VerificationKey): string; - generateProof(program: Uint8Array, witness: string, provingKey: Uint8Array): Proof; - verify(verificationKey: VerificationKey, proof: Proof): boolean; + setup(program: Uint8Array, options: AtLeast): SetupKeypair; + setupWithSrs(srs: Uint8Array, program: Uint8Array, options: AtLeast): SetupKeypair; + universalSetup(curve: Curve, size: number): Uint8Array; + exportSolidityVerifier(verificationKey: VerificationKey, options: AtLeast): string; + generateProof(program: Uint8Array, witness: string, provingKey: Uint8Array, options: AtLeast): Proof; + verify(verificationKey: VerificationKey, proof: Proof, options: Options): boolean; } export interface Metadata { diff --git a/zokrates_js/src/lib.rs b/zokrates_js/src/lib.rs index 2a9b32f6..447fa662 100644 --- a/zokrates_js/src/lib.rs +++ b/zokrates_js/src/lib.rs @@ -1,9 +1,11 @@ use serde::{Deserialize, Serialize}; use serde_json::to_string_pretty; +use std::convert::TryFrom; use std::io::Cursor; use std::path::PathBuf; use wasm_bindgen::prelude::*; use zokrates_abi::{parse_strict, Decode, Encode, Inputs}; +use zokrates_common::helpers::{BackendParameter, CurveParameter, Parameters, SchemeParameter}; use zokrates_common::Resolver; use zokrates_core::compile::{ compile as core_compile, CompilationArtifacts, CompileConfig, CompileError, @@ -82,136 +84,155 @@ impl<'a> Resolver for JsResolver<'a> { } } -pub fn setup, B: NonUniversalBackend>( - program: ir::Prog, -) -> JsValue { - let keypair = B::setup(program); - JsValue::from_serde(&keypair).unwrap() -} +mod internal { + use super::*; -pub fn setup_with_srs, B: UniversalBackend>( - srs: &[u8], - program: ir::Prog, -) -> Result { - let keypair = B::setup(srs.to_vec(), program).map_err(|e| JsValue::from_str(&e))?; - Ok(JsValue::from_serde(&keypair).unwrap()) -} + pub fn compile( + source: JsValue, + location: JsValue, + resolve_callback: &js_sys::Function, + config: JsValue, + ) -> Result { + let resolver = JsResolver::new(resolve_callback); + let fmt_error = |e: &CompileError| format!("{}:{}", e.file().display(), e.value()); -pub fn universal_setup, B: UniversalBackend>( - size: u32, -) -> JsValue { - let keypair = B::universal_setup(size); - JsValue::from_serde(&keypair).unwrap() -} - -fn generate_proof, B: Backend>( - prog: ir::Prog, - witness: JsValue, - pk: &[u8], -) -> Result { - let str_witness = witness.as_string().unwrap(); - let ir_witness: ir::Witness = ir::Witness::read(str_witness.as_bytes()) - .map_err(|err| JsValue::from_str(&format!("Could not read witness: {}", err)))?; - - let proof = B::generate_proof(prog, ir_witness, pk.to_vec()); - Ok(JsValue::from_serde(&proof).unwrap()) -} - -fn verify, B: Backend>( - vk: JsValue, - proof: JsValue, -) -> Result { - let vk: S::VerificationKey = vk.into_serde().unwrap(); - let proof: Proof = proof.into_serde().unwrap(); - - let result = B::verify(vk, proof); - Ok(JsValue::from_serde(&result).unwrap()) -} - -pub fn compile_source( - source: JsValue, - location: JsValue, - resolve_callback: &js_sys::Function, - config: JsValue, -) -> Result { - let resolver = JsResolver::new(resolve_callback); - let fmt_error = |e: &CompileError| format!("{}:{}", e.file().display(), e.value()); - - let config: CompileConfig = config.into_serde().unwrap_or_default(); - let artifacts: CompilationArtifacts = core_compile( - source.as_string().unwrap(), - PathBuf::from(location.as_string().unwrap()), - Some(&resolver), - &config, - ) - .map_err(|ce| { - JsValue::from_str( - &ce.0 - .iter() - .map(|e| fmt_error(e)) - .collect::>() - .join("\n"), + let config: CompileConfig = config.into_serde().unwrap_or_default(); + let artifacts: CompilationArtifacts = core_compile( + source.as_string().unwrap(), + PathBuf::from(location.as_string().unwrap()), + Some(&resolver), + &config, ) - })?; + .map_err(|ce| { + JsValue::from_str( + &ce.0 + .iter() + .map(|e| fmt_error(e)) + .collect::>() + .join("\n"), + ) + })?; - let program = artifacts.prog(); - let mut buffer = Cursor::new(vec![]); - program.serialize(&mut buffer); + let program = artifacts.prog(); + let mut buffer = Cursor::new(vec![]); + program.serialize(&mut buffer); - let result = CompilationResult { - program: buffer.into_inner(), - abi: to_string_pretty(artifacts.abi()).unwrap(), - }; + let result = CompilationResult { + program: buffer.into_inner(), + abi: to_string_pretty(artifacts.abi()).unwrap(), + }; - Ok(JsValue::from_serde(&result).unwrap()) -} + Ok(JsValue::from_serde(&result).unwrap()) + } -fn compute( - program: ir::Prog, - abi: JsValue, - args: JsValue, -) -> Result { - let abi: Abi = serde_json::from_str(abi.as_string().unwrap().as_str()) - .map_err(|err| JsValue::from_str(&format!("Could not deserialize abi: {}", err)))?; + pub fn compute( + program: ir::Prog, + abi: JsValue, + args: JsValue, + ) -> Result { + let abi: Abi = serde_json::from_str(abi.as_string().unwrap().as_str()) + .map_err(|err| JsValue::from_str(&format!("Could not deserialize abi: {}", err)))?; - let signature: Signature = abi.signature(); - let input = args.as_string().unwrap(); + let signature: Signature = abi.signature(); + let input = args.as_string().unwrap(); - let inputs = parse_strict(&input, signature.inputs) - .map(Inputs::Abi) - .map_err(|why| JsValue::from_str(&why.to_string()))?; + let inputs = parse_strict(&input, signature.inputs) + .map(Inputs::Abi) + .map_err(|why| JsValue::from_str(&why.to_string()))?; - let interpreter = ir::Interpreter::default(); + let interpreter = ir::Interpreter::default(); - let witness = interpreter - .execute(&program, &inputs.encode()) - .map_err(|err| JsValue::from_str(&format!("Execution failed: {}", err)))?; + let witness = interpreter + .execute(&program, &inputs.encode()) + .map_err(|err| JsValue::from_str(&format!("Execution failed: {}", err)))?; - let return_values: serde_json::Value = - zokrates_abi::Values::decode(witness.return_values(), signature.outputs).into_serde_json(); + let return_values: serde_json::Value = + zokrates_abi::Values::decode(witness.return_values(), signature.outputs) + .into_serde_json(); - let result = ComputationResult { - witness: format!("{}", witness), - output: to_string_pretty(&return_values).unwrap(), - }; + let result = ComputationResult { + witness: format!("{}", witness), + output: to_string_pretty(&return_values).unwrap(), + }; - Ok(JsValue::from_serde(&result).unwrap()) + Ok(JsValue::from_serde(&result).unwrap()) + } + + pub fn setup_non_universal, B: NonUniversalBackend>( + program: ir::Prog, + ) -> JsValue { + let keypair = B::setup(program); + JsValue::from_serde(&keypair).unwrap() + } + + pub fn setup_universal, B: UniversalBackend>( + srs: &[u8], + program: ir::Prog, + ) -> Result { + let keypair = B::setup(srs.to_vec(), program).map_err(|e| JsValue::from_str(&e))?; + Ok(JsValue::from_serde(&keypair).unwrap()) + } + + pub fn universal_setup_of_size, B: UniversalBackend>( + size: u32, + ) -> Vec { + B::universal_setup(size) + } + + pub fn generate_proof, B: Backend>( + prog: ir::Prog, + witness: JsValue, + pk: &[u8], + ) -> Result { + let str_witness = witness.as_string().unwrap(); + let ir_witness: ir::Witness = ir::Witness::read(str_witness.as_bytes()) + .map_err(|err| JsValue::from_str(&format!("Could not read witness: {}", err)))?; + + let proof = B::generate_proof(prog, ir_witness, pk.to_vec()); + Ok(JsValue::from_serde(&proof).unwrap()) + } + + pub fn verify, B: Backend>( + vk: JsValue, + proof: JsValue, + ) -> Result { + let vk: S::VerificationKey = vk.into_serde().unwrap(); + let proof: Proof = proof.into_serde().unwrap(); + + let result = B::verify(vk, proof); + Ok(JsValue::from_serde(&result).unwrap()) + } } #[wasm_bindgen] pub fn compile( - curve: JsValue, source: JsValue, location: JsValue, resolve_callback: &js_sys::Function, config: JsValue, + options: JsValue, ) -> Result { - match curve.as_string().unwrap().as_str() { - "bn128" => compile_source::(source, location, resolve_callback, config), - "bls12_381" => compile_source::(source, location, resolve_callback, config), - "bls12_377" => compile_source::(source, location, resolve_callback, config), - "bw6_761" => compile_source::(source, location, resolve_callback, config), - _ => unreachable!(), + let options: serde_json::Value = options.into_serde().unwrap(); + let curve = CurveParameter::try_from( + options["curve"] + .as_str() + .ok_or_else(|| JsValue::from_str("missing field `curve` in `options` object"))?, + ) + .map_err(|e| JsValue::from_str(&e))?; + + match curve { + CurveParameter::Bn128 => { + internal::compile::(source, location, resolve_callback, config) + } + CurveParameter::Bls12_381 => { + internal::compile::(source, location, resolve_callback, config) + } + CurveParameter::Bls12_377 => { + internal::compile::(source, location, resolve_callback, config) + } + CurveParameter::Bw6_761 => { + internal::compile::(source, location, resolve_callback, config) + } } } @@ -219,137 +240,225 @@ pub fn compile( pub fn compute_witness(program: &[u8], abi: JsValue, args: JsValue) -> Result { let p = ir::ProgEnum::deserialize(program).map_err(|err| JsValue::from_str(&err))?; match p { - ProgEnum::Bn128Program(p) => compute::<_>(p, abi, args), - ProgEnum::Bls12_381Program(p) => compute::<_>(p, abi, args), - ProgEnum::Bls12_377Program(p) => compute::<_>(p, abi, args), - ProgEnum::Bw6_761Program(p) => compute::<_>(p, abi, args), + ProgEnum::Bn128Program(p) => internal::compute::<_>(p, abi, args), + ProgEnum::Bls12_381Program(p) => internal::compute::<_>(p, abi, args), + ProgEnum::Bls12_377Program(p) => internal::compute::<_>(p, abi, args), + ProgEnum::Bw6_761Program(p) => internal::compute::<_>(p, abi, args), } } #[wasm_bindgen] -pub fn bellman_groth16_export_solidity_verifier(vk: JsValue) -> Result { - let verifier = >::export_solidity_verifier( - vk.into_serde().unwrap(), - ); +pub fn export_solidity_verifier(vk: JsValue, options: JsValue) -> Result { + let options: serde_json::Value = options.into_serde().unwrap(); + let curve = CurveParameter::try_from( + options["curve"] + .as_str() + .ok_or_else(|| JsValue::from_str("missing field `curve` in `options` object"))?, + ) + .map_err(|e| JsValue::from_str(&e))?; + + let scheme = SchemeParameter::try_from( + options["scheme"] + .as_str() + .ok_or_else(|| JsValue::from_str("missing field `scheme` in `options` object"))?, + ) + .map_err(|e| JsValue::from_str(&e))?; + + let verifier = match (curve, scheme) { + (CurveParameter::Bn128, SchemeParameter::G16) => Ok(>::export_solidity_verifier( + vk.into_serde().unwrap() + )), + (CurveParameter::Bn128, SchemeParameter::GM17) => Ok(>::export_solidity_verifier( + vk.into_serde().unwrap() + )), + _ => Err(JsValue::from_str("Could not export solidity verifier")), + }?; + Ok(JsValue::from_str(verifier.as_str())) } #[wasm_bindgen] -pub fn bellman_groth16_setup(program: &[u8]) -> Result { - let p = ir::ProgEnum::deserialize(program).map_err(|err| JsValue::from_str(&err))?; - match p { - ProgEnum::Bn128Program(p) => Ok(setup::<_, G16, Bellman>(p)), - ProgEnum::Bls12_381Program(p) => Ok(setup::<_, G16, Bellman>(p)), - _ => unreachable!(), // TODO: reachable +pub fn setup(program: &[u8], options: JsValue) -> Result { + let options: serde_json::Value = options.into_serde().unwrap(); + let backend = options["backend"] + .as_str() + .ok_or_else(|| JsValue::from_str("missing field `backend` in `options` object"))?; + + let scheme = options["scheme"] + .as_str() + .ok_or_else(|| JsValue::from_str("missing field `scheme` in `options` object"))?; + + let prog = ir::ProgEnum::deserialize(program).map_err(|err| JsValue::from_str(&err))?; + let parameters = + Parameters::try_from((backend, prog.curve(), scheme)).map_err(|e| JsValue::from_str(&e))?; + + match parameters { + Parameters(BackendParameter::Bellman, _, SchemeParameter::G16) => match prog { + ProgEnum::Bn128Program(p) => Ok(internal::setup_non_universal::<_, G16, Bellman>(p)), + ProgEnum::Bls12_381Program(p) => { + Ok(internal::setup_non_universal::<_, G16, Bellman>(p)) + } + _ => unreachable!(), + }, + Parameters(BackendParameter::Ark, _, SchemeParameter::GM17) => match prog { + ProgEnum::Bn128Program(p) => Ok(internal::setup_non_universal::<_, GM17, Ark>(p)), + ProgEnum::Bls12_377Program(p) => Ok(internal::setup_non_universal::<_, GM17, Ark>(p)), + ProgEnum::Bw6_761Program(p) => Ok(internal::setup_non_universal::<_, GM17, Ark>(p)), + _ => unreachable!(), + }, + _ => Err(JsValue::from_str("Unsupported combination of parameters")), } } #[wasm_bindgen] -pub fn ark_gm17_setup(program: &[u8]) -> Result { - let p = ir::ProgEnum::deserialize(program).map_err(|err| JsValue::from_str(&err))?; - match p { - ProgEnum::Bn128Program(p) => Ok(setup::<_, GM17, Ark>(p)), - ProgEnum::Bls12_377Program(p) => Ok(setup::<_, GM17, Ark>(p)), - ProgEnum::Bw6_761Program(p) => Ok(setup::<_, GM17, Ark>(p)), - _ => unreachable!(), // TODO: reachable +pub fn setup_with_srs(srs: &[u8], program: &[u8], options: JsValue) -> Result { + let options: serde_json::Value = options.into_serde().unwrap(); + let backend = options["backend"] + .as_str() + .ok_or_else(|| JsValue::from_str("missing field `backend` in `options` object"))?; + + let scheme = options["scheme"] + .as_str() + .ok_or_else(|| JsValue::from_str("missing field `scheme` in `options` object"))?; + + let prog = ir::ProgEnum::deserialize(program).map_err(|err| JsValue::from_str(&err))?; + let parameters = + Parameters::try_from((backend, prog.curve(), scheme)).map_err(|e| JsValue::from_str(&e))?; + + match parameters { + Parameters(BackendParameter::Ark, _, SchemeParameter::MARLIN) => match prog { + ProgEnum::Bn128Program(p) => internal::setup_universal::<_, Marlin, Ark>(srs, p), + ProgEnum::Bls12_377Program(p) => internal::setup_universal::<_, Marlin, Ark>(srs, p), + ProgEnum::Bw6_761Program(p) => internal::setup_universal::<_, Marlin, Ark>(srs, p), + _ => unreachable!(), + }, + _ => Err(JsValue::from_str("Unsupported combination of parameters")), } } #[wasm_bindgen] -pub fn ark_marlin_setup(srs: &[u8], program: &[u8]) -> Result { - let p = ir::ProgEnum::deserialize(program).map_err(|err| JsValue::from_str(&err))?; - match p { - ProgEnum::Bn128Program(p) => setup_with_srs::<_, Marlin, Ark>(srs, p), - ProgEnum::Bls12_377Program(p) => setup_with_srs::<_, Marlin, Ark>(srs, p), - ProgEnum::Bw6_761Program(p) => setup_with_srs::<_, Marlin, Ark>(srs, p), - _ => unreachable!(), // TODO: reachable +pub fn universal_setup(curve: JsValue, size: u32) -> Result, JsValue> { + let curve = CurveParameter::try_from(curve.as_string().unwrap().as_str()) + .map_err(|e| JsValue::from_str(&e))?; + + match curve { + CurveParameter::Bn128 => { + Ok(internal::universal_setup_of_size::(size)) + } + CurveParameter::Bls12_377 => Ok(internal::universal_setup_of_size::< + Bls12_377Field, + Marlin, + Ark, + >(size)), + CurveParameter::Bw6_761 => { + Ok(internal::universal_setup_of_size::(size)) + } + c => Err(JsValue::from_str(&format!( + "Unsupported curve `{:?}` provided in universal setup", + c + ))), } } #[wasm_bindgen] -pub fn ark_marlin_universal_setup(curve: JsValue, size: u32) -> Result { - match curve.as_string().unwrap().as_str() { - "bn128" => Ok(universal_setup::(size)), - "bls12_377" => Ok(universal_setup::(size)), - "bw6_761" => Ok(universal_setup::(size)), +pub fn generate_proof( + program: &[u8], + witness: JsValue, + pk: &[u8], + options: JsValue, +) -> Result { + let options: serde_json::Value = options.into_serde().unwrap(); + let backend = options["backend"] + .as_str() + .ok_or_else(|| JsValue::from_str("missing field `backend` in `options` object"))?; + + let scheme = options["scheme"] + .as_str() + .ok_or_else(|| JsValue::from_str("missing field `scheme` in `options` object"))?; + + let prog = ir::ProgEnum::deserialize(program).map_err(|err| JsValue::from_str(&err))?; + let parameters = + Parameters::try_from((backend, prog.curve(), scheme)).map_err(|e| JsValue::from_str(&e))?; + + match parameters { + Parameters(BackendParameter::Bellman, _, SchemeParameter::G16) => match prog { + ProgEnum::Bn128Program(p) => { + internal::generate_proof::<_, G16, Bellman>(p, witness, pk) + } + ProgEnum::Bls12_381Program(p) => { + internal::generate_proof::<_, G16, Bellman>(p, witness, pk) + } + _ => unreachable!(), + }, + Parameters(BackendParameter::Ark, _, SchemeParameter::GM17) => match prog { + ProgEnum::Bn128Program(p) => internal::generate_proof::<_, GM17, Ark>(p, witness, pk), + ProgEnum::Bls12_377Program(p) => { + internal::generate_proof::<_, GM17, Ark>(p, witness, pk) + } + ProgEnum::Bw6_761Program(p) => internal::generate_proof::<_, GM17, Ark>(p, witness, pk), + _ => unreachable!(), + }, + Parameters(BackendParameter::Ark, _, SchemeParameter::MARLIN) => match prog { + ProgEnum::Bn128Program(p) => internal::generate_proof::<_, Marlin, Ark>(p, witness, pk), + ProgEnum::Bls12_377Program(p) => { + internal::generate_proof::<_, Marlin, Ark>(p, witness, pk) + } + ProgEnum::Bw6_761Program(p) => { + internal::generate_proof::<_, Marlin, Ark>(p, witness, pk) + } + _ => unreachable!(), + }, _ => unreachable!(), } } #[wasm_bindgen] -pub fn bellman_groth16_generate_proof( - program: &[u8], - witness: JsValue, - pk: &[u8], -) -> Result { - let p = ir::ProgEnum::deserialize(program).map_err(|err| JsValue::from_str(&err))?; - match p { - ProgEnum::Bn128Program(p) => generate_proof::<_, G16, Bellman>(p, witness, pk), - ProgEnum::Bls12_381Program(p) => generate_proof::<_, G16, Bellman>(p, witness, pk), - _ => unreachable!(), // TODO: reachable - } -} +pub fn verify(vk: JsValue, proof: JsValue, options: JsValue) -> Result { + let options: serde_json::Value = options.into_serde().unwrap(); + let backend = options["backend"] + .as_str() + .ok_or_else(|| JsValue::from_str("missing field `backend` in `options` object"))?; -#[wasm_bindgen] -pub fn ark_gm17_generate_proof( - program: &[u8], - witness: JsValue, - pk: &[u8], -) -> Result { - let p = ir::ProgEnum::deserialize(program).map_err(|err| JsValue::from_str(&err))?; - match p { - ProgEnum::Bn128Program(p) => generate_proof::<_, GM17, Ark>(p, witness, pk), - ProgEnum::Bls12_377Program(p) => generate_proof::<_, GM17, Ark>(p, witness, pk), - ProgEnum::Bw6_761Program(p) => generate_proof::<_, GM17, Ark>(p, witness, pk), - _ => unreachable!(), // TODO: reachable - } -} + let curve = options["curve"] + .as_str() + .ok_or_else(|| JsValue::from_str("missing field `curve` in `options` object"))?; -#[wasm_bindgen] -pub fn ark_marlin_generate_proof( - program: &[u8], - witness: JsValue, - pk: &[u8], -) -> Result { - let p = ir::ProgEnum::deserialize(program).map_err(|err| JsValue::from_str(&err))?; - match p { - ProgEnum::Bn128Program(p) => generate_proof::<_, Marlin, Ark>(p, witness, pk), - ProgEnum::Bls12_377Program(p) => generate_proof::<_, Marlin, Ark>(p, witness, pk), - ProgEnum::Bw6_761Program(p) => generate_proof::<_, Marlin, Ark>(p, witness, pk), - _ => unreachable!(), // TODO: reachable - } -} + let scheme = options["scheme"] + .as_str() + .ok_or_else(|| JsValue::from_str("missing field `scheme` in `options` object"))?; -#[wasm_bindgen] -pub fn bellman_groth16_verify( - vk: JsValue, - proof: JsValue, - curve: JsValue, -) -> Result { - match curve.as_string().unwrap().as_str() { - "bn128" => verify::(vk, proof), - "bls12_381" => verify::(vk, proof), - _ => unreachable!(), // TODO: reachable - } -} + let parameters = Parameters::try_from((backend, curve, scheme))?; -#[wasm_bindgen] -pub fn ark_gm17_verify(vk: JsValue, proof: JsValue, curve: JsValue) -> Result { - match curve.as_string().unwrap().as_str() { - "bn128" => verify::(vk, proof), - "bls12_377" => verify::(vk, proof), - "bw6_761" => verify::(vk, proof), - _ => unreachable!(), // TODO: reachable - } -} - -#[wasm_bindgen] -pub fn ark_marlin_verify(vk: JsValue, proof: JsValue, curve: JsValue) -> Result { - match curve.as_string().unwrap().as_str() { - "bn128" => verify::(vk, proof), - "bls12_377" => verify::(vk, proof), - "bw6_761" => verify::(vk, proof), - _ => unreachable!(), // TODO: reachable + match parameters { + Parameters(BackendParameter::Bellman, CurveParameter::Bn128, SchemeParameter::G16) => { + internal::verify::(vk, proof) + } + Parameters(BackendParameter::Bellman, CurveParameter::Bls12_381, SchemeParameter::G16) => { + internal::verify::(vk, proof) + } + Parameters(BackendParameter::Ark, CurveParameter::Bls12_377, SchemeParameter::GM17) => { + internal::verify::(vk, proof) + } + Parameters(BackendParameter::Ark, CurveParameter::Bw6_761, SchemeParameter::GM17) => { + internal::verify::(vk, proof) + } + Parameters(BackendParameter::Ark, CurveParameter::Bn128, SchemeParameter::GM17) => { + internal::verify::(vk, proof) + } + Parameters(BackendParameter::Ark, CurveParameter::Bls12_377, SchemeParameter::MARLIN) => { + internal::verify::(vk, proof) + } + Parameters(BackendParameter::Ark, CurveParameter::Bw6_761, SchemeParameter::MARLIN) => { + internal::verify::(vk, proof) + } + Parameters(BackendParameter::Ark, CurveParameter::Bn128, SchemeParameter::MARLIN) => { + internal::verify::(vk, proof) + } + _ => unreachable!(), } } diff --git a/zokrates_js/tests/tests.js b/zokrates_js/tests/tests.js index d3c600d1..7e8f8a4a 100644 --- a/zokrates_js/tests/tests.js +++ b/zokrates_js/tests/tests.js @@ -86,6 +86,12 @@ describe('tests', function() { describe("bellman", () => { describe("groth16", () => { + const options = { + backend: "bellman", + curve: "bn128", + scheme: "g16" + }; + let artifacts; let computationResult; let keypair; @@ -100,39 +106,45 @@ describe('tests', function() { it("setup", () => { assert.doesNotThrow(() => { - keypair = zokrates.bellman.groth16.setup(artifacts.program); + keypair = zokrates.setup(artifacts.program, options); }); }); it("generate proof", () => { assert.doesNotThrow(() => { - proof = zokrates.bellman.groth16.generateProof(artifacts.program, computationResult.witness, keypair.pk); + proof = zokrates.generateProof(artifacts.program, computationResult.witness, keypair.pk, options); assert.ok(proof !== undefined); assert.deepEqual(proof.inputs, ["0x0000000000000000000000000000000000000000000000000000000000000004"]); }); }); it("export solidity verifier", () => { - let verifier = zokrates.bellman.groth16.exportSolidityVerifier(keypair.vk); + let verifier = zokrates.exportSolidityVerifier(keypair.vk, options); assert(verifier.length > 0); }); it("verify with valid proof", () => { assert.doesNotThrow(() => { - assert(zokrates.bellman.groth16.verify(keypair.vk, proof) === true); + assert(zokrates.verify(keypair.vk, proof, options) === true); }); }); it("verify with invalid proof", () => { // falsify proof proof["proof"]["a"][0] = "0x0000000000000000000000000000000000000000000000000000000000000000"; - assert(zokrates.bellman.groth16.verify(keypair.vk, proof) === false); + assert(zokrates.verify(keypair.vk, proof, options) === false); }); }); }); describe("ark", () => { describe("gm17", () => { + const options = { + backend: "ark", + curve: "bn128", + scheme: "gm17" + }; + let artifacts; let computationResult; let keypair; @@ -147,13 +159,13 @@ describe('tests', function() { it("setup", () => { assert.doesNotThrow(() => { - keypair = zokrates.ark.gm17.setup(artifacts.program); + keypair = zokrates.setup(artifacts.program, options); }); }); it("generate proof", () => { assert.doesNotThrow(() => { - proof = zokrates.ark.gm17.generateProof(artifacts.program, computationResult.witness, keypair.pk); + proof = zokrates.generateProof(artifacts.program, computationResult.witness, keypair.pk, options); assert.ok(proof !== undefined); assert.deepEqual(proof.inputs, ["0x0000000000000000000000000000000000000000000000000000000000000004"]); }); @@ -161,18 +173,24 @@ describe('tests', function() { it("verify with valid proof", () => { assert.doesNotThrow(() => { - assert(zokrates.ark.gm17.verify(keypair.vk, proof) === true); + assert(zokrates.verify(keypair.vk, proof, options) === true); }); }); it("verify with invalid proof", () => { // falsify proof proof["proof"]["a"][0] = "0x0000000000000000000000000000000000000000000000000000000000000000"; - assert(zokrates.ark.gm17.verify(keypair.vk, proof) === false); + assert(zokrates.verify(keypair.vk, proof, options) === false); }); }); describe("marlin", () => { + const options = { + backend: "ark", + curve: "bn128", + scheme: "marlin" + }; + let artifacts; let computationResult; let keypair; @@ -187,14 +205,14 @@ describe('tests', function() { it("setup", () => { assert.doesNotThrow(() => { - const srs = zokrates.ark.marlin.universalSetup("bn128", 4); - keypair = zokrates.ark.marlin.setup(srs, artifacts.program); + const srs = zokrates.universalSetup("bn128", 4); + keypair = zokrates.setupWithSrs(srs, artifacts.program, options); }); }); it("generate proof", () => { assert.doesNotThrow(() => { - proof = zokrates.ark.marlin.generateProof(artifacts.program, computationResult.witness, keypair.pk); + proof = zokrates.generateProof(artifacts.program, computationResult.witness, keypair.pk, options); assert.ok(proof !== undefined); assert.deepEqual(proof.inputs, ["0x0000000000000000000000000000000000000000000000000000000000000001"]); }); @@ -202,14 +220,14 @@ describe('tests', function() { it("verify with valid proof", () => { assert.doesNotThrow(() => { - assert(zokrates.ark.marlin.verify(keypair.vk, proof) === true); + assert(zokrates.verify(keypair.vk, proof, options) === true); }); }); it("verify with invalid proof", () => { // falsify proof proof["inputs"][0] = "0x0000000000000000000000000000000000000000000000000000000000000000"; - assert(zokrates.ark.marlin.verify(keypair.vk, proof) === false); + assert(zokrates.verify(keypair.vk, proof, options) === false); }); }); }); diff --git a/zokrates_js/wrapper.js b/zokrates_js/wrapper.js index 7fc5fa7c..b94cd7be 100644 --- a/zokrates_js/wrapper.js +++ b/zokrates_js/wrapper.js @@ -25,7 +25,6 @@ const getImportPath = (currentLocation, importLocation) => { } module.exports = (dep) => { - const { zokrates, stdlib } = dep; const resolveFromStdlib = (currentLocation, importLocation) => { @@ -40,7 +39,7 @@ module.exports = (dep) => { const callback = (currentLocation, importLocation) => { return resolveFromStdlib(currentLocation, importLocation) || resolveCallback(currentLocation, importLocation); }; - const { program, abi } = zokrates.compile(curve, source, location, callback, config); + const { program, abi } = zokrates.compile(source, location, callback, config, { curve }); return { program: new Uint8Array(program), abi @@ -50,26 +49,23 @@ module.exports = (dep) => { const { program, abi } = artifacts; return zokrates.compute_witness(program, abi, JSON.stringify(Array.from(args))); }, - bellman: { - groth16: { - setup: (program) => zokrates.bellman_groth16_setup(program), - generateProof: (program, witness, provingKey) => zokrates.bellman_groth16_generate_proof(program, witness, provingKey), - exportSolidityVerifier: (vk) => zokrates.bellman_groth16_export_solidity_verifier(vk), - verify: (vk, proof, curve = "bn128") => zokrates.bellman_groth16_verify(vk, proof, curve) - } + setup: (program, options) => { + return zokrates.setup(program, options); }, - ark: { - gm17: { - setup: (program) => zokrates.ark_gm17_setup(program), - generateProof: (program, witness, provingKey) => zokrates.ark_gm17_generate_proof(program, witness, provingKey), - verify: (vk, proof, curve = "bn128") => zokrates.ark_gm17_verify(vk, proof, curve) - }, - marlin: { - setup: (srs, program) => zokrates.ark_marlin_setup(srs, program), - universalSetup: (curve, size) => zokrates.ark_marlin_universal_setup(curve, size), - generateProof: (program, witness, provingKey) => zokrates.ark_marlin_generate_proof(program, witness, provingKey), - verify: (vk, proof, curve = "bn128") => zokrates.ark_marlin_verify(vk, proof, curve) - } + universalSetup: (curve, size) => { + return zokrates.universal_setup(curve, size); + }, + setupWithSrs: (srs, program, options) => { + return zokrates.setup_with_srs(srs, program, options); + }, + generateProof: (program, witness, provingKey, options) => { + return zokrates.generate_proof(program, witness, provingKey, options); + }, + verify: (vk, proof, options) => { + return zokrates.verify(vk, proof, options); + }, + exportSolidityVerifier: (vk, options) => { + return zokrates.export_solidity_verifier(vk, options); } } }; \ No newline at end of file