Readapt compression circuit construction logic from example

compression/src/circuit.rs

@@ -4,6 +4,7 @@ use crate::params::ConfigParams;
 use ark_std::{end_timer, start_timer};
 use ce_snark_verifier::halo2_base::gates::circuit::{BaseConfig, CircuitBuilderStage};
 use ce_snark_verifier_sdk::{
+    gen_pk,
     halo2::aggregation::{AggregationCircuit, AggregationConfigParams, VerifierUniversality},
     CircuitExt as CeCircuitExt, SHPLONK,
 };
@@ -93,30 +94,60 @@ impl CeCircuitExt<Fr> for CompressionCircuit {
 impl CompressionCircuit {
     /// Build a new circuit from a snark, with a flag whether this snark has been compressed before
     pub fn new(
+        degree: u32,
         params: &ParamsKZG<Bn256>,
         snark: snark_verifier_sdk::Snark,
         has_accumulator: bool,
         rng: impl Rng + Send,
     ) -> Result<Self, ce_snark_verifier::Error> {
-        verify_snark_accumulator_pairing(&snark, params)
-            .expect("Compression circuit accumulator pre-check should not fail.");
-        Self::new_from_ce_snark(params, to_ce_snark(&snark), has_accumulator, rng)
+        // compression_debug
+        // verify_snark_accumulator_pairing(&snark, params)
+        //     .expect("Compression circuit accumulator pre-check should not fail.");
+        Self::new_from_ce_snark(degree, params, to_ce_snark(&snark), has_accumulator, rng)
     }
 
     pub fn new_from_ce_snark(
+        degree: u32,
         params: &ParamsKZG<Bn256>,
         snark: ce_snark_verifier_sdk::Snark,
         has_accumulator: bool,
         _rng: impl Rng + Send, // TODO: hook this up to the rng in AggregationCircuit? is that even needed?
     ) -> Result<Self, ce_snark_verifier::Error> {
+        // compression_debug
+        // let mut inner = AggregationCircuit::new::<SHPLONK>(
+        //     CircuitBuilderStage::Mock,
+        //     load_params(),
+        //     params,
+        //     [snark],
+        //     VerifierUniversality::None,
+        // );
+        // inner.expose_previous_instances(has_accumulator);
+        // Ok(Self(inner))
+
+        let lookup_bits = degree as usize - 1;
+        let mut agg_circuit = AggregationCircuit::new::<SHPLONK>(
+            CircuitBuilderStage::Keygen,
+            AggregationConfigParams { degree, lookup_bits, ..Default::default() },
+            &params,
+            [snark.clone()],
+            VerifierUniversality::Full,
+        );
+        let agg_config = agg_circuit.calculate_params(Some(10));
+
+        let _pk = gen_pk(&params, &agg_circuit, None);
+        let break_points = agg_circuit.break_points();
+        drop(agg_circuit);
+
         let mut inner = AggregationCircuit::new::<SHPLONK>(
-            CircuitBuilderStage::Mock,
-            load_params(),
-            params,
+            CircuitBuilderStage::Prover,
+            agg_config,
+            &params,
             [snark],
-            VerifierUniversality::None,
-        );
+            VerifierUniversality::Full,
+        )
+        .use_break_points(break_points);
         inner.expose_previous_instances(has_accumulator);
+
         Ok(Self(inner))
     }
 }

compression/src/tests.rs

@@ -24,6 +24,8 @@ use ce_snark_verifier::halo2_base::{
     utils::fs::gen_srs,
 };
 
+use crate::params;
+
 #[derive(Clone, Copy)]
 pub struct StandardPlonkConfig {
     a: Column<Advice>,
@@ -192,10 +194,37 @@ fn test_standard_plonk_compression() {
     );
 }
 
