Update: use halo2-lib v0.4.0

snark-verifier-sdk/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snark-verifier-sdk"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 
 [dependencies]
@@ -19,6 +19,7 @@ bincode = "1.3.3"
 ark-std = { version = "0.3.0", features = ["print-trace"], optional = true }
 halo2-base = { git = "https://github.com/axiom-crypto/halo2-lib.git", branch = "develop", default-features = false }
 snark-verifier = { path = "../snark-verifier", default-features = false }
+getset = "0.1.2"
 
 # loader_evm
 ethereum-types = { version = "0.14.1", default-features = false, features = ["std"], optional = true }

snark-verifier-sdk/benches/read_pk.rs

@@ -1,7 +1,7 @@
 use ark_std::{end_timer, start_timer};
 use criterion::Criterion;
 use criterion::{criterion_group, criterion_main};
-use halo2_base::gates::builder::CircuitBuilderStage;
+use halo2_base::gates::circuit::CircuitBuilderStage;
 use halo2_base::halo2_proofs;
 use halo2_base::utils::fs::gen_srs;
 use halo2_proofs::halo2curves as halo2_curves;
@@ -172,8 +172,8 @@ mod application {
 fn gen_application_snark(params: &ParamsKZG<Bn256>) -> Snark {
     let circuit = application::StandardPlonk::rand(OsRng);
 
-    let pk = gen_pk(params, &circuit, Some(Path::new("examples/app.pk")));
-    gen_snark_shplonk(params, &pk, circuit, Some(Path::new("examples/app.snark")))
+    let pk = gen_pk(params, &circuit, None);
+    gen_snark_shplonk(params, &pk, circuit, None::<&str>)
 }
 
 fn bench(c: &mut Criterion) {
@@ -187,7 +187,6 @@ fn bench(c: &mut Criterion) {
     let agg_circuit = AggregationCircuit::new::<SHPLONK>(
         CircuitBuilderStage::Keygen,
         agg_config,
-        None,
         &params,
         snarks,
         VerifierUniversality::None,

snark-verifier-sdk/benches/standard_plonk.rs

@@ -1,7 +1,7 @@
 use ark_std::{end_timer, start_timer};
 use criterion::{criterion_group, criterion_main};
 use criterion::{BenchmarkId, Criterion};
-use halo2_base::gates::builder::CircuitBuilderStage;
+use halo2_base::gates::circuit::CircuitBuilderStage;
 use halo2_base::halo2_proofs;
 use halo2_base::utils::fs::gen_srs;
 use halo2_proofs::halo2curves as halo2_curves;
@@ -19,7 +19,6 @@ use snark_verifier_sdk::{
     Snark,
 };
 use snark_verifier_sdk::{CircuitExt, SHPLONK};
-use std::path::Path;
 
 mod application {
     use super::halo2_curves::bn256::Fr;
@@ -175,8 +174,8 @@ mod application {
 fn gen_application_snark(params: &ParamsKZG<Bn256>) -> Snark {
     let circuit = application::StandardPlonk::rand(OsRng);
 
-    let pk = gen_pk(params, &circuit, Some(Path::new("app.pk")));
-    gen_snark_shplonk(params, &pk, circuit, Some(Path::new("app.snark")))
+    let pk = gen_pk(params, &circuit, None);
+    gen_snark_shplonk(params, &pk, circuit, None::<&str>)
 }
 
 fn bench(c: &mut Criterion) {
@@ -190,16 +189,16 @@ fn bench(c: &mut Criterion) {
     let agg_circuit = AggregationCircuit::new::<SHPLONK>(
         CircuitBuilderStage::Keygen,
         agg_config,
-        None,
         &params,
         snarks.clone(),
         VerifierUniversality::None,
     );
 
     let start0 = start_timer!(|| "gen vk & pk");
-    let pk = gen_pk(&params, &agg_circuit, Some(Path::new("agg.pk")));
+    let pk = gen_pk(&params, &agg_circuit, None);
     end_timer!(start0);
     let break_points = agg_circuit.break_points();
+    drop(agg_circuit);
 
     let mut group = c.benchmark_group("plonk-prover");
     group.sample_size(10);
@@ -211,11 +210,11 @@ fn bench(c: &mut Criterion) {
                 let agg_circuit = AggregationCircuit::new::<SHPLONK>(
                     CircuitBuilderStage::Prover,
                     agg_config,
-                    Some(break_points.clone()),
                     params,
                     snarks.clone(),
                     VerifierUniversality::None,
-                );
+                )
+                .use_break_points(break_points.clone());
                 let instances = agg_circuit.instances();
                 gen_proof_shplonk(params, pk, agg_circuit, instances, None)
             })
@@ -229,11 +228,11 @@ fn bench(c: &mut Criterion) {
         let agg_circuit = AggregationCircuit::new::<SHPLONK>(
             CircuitBuilderStage::Prover,
             agg_config,
-            Some(break_points),
             &params,
             snarks.clone(),
             VerifierUniversality::None,
-        );
+        )
+        .use_break_points(break_points);
         let num_instances = agg_circuit.num_instance();
         let instances = agg_circuit.instances();
         let proof = gen_evm_proof_shplonk(&params, &pk, agg_circuit, instances.clone());

snark-verifier-sdk/examples/n_as_witness.rs

@@ -1,4 +1,4 @@
-use halo2_base::gates::builder::CircuitBuilderStage;
+use halo2_base::gates::circuit::CircuitBuilderStage;
 use halo2_base::halo2_proofs;
 use halo2_base::halo2_proofs::arithmetic::Field;
 use halo2_base::halo2_proofs::halo2curves::bn256::Fr;
@@ -162,12 +162,11 @@ fn main() {
     let mut agg_circuit = AggregationCircuit::new::<SHPLONK>(
         CircuitBuilderStage::Keygen,
         AggregationConfigParams { degree: k, lookup_bits, ..Default::default() },
-        None,
         &params,
         vec![dummy_snark],
         VerifierUniversality::Full,
     );
-    let agg_config = agg_circuit.config(Some(10));
+    let agg_config = agg_circuit.calculate_params(Some(10));
 
     let pk = gen_pk(&params, &agg_circuit, None);
     let break_points = agg_circuit.break_points();
@@ -177,11 +176,11 @@ fn main() {
         let agg_circuit = AggregationCircuit::new::<SHPLONK>(
             CircuitBuilderStage::Prover,
             agg_config,
-            Some(break_points.clone()),
             &params,
             vec![snark],
             VerifierUniversality::Full,
-        );
+        )
+        .use_break_points(break_points.clone());
         let _snark = gen_snark_shplonk(&params, &pk, agg_circuit, None::<&str>);
         println!("snark with k = {k} success");
     }

snark-verifier-sdk/examples/range_check.rs

@@ -1,11 +1,8 @@
 use ark_std::{end_timer, start_timer};
-use halo2_base::gates::builder::{
-    BaseConfigParams, CircuitBuilderStage, GateThreadBuilder, RangeWithInstanceCircuitBuilder,
-};
-use halo2_base::gates::flex_gate::GateStrategy;
+use halo2_base::gates::circuit::builder::BaseCircuitBuilder;
+use halo2_base::gates::circuit::{BaseCircuitParams, CircuitBuilderStage};
+use halo2_base::gates::{GateInstructions, RangeInstructions};
 use halo2_base::halo2_proofs::halo2curves::bn256::Fr;
-use halo2_base::halo2_proofs::plonk::Circuit;
-use halo2_base::safe_types::{GateInstructions, RangeChip, RangeInstructions};
 use halo2_base::utils::fs::gen_srs;
 
 use itertools::Itertools;
@@ -18,72 +15,61 @@ use snark_verifier_sdk::{
 };
 
 fn generate_circuit(k: u32) -> Snark {
-    let mut builder = GateThreadBuilder::new(false);
-    let ctx = builder.main(0);
     let lookup_bits = k as usize - 1;
-    let range = RangeChip::<Fr>::default(lookup_bits);
+    let circuit_params = BaseCircuitParams {
+        k: k as usize,
+        num_advice_per_phase: vec![10],
+        num_lookup_advice_per_phase: vec![5],
+        num_fixed: 1,
+        lookup_bits: Some(lookup_bits),
+        num_instance_columns: 1,
+    };
+    let mut builder = BaseCircuitBuilder::new(false).use_params(circuit_params);
+    let range = builder.range_chip();
+
+    let ctx = builder.main(0);
 
     let x = ctx.load_witness(Fr::from(14));
     range.range_check(ctx, x, 2 * lookup_bits + 1);
     range.gate().add(ctx, x, x);
 
-    let circuit = RangeWithInstanceCircuitBuilder::<Fr>::keygen(
-        builder.clone(),
-        BaseConfigParams {
-            strategy: GateStrategy::Vertical,
-            k: k as usize,
-            num_advice_per_phase: vec![1],
-            num_lookup_advice_per_phase: vec![1],
-            num_fixed: 1,
-            lookup_bits: Some(lookup_bits),
-        },
-        vec![],
-    );
     let params = gen_srs(k);
-
-    let pk = gen_pk(&params, &circuit, None);
-    let breakpoints = circuit.break_points();
-
-    let circuit = RangeWithInstanceCircuitBuilder::<Fr>::prover(
-        builder.clone(),
-        circuit.params(),
-        breakpoints,
-        vec![],
-    );
-    gen_snark_shplonk(&params, &pk, circuit, None::<&str>)
+    // do not call calculate_params, we want to use fixed params
+    let pk = gen_pk(&params, &builder, None);
+    // builder now has break_point set
+    gen_snark_shplonk(&params, &pk, builder, None::<&str>)
 }
 
 fn main() {
-    let dummy_snark = generate_circuit(13);
+    let dummy_snark = generate_circuit(9);
 
     let k = 14u32;
     let lookup_bits = k as usize - 1;
     let params = gen_srs(k);
     let mut agg_circuit = AggregationCircuit::new::<SHPLONK>(
         CircuitBuilderStage::Keygen,
         AggregationConfigParams { degree: k, lookup_bits, ..Default::default() },
-        None,
         &params,
         vec![dummy_snark],
         VerifierUniversality::Full,
     );
-    let agg_config = agg_circuit.config(Some(10));
+    let agg_config = agg_circuit.calculate_params(Some(10));
 
     let start0 = start_timer!(|| "gen vk & pk");
     let pk = gen_pk(&params, &agg_circuit, None);
     end_timer!(start0);
     let break_points = agg_circuit.break_points();
 
-    let snarks = (14..17).map(generate_circuit).collect_vec();
+    let snarks = (10..16).map(generate_circuit).collect_vec();
     for (i, snark) in snarks.into_iter().enumerate() {
         let agg_circuit = AggregationCircuit::new::<SHPLONK>(
             CircuitBuilderStage::Prover,
             agg_config,
-            Some(break_points.clone()),
             &params,
             vec![snark],
             VerifierUniversality::Full,
-        );
+        )
+        .use_break_points(break_points.clone());
         let _snark = gen_snark_shplonk(&params, &pk, agg_circuit, None::<&str>);
         println!("snark {i} success");
     }

snark-verifier-sdk/examples/vkey_as_witness.rs

@@ -1,6 +1,6 @@
 use application::ComputeFlag;
 
-use halo2_base::gates::builder::CircuitBuilderStage;
+use halo2_base::gates::circuit::CircuitBuilderStage;
 use halo2_base::halo2_proofs;
 use halo2_base::halo2_proofs::arithmetic::Field;
 use halo2_base::halo2_proofs::halo2curves::bn256::Fr;
@@ -157,12 +157,11 @@ fn main() {
     let mut agg_circuit = AggregationCircuit::new::<SHPLONK>(
         CircuitBuilderStage::Keygen,
         AggregationConfigParams { degree: k, lookup_bits, ..Default::default() },
-        None,
         &params,
         vec![dummy_snark],
         VerifierUniversality::PreprocessedAsWitness,
     );
-    let agg_config = agg_circuit.config(Some(10));
+    let agg_config = agg_circuit.calculate_params(Some(10));
 
     let pk = gen_pk(&params, &agg_circuit, None);
     let break_points = agg_circuit.break_points();
@@ -173,11 +172,11 @@ fn main() {
         let agg_circuit = AggregationCircuit::new::<SHPLONK>(
             CircuitBuilderStage::Prover,
             agg_config,
-            Some(break_points.clone()),
             &params,
             vec![snark],
             VerifierUniversality::PreprocessedAsWitness,
-        );
+        )
+        .use_break_points(break_points.clone());
         let _snark = gen_snark_shplonk(&params, &pk, agg_circuit, None::<&str>);
         println!("snark {i} success");
     }