implement high-level helper api

src/sonic/helped/adapted_helper.rs

@@ -0,0 +1,33 @@
+use ff::{Field};
+use pairing::{Engine, CurveProjective};
+use std::marker::PhantomData;
+
+use rand::{Rand, Rng};
+
+use super::{Proof, SxyAdvice};
+use super::batch::Batch;
+use super::poly::{SxEval, SyEval};
+use super::parameters::{Parameters};
+use super::helper::{Aggregate};
+
+use crate::SynthesisError;
+
+use crate::sonic::transcript::{Transcript, TranscriptProtocol};
+use crate::sonic::util::*;
+use crate::sonic::cs::{Backend, SynthesisDriver};
+use crate::{Circuit};
+use crate::sonic::sonic::AdaptorCircuit;
+use crate::sonic::srs::SRS;
+use crate::sonic::cs::Nonassigning;
+use super::helper::create_aggregate as create_aggregate_sonic_circuit;
+
+pub fn create_aggregate<E: Engine, C: Circuit<E> + Clone>(
+    circuit: C,
+    inputs: &[(Proof<E>, SxyAdvice<E>)],
+    params: &Parameters<E>,
+) -> Aggregate<E>
+{
+    let adapted_circuit = AdaptorCircuit(circuit);
+
+    create_aggregate_sonic_circuit::<_, _, Nonassigning>(&adapted_circuit, inputs, params)
+}

src/sonic/helped/helper.rs

@@ -5,6 +5,7 @@ use std::marker::PhantomData;
 use super::{Proof, SxyAdvice};
 use super::batch::Batch;
 use super::poly::{SxEval, SyEval};
+use super::Parameters;
 
 use crate::SynthesisError;
 