+#[test]
+fn test_mock_compression() {
+    use halo2_proofs::dev::MockProver;
+    use crate::CompressionCircuit;
+    use ark_std::test_rng;
+    use aggregator::MockChunkCircuit;
+
+    let k0 = 8u32;
+    let params_app = gen_srs(k0);
+
+    let mut rng = test_rng();
+    let circuit = MockChunkCircuit::random(&mut rng, false, false);
+
+    let pk = gen_pk(&params_app, &circuit, None);
+    let snark = gen_snark_shplonk(&params_app, &pk, circuit, None::<&str>);
+
+    let k1 = 21u32;
+    let params = gen_srs(k1);
+
+    let compression_circuit =
+        CompressionCircuit::new_from_ce_snark(k1, &params, snark, true, &mut rng).unwrap();
+    let instance = compression_circuit.instances();
+    println!("instance length {:?}", instance.len());
+
+    let mock_prover = MockProver::<Fr>::run(k1, &compression_circuit, instance).unwrap();
+
+    mock_prover.assert_satisfied_par()
+}
+
 
 // use crate::{circuit::to_ce_snark, CompressionCircuit};
-// use aggregator::MockChunkCircuit;
-// use ark_std::{end_timer, start_timer, test_rng};
 // use ce_snark_verifier::{
 //     loader::halo2::halo2_ecc::halo2_base::{halo2_proofs, utils::fs::gen_srs},
 //     pcs::kzg::{Bdfg21, KzgAs},
@@ -210,50 +239,6 @@ fn test_standard_plonk_compression() {
 // use halo2curves::bn256::{Bn256, Fr};
 // use std::{fs, path::Path, process};
 
-// #[ignore = "it takes too much time"]
-// #[test]
-// fn test_mock_compression() {
-//     // env_logger::init();
-
-//     if std::path::Path::new("data").is_dir() {
-//         println!("data folder already exists\n");
-//     } else {
-//         println!("Generating data folder used for testing\n");
-//         std::fs::create_dir("data").unwrap();
-//     }
-
-//     let dir = format!("data/{}", process::id());
-//     let path = Path::new(dir.as_str());
-//     fs::create_dir(path).unwrap();
-
-//     let k0 = 8;
-//     let k1 = 22;
-
-//     let mut rng = test_rng();
-//     let params = gen_srs(k1);
-
-//     // Proof for test circuit
-//     let circuit = MockChunkCircuit::random(&mut rng, false, false);
-//     let layer_0_snark = layer_0(&circuit, params.clone(), k0, path);
-
-//     std::env::set_var("COMPRESSION_CONFIG", "./configs/compression_wide.config");
-//     // layer 1 proof compression
-//     {
-//         let param = {
-//             let mut param = params;
-//             param.downsize(k1);
-//             param
-//         };
-//         let compression_circuit =
-//             CompressionCircuit::new_from_ce_snark(&param, layer_0_snark, true, &mut rng).unwrap();
-//         let instance = compression_circuit.instances();
-//         println!("instance length {:?}", instance.len());
-
-//         let mock_prover = MockProver::<Fr>::run(k1, &compression_circuit, instance).unwrap();
-
-//         mock_prover.assert_satisfied_par()
-//     }
-// }
 
 // // This test takes about 1 hour on CPU
 // #[ignore = "it takes too much time"]

prover/src/common/prover/compression.rs

@@ -22,7 +22,7 @@ impl<'params> Prover<'params> {
         env::set_var("COMPRESSION_CONFIG", layer_config_path(id));
 
         let circuit =
-            CompressionCircuit::new(self.params(degree), prev_snark, has_accumulator, &mut rng)
+            CompressionCircuit::new(degree, self.params(degree), prev_snark, has_accumulator, &mut rng)
                 .map_err(|err| anyhow!("Failed to construct compression circuit: {err:?}"))?;
         self.gen_snark(id, degree, &mut rng, circuit, "gen_comp_snark")
     }

prover/src/common/prover/evm.rs

@@ -29,6 +29,7 @@ impl<'params> Prover<'params> {
 
                 let mut rng = gen_rng();
                 let circuit = CompressionCircuit::new(
+                    degree,
                     self.params(degree),
                     prev_snark,
                     has_accumulator,