diff --git a/Cargo.toml b/Cargo.toml index 254a1e5..aede873 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,11 +14,10 @@ crate-type = ["rlib"] [[bin]] path = "src/setup/main.rs" name = "libzeropool-setup" -required-features = ["cli_libzeropool_setup"] +required-features = ["cli_libzeropool_setup"] [dependencies] -fawkes-crypto = { version = "4.3.3", features = ["rand_support"] } - +fawkes-crypto = { git = "https://github.com/zeropoolnetwork/fawkes-crypto", branch = "fix/plonk-fixes", default-features = false, features = ["rand_support", "borsh_support", "serde_support"] } sha3 = "0.9.1" serde = { version = "1.0", features = ["derive"] } @@ -27,14 +26,24 @@ lazy_static = "1.4.0" chacha20poly1305 = "0.8.0" clap={ package = "clap-v3", version = "3.0.0-beta.1", optional=true} convert_case = "0.4.0" +near-halo2-verifier = { git = "https://github.com/zeropoolnetwork/near-halo2-verifier", branch = "master", optional = true } [features] in1out127=[] in3out127=[] in7ount127=[] in15out127=[] -cli_libzeropool_setup = ["clap", "fawkes-crypto/rand_support", "fawkes-crypto/backend_bellman_groth16"] -default=["cli_libzeropool_setup", "in3out127"] +cli_libzeropool_setup = ["clap"] +cli_libzeropool_setup_plonk = ["cli_libzeropool_setup", "plonk", "near-halo2-verifier"] +default=["in3out127"] +plonk=["fawkes-crypto/plonk"] +groth16=["fawkes-crypto/r1cs", "fawkes-crypto/backend_bellman_groth16"] [dev-dependencies] -fawkes-crypto = { version = "4.3.3", features = ["rand_support", "backend_bellman_groth16"] } +fawkes-crypto = { git = "https://github.com/zeropoolnetwork/fawkes-crypto", branch = "fix/plonk-fixes", default-features = false, features = ["rand_support", "borsh_support", "serde_support"] } + +[patch."https://github.com/privacy-scaling-explorations/halo2curves"] +halo2curves = { git = "https://github.com/zeropoolnetwork/halo2curves", branch = "zeropool-near" } + +[patch.crates-io] +parity-secp256k1 = { git = "https://github.com/paritytech/rust-secp256k1" } \ No newline at end of file diff --git a/src/lib.rs b/src/lib.rs index 1bbf856..7bce080 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,9 @@ +#[cfg(all(feature = "r1cs", feature = "plonk"))] +compile_error!("Features \"groth16\" and \"plonk\" are mutually exclusive"); + +#[cfg(not(any(feature = "groth16", feature = "plonk")))] +compile_error!("At least one of features \"r1cs\" and \"plonk\" must be enabled"); + #[macro_use] pub extern crate fawkes_crypto; diff --git a/src/setup/cli_groth16.rs b/src/setup/cli_groth16.rs new file mode 100644 index 0000000..ffdae8b --- /dev/null +++ b/src/setup/cli_groth16.rs @@ -0,0 +1,237 @@ + + +use libzeropool::{ + POOL_PARAMS, + circuit::tree::{tree_update, CTreePub, CTreeSec}, + circuit::tx::{c_transfer, CTransferPub, CTransferSec}, + clap::Clap, +}; +use core::panic; +use std::{fs::File, io::Write}; + +use fawkes_crypto::engines::bn256::Fr; +use fawkes_crypto::backend::bellman_groth16::engines::Bn256; +use fawkes_crypto::ff_uint::Num; +use fawkes_crypto::backend::bellman_groth16::{verifier::{VK, verify}, prover::{Proof, prove}, setup::setup, Parameters}; +use crate::evm_verifier::generate_sol_data; +use fawkes_crypto::circuit::cs::CS; +use fawkes_crypto::rand::rngs::OsRng; +use libzeropool::helpers::sample_data::State; +use convert_case::{Case, Casing}; + +#[derive(Clap)] +struct Opts { + #[clap(subcommand)] + command: SubCommand, +} + +#[derive(Clap)] +enum SubCommand { + /// Generate a SNARK proof + Prove(ProveOpts), + /// Verify a SNARK proof + Verify(VerifyOpts), + /// Generate trusted setup parameters + Setup(SetupOpts), + /// Generate verifier smart contract + GenerateVerifier(GenerateVerifierOpts), + /// Generate test object + GenerateTestData(GenerateTestDataOpts), +} + +/// A subcommand for generating a SNARK proof +#[derive(Clap)] +struct ProveOpts { + /// Circuit for prooving (transfer|tree_update) + #[clap(short = "c", long = "circuit", default_value = "transfer")] + circuit: String, + /// Snark trusted setup parameters file + #[clap(short = "p", long = "params")] + params: Option, + /// Input object JSON file + #[clap(short = "o", long = "object")] + object: Option, + /// Output file for proof JSON + #[clap(short = "r", long = "proof")] + proof: Option, + /// Output file for public inputs JSON + #[clap(short = "i", long = "inputs")] + inputs: Option, +} + +/// A subcommand for verifying a SNARK proof +#[derive(Clap)] +struct VerifyOpts { + /// Circuit for verifying (transfer|tree_update) + #[clap(short = "c", long = "circuit", default_value = "transfer")] + circuit: String, + /// Snark verification key + #[clap(short = "v", long = "vk")] + vk: Option, + /// Proof JSON file + #[clap(short = "r", long = "proof")] + proof: Option, + /// Public inputs JSON file + #[clap(short = "i", long = "inputs")] + inputs: Option, +} + +/// A subcommand for generating a trusted setup parameters +#[derive(Clap)] +struct SetupOpts { + /// Circuit for parameter generation (transfer|tree_update) + #[clap(short = "c", long = "circuit", default_value = "transfer")] + circuit: String, + /// Snark trusted setup parameters file + #[clap(short = "p", long = "params")] + params: Option, + /// Snark verifying key file + #[clap(short = "v", long = "vk")] + vk: Option, +} + +/// A subcommand for generating a Solidity verifier smart contract +#[derive(Clap)] +struct GenerateVerifierOpts { + /// Circuit for verifying (transfer|tree_update) + #[clap(short = "c", long = "circuit", default_value = "transfer")] + circuit: String, + /// Snark verification key + #[clap(short = "v", long = "vk")] + vk: Option, + /// Smart contract name + #[clap(short = "n", long = "name")] + contract_name: Option, + /// Output file name + #[clap(short = "s", long = "solidity")] + solidity: Option, +} + +#[derive(Clap)] +struct GenerateTestDataOpts { + /// Circuit for testing (transfer|tree_update) + #[clap(short = "c", long = "circuit", default_value = "transfer")] + circuit: String, + /// Input object JSON file + #[clap(short = "o", long = "object")] + object: Option +} + +fn tree_circuit>(public: CTreePub, secret: CTreeSec) { + tree_update(&public, &secret, &*POOL_PARAMS); +} + +fn tx_circuit>(public: CTransferPub, secret: CTransferSec) { + c_transfer(&public, &secret, &*POOL_PARAMS); +} + +fn cli_setup(o:SetupOpts) { + let params_path = o.params.unwrap_or(format!("{}_params.bin", o.circuit)); + let vk_path = o.vk.unwrap_or(format!("{}_verification_key.json", o.circuit)); + + + let params = match o.circuit.as_str() { + "tree_update" => setup::(tree_circuit), + "transfer" => setup::(tx_circuit), + _ => panic!("Wrong cicruit parameter") + }; + + let vk = params.get_vk(); + let vk_str = serde_json::to_string_pretty(&vk).unwrap(); + + let mut fp = File::create(params_path).unwrap(); + params.write(&mut fp).unwrap(); + std::fs::write(vk_path, &vk_str.into_bytes()).unwrap(); + println!("setup OK"); +} + +fn cli_generate_verifier(o: GenerateVerifierOpts) { + let circuit = o.circuit.clone(); + let vk_path = o.vk.unwrap_or(format!("{}_verification_key.json", circuit)); + let contract_name = o.contract_name.unwrap_or(format!("{}_verifier", circuit).to_case(Case::Pascal)); + let solidity_path = o.solidity.unwrap_or(format!("{}_verifier.sol", circuit)); + + + let vk_str = std::fs::read_to_string(vk_path).unwrap(); + let vk :VK = serde_json::from_str(&vk_str).unwrap(); + let sol_str = generate_sol_data(&vk, contract_name); + File::create(solidity_path).unwrap().write(&sol_str.into_bytes()).unwrap(); + println!("solidity verifier generated") +} + +fn cli_verify(o:VerifyOpts) { + let proof_path = o.proof.unwrap_or(format!("{}_proof.json", o.circuit)); + let vk_path = o.vk.unwrap_or(format!("{}_verification_key.json", o.circuit)); + let inputs_path = o.inputs.unwrap_or(format!("{}_inputs.json", o.circuit)); + + let vk_str = std::fs::read_to_string(vk_path).unwrap(); + let proof_str = std::fs::read_to_string(proof_path).unwrap(); + let public_inputs_str = std::fs::read_to_string(inputs_path).unwrap(); + + let vk:VK = serde_json::from_str(&vk_str).unwrap(); + let proof:Proof = serde_json::from_str(&proof_str).unwrap(); + let public_inputs:Vec> = serde_json::from_str(&public_inputs_str).unwrap(); + + println!("Verify result is {}.", verify(&vk, &proof, &public_inputs)) +} + +fn cli_generate_test_data(o:GenerateTestDataOpts) { + let object_path = o.object.unwrap_or(format!("{}_object.json", o.circuit)); + + match o.circuit.as_str() { + "transfer" => { + let mut rng = OsRng::default(); + let state = State::random_sample_state(&mut rng, &*POOL_PARAMS); + let data = state.random_sample_transfer(&mut rng, &*POOL_PARAMS); + let data_str = serde_json::to_string_pretty(&data).unwrap(); + std::fs::write(object_path, &data_str.into_bytes()).unwrap(); + }, + "tree_update" => std::unimplemented!(), + _ => panic!("Wrong cicruit parameter") + } + + println!("Test data generated") + +} + +fn cli_prove(o:ProveOpts) { + let params_path = o.params.unwrap_or(format!("{}_params.bin", o.circuit)); + let object_path = o.object.unwrap_or(format!("{}_object.json", o.circuit)); + let proof_path = o.proof.unwrap_or(format!("{}_proof.json", o.circuit)); + let inputs_path = o.inputs.unwrap_or(format!("{}_inputs.json", o.circuit)); + + let params_data = std::fs::read(params_path).unwrap(); + let mut params_data_cur = ¶ms_data[..]; + + let params = Parameters::::read(&mut params_data_cur, false, false).unwrap(); + let object_str = std::fs::read_to_string(object_path).unwrap(); + + let (inputs, snark_proof) = if o.circuit.eq("tree_update") { + let (public, secret) = serde_json::from_str(&object_str).unwrap(); + prove(¶ms, &public, &secret, tree_circuit) + } else { + let (public, secret) = serde_json::from_str(&object_str).unwrap(); + prove(¶ms, &public, &secret, tx_circuit) + }; + + + let proof_str = serde_json::to_string_pretty(&snark_proof).unwrap(); + let inputs_str = serde_json::to_string_pretty(&inputs).unwrap(); + + std::fs::write(proof_path, &proof_str.into_bytes()).unwrap(); + std::fs::write(inputs_path, &inputs_str.into_bytes()).unwrap(); + + println!("Proved") +} + + +pub fn main() { + let opts: Opts = Opts::parse(); + match opts.command { + SubCommand::Prove(o) => cli_prove(o), + SubCommand::Verify(o) => cli_verify(o), + SubCommand::Setup(o) => cli_setup(o), + SubCommand::GenerateVerifier(o) => cli_generate_verifier(o), + SubCommand::GenerateTestData(o) => cli_generate_test_data(o) + } +} diff --git a/src/setup/cli_plonk.rs b/src/setup/cli_plonk.rs new file mode 100644 index 0000000..64a9e02 --- /dev/null +++ b/src/setup/cli_plonk.rs @@ -0,0 +1,103 @@ +use std::fs::File; +use std::io::Write; + +use clap::Clap; +use fawkes_crypto::{backend::plonk::{Parameters, engines::Bn256}, BorshSerialize, circuit::cs::CS}; +use fawkes_crypto::backend::plonk::setup::setup; +use fawkes_crypto::engines::bn256::Fr; +use near_halo2_verifier::PlonkVerifierData; +use libzeropool::circuit::tree::{CTreePub, CTreeSec, tree_update}; +use libzeropool::circuit::tx::{c_transfer, CTransferPub, CTransferSec}; +use libzeropool::POOL_PARAMS; + +pub fn main() { + let opts: Opts = Opts::parse(); + match opts.command { + SubCommand::Setup(o) => cli_setup(o), + } +} + +fn tree_circuit>(public: CTreePub, secret: CTreeSec) { + tree_update(&public, &secret, &*POOL_PARAMS); +} + +fn tx_circuit>(public: CTransferPub, secret: CTransferSec) { + c_transfer(&public, &secret, &*POOL_PARAMS); +} + +fn cli_setup(o:SetupOpts) { + let params_path = o.params.unwrap_or("plonk_params.bin".to_string()); + + let params = if !std::path::Path::new(¶ms_path).exists() { + let params: Parameters = Parameters::setup(o.k); + println!("setup OK"); + let mut fp = File::create(params_path).unwrap(); + params.write(&mut fp).unwrap(); + params + } else { + let mut fp = File::open(params_path).unwrap(); + Parameters::read(&mut fp).unwrap() + }; + + let (vk, pk) = setup(¶ms, tree_circuit); + + let mut buf = Vec::new(); + vk.write(&mut buf).unwrap(); + let mut fp = File::create("tree_vk.bin").unwrap(); + fp.write_all(&buf).unwrap(); + + let mut buf = Vec::new(); + pk.write(&mut buf).unwrap(); + let mut fp = File::create("tree_pk.bin").unwrap(); + fp.write_all(&buf).unwrap(); + + let tree_vd = PlonkVerifierData::new(params.0.clone(), vk.0, 3); + let tree_vd_bytes = tree_vd.try_to_vec().unwrap(); + let mut fp = File::create("tree_vd.bin").unwrap(); + fp.write_all(&tree_vd_bytes).unwrap(); + + println!("tree OK"); + + let (vk, pk) = setup(¶ms, tx_circuit); + + let mut buf = Vec::new(); + vk.write(&mut buf).unwrap(); + let mut fp = File::create("transfer_vk.bin").unwrap(); + fp.write_all(&buf).unwrap(); + + let mut buf = Vec::new(); + pk.write(&mut buf).unwrap(); + let mut fp = File::create("transfer_pk.bin").unwrap(); + fp.write_all(&buf).unwrap(); + + let tx_vd = PlonkVerifierData::new(params.0.clone(), vk.0, 5); + let tx_vd_bytes = tx_vd.try_to_vec().unwrap(); + let mut fp = File::create("transfer_vd.bin").unwrap(); + fp.write_all(&tx_vd_bytes).unwrap(); + + println!("tx OK"); +} + +#[derive(Clap)] +struct Opts { + #[clap(subcommand)] + command: SubCommand, +} + +#[derive(Clap)] +enum SubCommand { + /// Generate trusted setup parameters + Setup(SetupOpts), +} + +/// A subcommand for generating a trusted setup parameters +#[derive(Clap)] +struct SetupOpts { + /// Snark trusted setup parameters file + #[clap(short = "p", long = "params")] + params: Option, + /// Security parameter + #[clap(short = "k", default_value = "20")] + k: usize, +} + diff --git a/src/setup/main.rs b/src/setup/main.rs index b0e194d..67dcaa6 100644 --- a/src/setup/main.rs +++ b/src/setup/main.rs @@ -1,237 +1,13 @@ +#[cfg(feature = "groth16")] +mod cli_groth16; +#[cfg(feature = "groth16")] mod evm_verifier; - -use libzeropool::{ - POOL_PARAMS, - circuit::tree::{tree_update, CTreePub, CTreeSec}, - circuit::tx::{c_transfer, CTransferPub, CTransferSec}, - clap::Clap, -}; -use core::panic; -use std::{fs::File, io::Write}; - -use fawkes_crypto::engines::bn256::Fr; -use fawkes_crypto::backend::bellman_groth16::engines::Bn256; -use fawkes_crypto::ff_uint::Num; -use fawkes_crypto::backend::bellman_groth16::{verifier::{VK, verify}, prover::{Proof, prove}, setup::setup, Parameters}; -use evm_verifier::generate_sol_data; -use fawkes_crypto::circuit::cs::CS; -use fawkes_crypto::rand::rngs::OsRng; -use libzeropool::helpers::sample_data::State; -use convert_case::{Case, Casing}; - -#[derive(Clap)] -struct Opts { - #[clap(subcommand)] - command: SubCommand, -} - -#[derive(Clap)] -enum SubCommand { - /// Generate a SNARK proof - Prove(ProveOpts), - /// Verify a SNARK proof - Verify(VerifyOpts), - /// Generate trusted setup parameters - Setup(SetupOpts), - /// Generate verifier smart contract - GenerateVerifier(GenerateVerifierOpts), - /// Generate test object - GenerateTestData(GenerateTestDataOpts), -} - -/// A subcommand for generating a SNARK proof -#[derive(Clap)] -struct ProveOpts { - /// Circuit for prooving (transfer|tree_update) - #[clap(short = "c", long = "circuit", default_value = "transfer")] - circuit: String, - /// Snark trusted setup parameters file - #[clap(short = "p", long = "params")] - params: Option, - /// Input object JSON file - #[clap(short = "o", long = "object")] - object: Option, - /// Output file for proof JSON - #[clap(short = "r", long = "proof")] - proof: Option, - /// Output file for public inputs JSON - #[clap(short = "i", long = "inputs")] - inputs: Option, -} - -/// A subcommand for verifying a SNARK proof -#[derive(Clap)] -struct VerifyOpts { - /// Circuit for verifying (transfer|tree_update) - #[clap(short = "c", long = "circuit", default_value = "transfer")] - circuit: String, - /// Snark verification key - #[clap(short = "v", long = "vk")] - vk: Option, - /// Proof JSON file - #[clap(short = "r", long = "proof")] - proof: Option, - /// Public inputs JSON file - #[clap(short = "i", long = "inputs")] - inputs: Option, -} - -/// A subcommand for generating a trusted setup parameters -#[derive(Clap)] -struct SetupOpts { - /// Circuit for parameter generation (transfer|tree_update) - #[clap(short = "c", long = "circuit", default_value = "transfer")] - circuit: String, - /// Snark trusted setup parameters file - #[clap(short = "p", long = "params")] - params: Option, - /// Snark verifying key file - #[clap(short = "v", long = "vk")] - vk: Option, -} - -/// A subcommand for generating a Solidity verifier smart contract -#[derive(Clap)] -struct GenerateVerifierOpts { - /// Circuit for verifying (transfer|tree_update) - #[clap(short = "c", long = "circuit", default_value = "transfer")] - circuit: String, - /// Snark verification key - #[clap(short = "v", long = "vk")] - vk: Option, - /// Smart contract name - #[clap(short = "n", long = "name")] - contract_name: Option, - /// Output file name - #[clap(short = "s", long = "solidity")] - solidity: Option, -} - -#[derive(Clap)] -struct GenerateTestDataOpts { - /// Circuit for testing (transfer|tree_update) - #[clap(short = "c", long = "circuit", default_value = "transfer")] - circuit: String, - /// Input object JSON file - #[clap(short = "o", long = "object")] - object: Option -} - -fn tree_circuit>(public: CTreePub, secret: CTreeSec) { - tree_update(&public, &secret, &*POOL_PARAMS); -} - -fn tx_circuit>(public: CTransferPub, secret: CTransferSec) { - c_transfer(&public, &secret, &*POOL_PARAMS); -} - -fn cli_setup(o:SetupOpts) { - let params_path = o.params.unwrap_or(format!("{}_params.bin", o.circuit)); - let vk_path = o.vk.unwrap_or(format!("{}_verification_key.json", o.circuit)); - - - let params = match o.circuit.as_str() { - "tree_update" => setup::(tree_circuit), - "transfer" => setup::(tx_circuit), - _ => panic!("Wrong cicruit parameter") - }; - - let vk = params.get_vk(); - let vk_str = serde_json::to_string_pretty(&vk).unwrap(); - - let mut fp = File::create(params_path).unwrap(); - params.write(&mut fp).unwrap(); - std::fs::write(vk_path, &vk_str.into_bytes()).unwrap(); - println!("setup OK"); -} - -fn cli_generate_verifier(o: GenerateVerifierOpts) { - let circuit = o.circuit.clone(); - let vk_path = o.vk.unwrap_or(format!("{}_verification_key.json", circuit)); - let contract_name = o.contract_name.unwrap_or(format!("{}_verifier", circuit).to_case(Case::Pascal)); - let solidity_path = o.solidity.unwrap_or(format!("{}_verifier.sol", circuit)); - - - let vk_str = std::fs::read_to_string(vk_path).unwrap(); - let vk :VK = serde_json::from_str(&vk_str).unwrap(); - let sol_str = generate_sol_data(&vk, contract_name); - File::create(solidity_path).unwrap().write(&sol_str.into_bytes()).unwrap(); - println!("solidity verifier generated") -} - -fn cli_verify(o:VerifyOpts) { - let proof_path = o.proof.unwrap_or(format!("{}_proof.json", o.circuit)); - let vk_path = o.vk.unwrap_or(format!("{}_verification_key.json", o.circuit)); - let inputs_path = o.inputs.unwrap_or(format!("{}_inputs.json", o.circuit)); - - let vk_str = std::fs::read_to_string(vk_path).unwrap(); - let proof_str = std::fs::read_to_string(proof_path).unwrap(); - let public_inputs_str = std::fs::read_to_string(inputs_path).unwrap(); - - let vk:VK = serde_json::from_str(&vk_str).unwrap(); - let proof:Proof = serde_json::from_str(&proof_str).unwrap(); - let public_inputs:Vec> = serde_json::from_str(&public_inputs_str).unwrap(); - - println!("Verify result is {}.", verify(&vk, &proof, &public_inputs)) -} - -fn cli_generate_test_data(o:GenerateTestDataOpts) { - let object_path = o.object.unwrap_or(format!("{}_object.json", o.circuit)); - - match o.circuit.as_str() { - "transfer" => { - let mut rng = OsRng::default(); - let state = State::random_sample_state(&mut rng, &*POOL_PARAMS); - let data = state.random_sample_transfer(&mut rng, &*POOL_PARAMS); - let data_str = serde_json::to_string_pretty(&data).unwrap(); - std::fs::write(object_path, &data_str.into_bytes()).unwrap(); - }, - "tree_update" => std::unimplemented!(), - _ => panic!("Wrong cicruit parameter") - } - - println!("Test data generated") - -} - -fn cli_prove(o:ProveOpts) { - let params_path = o.params.unwrap_or(format!("{}_params.bin", o.circuit)); - let object_path = o.object.unwrap_or(format!("{}_object.json", o.circuit)); - let proof_path = o.proof.unwrap_or(format!("{}_proof.json", o.circuit)); - let inputs_path = o.inputs.unwrap_or(format!("{}_inputs.json", o.circuit)); - - let params_data = std::fs::read(params_path).unwrap(); - let mut params_data_cur = ¶ms_data[..]; - - let params = Parameters::::read(&mut params_data_cur, false, false).unwrap(); - let object_str = std::fs::read_to_string(object_path).unwrap(); - - let (inputs, snark_proof) = if o.circuit.eq("tree_update") { - let (public, secret) = serde_json::from_str(&object_str).unwrap(); - prove(¶ms, &public, &secret, tree_circuit) - } else { - let (public, secret) = serde_json::from_str(&object_str).unwrap(); - prove(¶ms, &public, &secret, tx_circuit) - }; - - - let proof_str = serde_json::to_string_pretty(&snark_proof).unwrap(); - let inputs_str = serde_json::to_string_pretty(&inputs).unwrap(); - - std::fs::write(proof_path, &proof_str.into_bytes()).unwrap(); - std::fs::write(inputs_path, &inputs_str.into_bytes()).unwrap(); - - println!("Proved") -} - - -pub fn main() { - let opts: Opts = Opts::parse(); - match opts.command { - SubCommand::Prove(o) => cli_prove(o), - SubCommand::Verify(o) => cli_verify(o), - SubCommand::Setup(o) => cli_setup(o), - SubCommand::GenerateVerifier(o) => cli_generate_verifier(o), - SubCommand::GenerateTestData(o) => cli_generate_test_data(o) - } -} +#[cfg(feature = "plonk")] +mod cli_plonk; + +fn main() { + #[cfg(feature = "groth16")] + cli_groth16::main(); + #[cfg(feature = "plonk")] + cli_plonk::main(); +} \ No newline at end of file diff --git a/tests/circuit.rs b/tests/circuit.rs index fa87e84..d26c865 100644 --- a/tests/circuit.rs +++ b/tests/circuit.rs @@ -1,3 +1,5 @@ +#![cfg(feature = "r1cs")] + use fawkes_crypto::circuit::cs::CS; use libzeropool::{ fawkes_crypto::{ diff --git a/tests/transaction.rs b/tests/transaction.rs index 8a695d5..16a89a4 100644 --- a/tests/transaction.rs +++ b/tests/transaction.rs @@ -1,3 +1,5 @@ +#![cfg(feature = "r1cs")] + use libzeropool::{POOL_PARAMS, circuit::tx::{CTransferPub, CTransferSec, c_transfer}, fawkes_crypto::{ circuit::{ @@ -5,15 +7,27 @@ use libzeropool::{POOL_PARAMS, circuit::tx::{CTransferPub, CTransferSec, c_trans }, core::signal::Signal, rand::thread_rng, - backend::bellman_groth16::{ - engines::Bn256, - setup::setup, - prover, - verifier - } + }, }; + +#[cfg(feature = "r1cs")] +use libzeropool::fawkes_crypto::backend::bellman_groth16::{ + engines::Bn256, + setup::setup, + prover, + verifier +}; + +#[cfg(feature = "plonk")] +use libzeropool::fawkes_crypto::backend::plonk::{ + engines::Bn256, + setup::setup, + prover, + verifier +}; + use libzeropool::fawkes_crypto::engines::bn256::Fr; use std::time::Instant; diff --git a/tests/tree.rs b/tests/tree.rs index 68fabec..655775d 100644 --- a/tests/tree.rs +++ b/tests/tree.rs @@ -1,3 +1,5 @@ +#![cfg(feature = "r1cs")] + use fawkes_crypto::rand::Rng; use libzeropool::{POOL_PARAMS, circuit::tree::{CTreePub, CTreeSec, tree_update}, native::tree::{TreePub, TreeSec},