@@ -27,6 +28,18 @@ pub struct Aggregate<E: Engine> {
 }
 
 pub fn create_aggregate<E: Engine, C: Circuit<E>, S: SynthesisDriver>(
+    circuit: &C,
+    inputs: &[(Proof<E>, SxyAdvice<E>)],
+    params: &Parameters<E>,
+) -> Aggregate<E>
+{
+    let n = params.vk.n;
+    let q = params.vk.q;
+
+    create_aggregate_on_srs_using_information::<E, C, S>(circuit, inputs, &params.srs, n, q)
+}
+
+pub fn create_aggregate_on_srs<E: Engine, C: Circuit<E>, S: SynthesisDriver>(
     circuit: &C,
     inputs: &[(Proof<E>, SxyAdvice<E>)],
     srs: &SRS<E>,
@@ -55,6 +68,17 @@ pub fn create_aggregate<E: Engine, C: Circuit<E>, S: SynthesisDriver>(
         (tmp.n, tmp.q)
     };
 
+    create_aggregate_on_srs_using_information::<E, C, S>(circuit, inputs, srs, n, q)
+}
+
+pub fn create_aggregate_on_srs_using_information<E: Engine, C: Circuit<E>, S: SynthesisDriver>(
+    circuit: &C,
+    inputs: &[(Proof<E>, SxyAdvice<E>)],
+    srs: &SRS<E>,
+    n: usize,
+    q: usize,
+) -> Aggregate<E>
+{
     let mut transcript = Transcript::new(&[]);
     let mut y_values: Vec<E::Fr> = Vec::with_capacity(inputs.len());
     for &(ref proof, ref sxyadvice) in inputs {

src/sonic/helped/mod.rs

@@ -5,19 +5,18 @@ use ff::{Field};
 use pairing::{Engine, CurveProjective};
 use std::marker::PhantomData;
 
-mod verifier;
 mod batch;
 mod poly;
-mod helper;
+pub mod prover;
+pub mod verifier;
+pub mod helper;
 mod parameters;
 mod generator;
 mod adapted_prover;
 mod adapted_verifier;
-
-pub mod prover;
+mod adapted_helper;
 
 pub use self::batch::{Batch};
-pub use self::helper::{Aggregate, create_aggregate};
 pub use self::verifier::{MultiVerifier};
 
 pub use self::generator::{
@@ -29,7 +28,13 @@ pub use self::generator::{
     generate_srs,
     get_circuit_parameters
 };
-pub use self::parameters::{Proof, SxyAdvice, Parameters, VerifyingKey, PreparedVerifyingKey};
+pub use self::parameters::{
+    Proof, 
+    SxyAdvice, 
+    Parameters, 
+    VerifyingKey, 
+    PreparedVerifyingKey
+};
 pub use self::adapted_prover::{
     create_advice,
     create_advice_on_srs,
@@ -42,3 +47,7 @@ pub use self::adapted_verifier::{
     verify_proofs,
     verify_aggregate
 };
+
+pub use self::adapted_helper::{
+    create_aggregate
+};

tests/mimc.rs

@@ -480,7 +480,8 @@ fn test_sonic_mimc() {
         use bellman::sonic::cs::Basic;
         use bellman::sonic::sonic::AdaptorCircuit;
         use bellman::sonic::helped::prover::{create_advice_on_srs, create_proof_on_srs};
-        use bellman::sonic::helped::{create_aggregate, MultiVerifier};
+        use bellman::sonic::helped::{MultiVerifier, get_circuit_parameters};
+        use bellman::sonic::helped::helper::{create_aggregate_on_srs};
 
         println!("creating proof");
         let start = Instant::now();
@@ -495,7 +496,7 @@ fn test_sonic_mimc() {
         println!("creating aggregate for {} proofs", samples);
         let start = Instant::now();
         let proofs: Vec<_> = (0..samples).map(|_| (proof.clone(), advice.clone())).collect();
-        let aggregate = create_aggregate::<Bls12, _, Basic>(&AdaptorCircuit(circuit.clone()), &proofs, &srs);
+        let aggregate = create_aggregate_on_srs::<Bls12, _, Basic>(&AdaptorCircuit(circuit.clone()), &proofs, &srs);
         println!("done in {:?}", start.elapsed());
 
         {
@@ -583,7 +584,8 @@ fn test_inputs_into_sonic_mimc() {
         use bellman::sonic::cs::Basic;
         use bellman::sonic::sonic::AdaptorCircuit;
         use bellman::sonic::helped::prover::{create_advice_on_srs, create_proof_on_srs};
-        use bellman::sonic::helped::{create_aggregate, MultiVerifier, get_circuit_parameters};
+        use bellman::sonic::helped::{MultiVerifier, get_circuit_parameters};
+        use bellman::sonic::helped::helper::{create_aggregate_on_srs};
 
         let info = get_circuit_parameters::<Bn256, _>(circuit.clone()).expect("Must get circuit info");
         println!("{:?}", info);
@@ -601,7 +603,7 @@ fn test_inputs_into_sonic_mimc() {
         println!("creating aggregate for {} proofs", samples);
         let start = Instant::now();
         let proofs: Vec<_> = (0..samples).map(|_| (proof.clone(), advice.clone())).collect();
-        let aggregate = create_aggregate::<Bn256, _, Basic>(&AdaptorCircuit(circuit.clone()), &proofs, &srs);
+        let aggregate = create_aggregate_on_srs::<Bn256, _, Basic>(&AdaptorCircuit(circuit.clone()), &proofs, &srs);
         println!("done in {:?}", start.elapsed());
 
         {
@@ -651,19 +653,16 @@ fn test_inputs_into_sonic_mimc() {
 
 #[test]
 fn test_high_level_sonic_api() {
-    use ff::{Field, PrimeField};
-    use pairing::{Engine, CurveAffine, CurveProjective};
-    use pairing::bn256::{Bn256, Fr};
+    use pairing::bn256::{Bn256};
     use std::time::{Instant};
-    use bellman::sonic::helped::{generate_random_parameters, 
+    use bellman::sonic::helped::{
+        generate_random_parameters, 
         verify_aggregate, 
         verify_proofs, 
         create_proof, 
         create_advice,
         create_aggregate
     };
-    use bellman::sonic::cs::Basic;
-    use bellman::sonic::sonic::AdaptorCircuit;
 
     {
         // This may not be cryptographically safe, use
@@ -701,7 +700,7 @@ fn test_high_level_sonic_api() {
         println!("creating aggregate for {} proofs", samples);
         let start = Instant::now();
         let proofs: Vec<_> = (0..samples).map(|_| (proof.clone(), advice.clone())).collect();
-        let aggregate = create_aggregate::<Bn256, _, Basic>(&AdaptorCircuit(circuit.clone()), &proofs, &params.srs);
+        let aggregate = create_aggregate::<Bn256, _>(circuit.clone(), &proofs, &params);
         println!("done in {:?}", start.elapsed());
 
         {