Encapsulate functionality

privacy-scaling-explorations · Jul 5, 2024 · ba930c7 · ba930c7
1 parent 3ea84a1
commit ba930c7
Show file tree

Hide file tree

Showing 12 changed files with 240 additions and 251 deletions.
diff --git a/examples/blake2f.rs b/examples/blake2f.rs
@@ -8,8 +8,8 @@ use chiquito::{
     },
     plonkish::{
         backend::halo2::{
-            chiquitoSuperCircuit2Halo2, get_super_circuit_halo2_setup, halo2_prove, halo2_verify,
-            ChiquitoHalo2SuperCircuit, DummyRng,
+            chiquitoSuperCircuit2Halo2, get_super_circuit_halo2_setup, halo2_verify,
+            ChiquitoHalo2SuperCircuit, DummyRng, Halo2Setup,
         },
         compiler::{
             cell_manager::{MaxWidthCellManager, SingleRowCellManager},
@@ -1487,11 +1487,12 @@ fn main() {
     let rng = BlockRng::new(DummyRng {});
 
     let (cs, params, vk, pk) = get_super_circuit_halo2_setup(9, &mut circuit, rng);
+    let halo2_setup = Halo2Setup::new(cs, params, vk, pk, circuit.sub_circuits, witness);
 
     let rng = BlockRng::new(DummyRng {});
-    let (proof, instance) = halo2_prove(&params, pk, rng, cs, witness, &circuit.sub_circuits);
+    let (proof, instance) = halo2_setup.generate_proof(rng);
 
-    let result = halo2_verify(proof, params, vk, instance);
+    let result = halo2_verify(proof, halo2_setup.params, halo2_setup.vk, instance);
 
     println!("result = {:#?}", result);
 

diff --git a/examples/factorial.rs b/examples/factorial.rs
@@ -1,18 +1,18 @@
-use std::{collections::HashMap, hash::Hash};
+use std::hash::Hash;
 
 use chiquito::{
     field::Field,
     frontend::dsl::{circuit, trace::DSLTraceGenerator}, /* main function for constructing an AST
                                                          * circuit */
     plonkish::{
-        backend::halo2::{get_halo2_setup, halo2_prove, halo2_verify, ChiquitoHalo2, DummyRng},
+        backend::halo2::{halo2_verify, DummyRng, PlonkishHalo2},
         compiler::{
             cell_manager::SingleRowCellManager, // input for constructing the compiler
             compile,                            // input for constructing the compiler
             config,
             step_selector::SimpleStepSelectorBuilder,
+            PlonkishCompilationResult,
         },
-        ir::{assignments::AssignmentGenerator, Circuit},
     }, /* compiles to
         * Chiquito Halo2
         * backend,
@@ -27,8 +27,8 @@ use rand_chacha::rand_core::block::BlockRng;
 
 const MAX_FACTORIAL: usize = 10;
 
-type AssignGen<F> = AssignmentGenerator<F, DSLTraceGenerator<F, u32>>;
-fn generate<F: Field + From<u64> + Hash>() -> (Circuit<F>, Option<AssignGen<F>>) {
+fn generate<F: Field + From<u64> + Hash>() -> PlonkishCompilationResult<F, DSLTraceGenerator<F, u32>>
+{
     // table for the circuit:
     // |    step_type      |  i  |  x   |
     // ----------------------------------
@@ -138,22 +138,13 @@ fn main() {
     let plonkish = generate::<Fr>();
     let rng = BlockRng::new(DummyRng {});
 
-    let (cs, params, vk, pk, chiquito_halo2) =
-        get_halo2_setup(10, ChiquitoHalo2::new(plonkish.0), rng);
+    let halo2_setup = plonkish.get_halo2_setup(10, rng, 0);
 
     let rng = BlockRng::new(DummyRng {});
-    let witness = plonkish.1.unwrap().generate(0);
 
-    let (proof, instance) = halo2_prove(
-        &params,
-        pk,
-        rng,
-        cs,
-        HashMap::from([(chiquito_halo2.ir_id, witness)]),
-        &vec![chiquito_halo2],
-    );
+    let (proof, instance) = halo2_setup.generate_proof(rng);
 
-    let result = halo2_verify(proof, params, vk, instance);
+    let result = halo2_verify(proof, halo2_setup.params, halo2_setup.vk, instance);
 
     println!("result = {:#?}", result);
 
@@ -164,22 +155,13 @@ fn main() {
     let plonkish = generate::<Fr>();
     let rng = BlockRng::new(DummyRng {});
 
-    let (cs, params, vk, pk, chiquito_halo2) =
-        get_halo2_setup(8, ChiquitoHalo2::new(plonkish.0), rng);
+    let halo2_setup = plonkish.get_halo2_setup(8, rng, 7);
 
     let rng = BlockRng::new(DummyRng {});
-    let witness = plonkish.1.unwrap().generate(7);
-
-    let (proof, instance) = halo2_prove(
-        &params,
-        pk,
-        rng,
-        cs,
-        HashMap::from([(chiquito_halo2.ir_id, witness)]),
-        &vec![chiquito_halo2],
-    );
-
-    let result = halo2_verify(proof, params, vk, instance);
+
+    let (proof, instance) = halo2_setup.generate_proof(rng);
+
+    let result = halo2_verify(proof, halo2_setup.params, halo2_setup.vk, instance);
 
     println!("result = {:#?}", result);
 

diff --git a/examples/fibo_with_padding.rs b/examples/fibo_with_padding.rs
@@ -1,18 +1,18 @@
-use std::{collections::HashMap, hash::Hash};
+use std::hash::Hash;
 
 use chiquito::{
     field::Field,
     frontend::dsl::{circuit, trace::DSLTraceGenerator}, /* main function for constructing an AST
                                                          * circuit */
     plonkish::{
-        backend::halo2::{get_halo2_setup, halo2_prove, halo2_verify, ChiquitoHalo2, DummyRng},
+        backend::halo2::{halo2_verify, DummyRng, PlonkishHalo2},
         compiler::{
             cell_manager::SingleRowCellManager, // input for constructing the compiler
             compile,                            // input for constructing the compiler
             config,
             step_selector::SimpleStepSelectorBuilder,
+            PlonkishCompilationResult,
         },
-        ir::{assignments::AssignmentGenerator, Circuit},
     }, /* compiles to
         * Chiquito Halo2
         * backend,
@@ -28,10 +28,9 @@ use rand_chacha::rand_core::block::BlockRng;
 // This example file extends the rust example file 'fibonacci.rs',
 // describing usage of multiple steptypes, padding, and exposing signals.
 
-type AssignGen<F> = AssignmentGenerator<F, DSLTraceGenerator<F, u32>>;
-
 // the main circuit function
-fn fibo_circuit<F: Field + From<u64> + Hash>() -> (Circuit<F>, Option<AssignGen<F>>)
+fn fibo_circuit<F: Field + From<u64> + Hash>(
+) -> PlonkishCompilationResult<F, DSLTraceGenerator<F, u32>>
 // u32 is for external input that indicates the number of fibnoacci iterations
 {
     use chiquito::{
@@ -206,25 +205,16 @@ fn fibo_circuit<F: Field + From<u64> + Hash>() -> (Circuit<F>, Option<AssignGen<
 
 // standard main function for a Halo2 circuit
 fn main() {
-    let (chiquito, wit_gen) = fibo_circuit::<Fr>();
+    let plonkish_compilation_result = fibo_circuit::<Fr>();
     let rng = BlockRng::new(DummyRng {});
 
-    let (cs, params, vk, pk, chiquito_halo2) =
-        get_halo2_setup(7, ChiquitoHalo2::new(chiquito), rng);
+    let halo2_setup = plonkish_compilation_result.get_halo2_setup(7, rng, 7);
 
     let rng = BlockRng::new(DummyRng {});
-    let witness = wit_gen.unwrap().generate(7);
-
-    let (proof, instance) = halo2_prove(
-        &params,
-        pk,
-        rng,
-        cs,
-        HashMap::from([(chiquito_halo2.ir_id, witness)]),
-        &vec![chiquito_halo2],
-    );
-
-    let result = halo2_verify(proof, params, vk, instance);
+
+    let (proof, instance) = halo2_setup.generate_proof(rng);
+
+    let result = halo2_verify(proof, halo2_setup.params, halo2_setup.vk, instance);
 
     println!("{:#?}", result);
 

diff --git a/examples/fibonacci.rs b/examples/fibonacci.rs
@@ -1,21 +1,21 @@
-use std::{collections::HashMap, hash::Hash};
+use std::hash::Hash;
 
 use chiquito::{
     field::Field,
     frontend::dsl::{circuit, trace::DSLTraceGenerator}, /* main function for constructing an AST
                                                          * circuit */
     plonkish::{
         backend::{
-            halo2::{get_halo2_setup, halo2_prove, halo2_verify, ChiquitoHalo2, DummyRng},
+            halo2::{halo2_verify, DummyRng, PlonkishHalo2},
             hyperplonk::ChiquitoHyperPlonkCircuit,
         },
         compiler::{
             cell_manager::SingleRowCellManager, // input for constructing the compiler
             compile,                            // input for constructing the compiler
             config,
             step_selector::SimpleStepSelectorBuilder,
+            PlonkishCompilationResult,
         },
-        ir::{assignments::AssignmentGenerator, Circuit},
     }, /* compiles to
         * Chiquito Halo2
         * backend,
@@ -36,8 +36,7 @@ use rand_chacha::rand_core::block::BlockRng;
 // 3. two witness generation arguments both of u64 type, i.e. (u64, u64)
 
 type FiboReturn<F> = (
-    Circuit<F>,
-    Option<AssignmentGenerator<F>>,
+    PlonkishCompilationResult<F, DSLTraceGenerator<F>>,
     SBPIR<F, DSLTraceGenerator<F>>,
 );
 
@@ -125,34 +124,25 @@ fn fibo_circuit<F: Field + From<u64> + Hash>() -> FiboReturn<F> {
         &fibo,
     );
 
-    (compiled.0, compiled.1, fibo)
+    (compiled, fibo)
 }
 
 // After compiling Chiquito AST to an IR, it is further parsed by a Chiquito Halo2 backend and
 // integrated into a Halo2 circuit, which is done by the boilerplate code below.
 
 // standard main function for a Halo2 circuit
 fn main() {
-    let (chiquito, wit_gen, _) = fibo_circuit::<Fr>();
+    let (chiquito, _) = fibo_circuit::<Fr>();
 
     let rng = BlockRng::new(DummyRng {});
 
-    let (cs, params, vk, pk, chiquito_halo2) =
-        get_halo2_setup(7, ChiquitoHalo2::new(chiquito), rng);
+    let halo2_setup = chiquito.get_halo2_setup(7, rng, ());
 
     let rng = BlockRng::new(DummyRng {});
-    let witness = wit_gen.unwrap().generate(());
-
-    let (proof, instance) = halo2_prove(
-        &params,
-        pk,
-        rng,
-        cs,
-        HashMap::from([(chiquito_halo2.ir_id, witness)]),
-        &vec![chiquito_halo2],
-    );
 
-    let result = halo2_verify(proof, params, vk, instance);
+    let (proof, instance) = halo2_setup.generate_proof(rng);
+
+    let result = halo2_verify(proof, halo2_setup.params, halo2_setup.vk, instance);
 
     println!("result = {:#?}", result);
 
@@ -168,11 +158,15 @@ fn main() {
         pcs::{multilinear, univariate},
     };
     // get Chiquito ir
-    let (circuit, assignment_generator, _) = fibo_circuit::<hpFr>();
+    let (plonkish_compilation_result, _) = fibo_circuit::<hpFr>();
     // get assignments
-    let assignments = assignment_generator.unwrap().generate(());
+    let assignments = plonkish_compilation_result
+        .assignment_generator
+        .unwrap()
+        .generate(());
     // get hyperplonk circuit
-    let mut hyperplonk_circuit = ChiquitoHyperPlonkCircuit::new(4, circuit);
+    let mut hyperplonk_circuit =
+        ChiquitoHyperPlonkCircuit::new(4, plonkish_compilation_result.circuit);
     hyperplonk_circuit.set_assignment(assignments);
 
     type GeminiKzg = multilinear::Gemini<univariate::UnivariateKzg<Bn256>>;
@@ -182,10 +176,15 @@ fn main() {
     // pil boilerplate
     use chiquito::pil::backend::powdr_pil::chiquito2Pil;
 
-    let (_, wit_gen, circuit) = fibo_circuit::<hpFr>();
+    let (plonkish_compilation_result, circuit) = fibo_circuit::<hpFr>();
     let pil = chiquito2Pil(
         circuit,
-        Some(wit_gen.unwrap().generate_trace_witness(())),
+        Some(
+            plonkish_compilation_result
+                .assignment_generator
+                .unwrap()
+                .generate_trace_witness(()),
+        ),
         String::from("FiboCircuit"),
     );
     print!("{}", pil);

diff --git a/examples/keccak.rs b/examples/keccak.rs
@@ -4,8 +4,8 @@ use chiquito::{
     },
     plonkish::{
         backend::halo2::{
-            chiquitoSuperCircuit2Halo2, get_super_circuit_halo2_setup, halo2_prove, halo2_verify,
-            ChiquitoHalo2SuperCircuit, DummyRng,
+            chiquitoSuperCircuit2Halo2, get_super_circuit_halo2_setup, halo2_verify,
+            ChiquitoHalo2SuperCircuit, DummyRng, Halo2Setup,
         },
         compiler::{
             cell_manager::{MaxWidthCellManager, SingleRowCellManager},
@@ -2265,11 +2265,13 @@ fn main() {
 
     let (cs, params, vk, pk) = get_super_circuit_halo2_setup(9, &mut circuit, rng);
 
-    let rng = BlockRng::new(DummyRng {});
     let witness = super_circuit.get_mapping().generate(circuit_param);
-    let (proof, instance) = halo2_prove(&params, pk, rng, cs, witness, &circuit.sub_circuits);
+    let halo2_setup = Halo2Setup::new(cs, params, vk, pk, circuit.sub_circuits, witness);
+
+    let rng = BlockRng::new(DummyRng {});
+    let (proof, instance) = halo2_setup.generate_proof(rng);
 
-    let result = halo2_verify(proof, params, vk, instance);
+    let result = halo2_verify(proof, halo2_setup.params, halo2_setup.vk, instance);
 
     println!("result = {:#?}", result);
 

diff --git a/examples/mimc7.rs b/examples/mimc7.rs
@@ -6,8 +6,8 @@ use chiquito::{
     frontend::dsl::{lb::LookupTable, super_circuit, trace::DSLTraceGenerator, CircuitContext},
     plonkish::{
         backend::halo2::{
-            chiquitoSuperCircuit2Halo2, get_super_circuit_halo2_setup, halo2_prove, halo2_verify,
-            ChiquitoHalo2SuperCircuit, DummyRng,
+            chiquitoSuperCircuit2Halo2, get_super_circuit_halo2_setup, halo2_verify,
+            ChiquitoHalo2SuperCircuit, DummyRng, Halo2Setup,
         },
         compiler::{
             cell_manager::SingleRowCellManager, config, step_selector::SimpleStepSelectorBuilder,
@@ -211,12 +211,13 @@ fn main() {
 
     let (cs, params, vk, pk) = get_super_circuit_halo2_setup(10, &mut circuit, rng);
 
-    let rng = BlockRng::new(DummyRng {});
-
     let witness = super_circuit.get_mapping().generate((x_in_value, k_value));
-    let (proof, instance) = halo2_prove(&params, pk, rng, cs, witness, &circuit.sub_circuits);
+    let halo2_setup = Halo2Setup::new(cs, params, vk, pk, circuit.sub_circuits, witness);
+
+    let rng = BlockRng::new(DummyRng {});
+    let (proof, instance) = halo2_setup.generate_proof(rng);
 
-    let result = halo2_verify(proof, params, vk, instance);
+    let result = halo2_verify(proof, halo2_setup.params, halo2_setup.vk, instance);
 
     println!("result = {:#?}", result);
 

diff --git a/examples/poseidon.rs b/examples/poseidon.rs
@@ -2,8 +2,8 @@ use chiquito::{
     frontend::dsl::{lb::LookupTable, super_circuit, trace::DSLTraceGenerator, CircuitContext},
     plonkish::{
         backend::halo2::{
-            chiquitoSuperCircuit2Halo2, get_super_circuit_halo2_setup, halo2_prove, halo2_verify,
-            ChiquitoHalo2SuperCircuit, DummyRng,
+            chiquitoSuperCircuit2Halo2, get_super_circuit_halo2_setup, halo2_verify,
+            ChiquitoHalo2SuperCircuit, DummyRng, Halo2Setup,
         },
         compiler::{
             cell_manager::{MaxWidthCellManager, SingleRowCellManager},
@@ -712,11 +712,12 @@ fn main() {
     let rng = BlockRng::new(DummyRng {});
 
     let (cs, params, vk, pk) = get_super_circuit_halo2_setup(12, &mut circuit, rng);
+    let halo2_setup = Halo2Setup::new(cs, params, vk, pk, circuit.sub_circuits, witness);
 
     let rng = BlockRng::new(DummyRng {});
-    let (proof, instance) = halo2_prove(&params, pk, rng, cs, witness, &circuit.sub_circuits);
+    let (proof, instance) = halo2_setup.generate_proof(rng);
 
-    let result = halo2_verify(proof, params, vk, instance);
+    let result = halo2_verify(proof, halo2_setup.params, halo2_setup.vk, instance);
 
     println!("result = {:#?}", result);
 

diff --git a/src/compiler/compiler.rs b/src/compiler/compiler.rs
@@ -13,7 +13,7 @@ use crate::{
         ast::{debug_sym_factory::DebugSymRefFactory, tl::TLDecl, Identifiable, Identifier},
         lang::TLDeclsParser,
     },
-    plonkish,
+    plonkish::{self, compiler::PlonkishCompilationResult},
     poly::{self, mielim::mi_elimination, reduce::reduce_degree, Expr},
     sbpir::{query::Queriable, InternalSignal, SBPIR},
     wit_gen::{NullTraceGenerator, SymbolSignalMapping, TraceGenerator},
@@ -41,10 +41,7 @@ impl<F: Field + Hash> CompilerResult<F> {
     >(
         &self,
         config: plonkish::compiler::CompilerConfig<CM, SSB>,
-    ) -> (
-        crate::plonkish::ir::Circuit<F>,
-        Option<plonkish::ir::assignments::AssignmentGenerator<F, InterpreterTraceGenerator>>,
-    ) {
+    ) -> PlonkishCompilationResult<F, InterpreterTraceGenerator> {
         plonkish::compiler::compile(config, &self.circuit)
     }
 }