[one-shot implementation for discussion, not for merging]: BLS support

Cargo.toml

@@ -34,3 +34,17 @@ incremental = false
 [profile.flamegraph]
 inherits = "release"
 debug = true
+#[patch.crates-io]
+#halo2curves-axiom = { git = "https://github.com/jtcoolen/halo2curves.git" }
+#halo2-base = { git = "https://github.com/jtcoolen/halo2-lib.git", branch = "main" }
+
+[patch."https://github.com/axiom-crypto/halo2-lib.git"]
+halo2-base = { path = "vendor/halo2-lib/halo2-base" }
+halo2-ecc  = { path = "vendor/halo2-lib/halo2-ecc" }
+
+[patch."https://github.com/jtcoolen/halo2-lib.git"]
+halo2-base = { path = "vendor/halo2-lib/halo2-base" }
+halo2-ecc  = { path = "vendor/halo2-lib/halo2-ecc" }
+
+[patch.crates-io]
+halo2curves-axiom = { git = "https://github.com/jtcoolen/halo2curves.git", rev = "edeb29e7964f1d24bb3bc0d2a5f9417de92a572a" }

rust-toolchain

@@ -1 +1 @@
-1.85.1
+1.88.0

snark-verifier-sdk/examples/standard_plonk.rs

@@ -1,24 +1,16 @@
 use std::path::Path;
 
-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;
-use halo2_proofs::{halo2curves::bn256::Bn256, poly::kzg::commitment::ParamsKZG};
+use halo2_proofs::{halo2curves::bls12_381::Bls12, poly::kzg::commitment::ParamsKZG};
 use rand::rngs::OsRng;
 #[cfg(feature = "revm")]
 use snark_verifier_sdk::evm::evm_verify;
-use snark_verifier_sdk::evm::{gen_evm_proof_shplonk, gen_evm_verifier_shplonk};
-use snark_verifier_sdk::halo2::aggregation::{AggregationConfigParams, VerifierUniversality};
-use snark_verifier_sdk::{
-    gen_pk,
-    halo2::{aggregation::AggregationCircuit, gen_snark_shplonk},
-    Snark,
-};
-use snark_verifier_sdk::{CircuitExt, SHPLONK};
+use snark_verifier_sdk::evm::{gen_evm_proof_gwc, gen_evm_verifier_gwc, write_calldata};
+use snark_verifier_sdk::{gen_pk, CircuitExt};
 
 mod application {
-    use super::halo2_curves::bn256::Fr;
+    use super::halo2_curves::bls12_381::Fr;
     use super::halo2_proofs::{
         circuit::{Layouter, SimpleFloorPlanner, Value},
         plonk::{Advice, Circuit, Column, ConstraintSystem, Error, Fixed, Instance},
@@ -46,7 +38,6 @@ mod application {
             let [a, b, c] = [(); 3].map(|_| meta.advice_column());
             let [q_a, q_b, q_c, q_ab, constant] = [(); 5].map(|_| meta.fixed_column());
             let instance = meta.instance_column();
-
             [a, b, c].map(|column| meta.enable_equality(column));
 
             meta.create_gate(
@@ -56,7 +47,7 @@ mod application {
                         [a, b, c].map(|column| meta.query_advice(column, Rotation::cur()));
                     let [q_a, q_b, q_c, q_ab, constant] = [q_a, q_b, q_c, q_ab, constant]
                         .map(|column| meta.query_fixed(column, Rotation::cur()));
-                    let instance = meta.query_instance(instance, Rotation::cur());
+                let instance = meta.query_instance(instance, Rotation::cur());
                     Some(
                         q_a * a.clone()
                             + q_b * b.clone()
@@ -141,6 +132,7 @@ mod application {
                             region.assign_advice(|| "", config.a, 2, || Value::known(Fr::one()))?;
                         a.copy_advice(|| "", &mut region, config.b, 3)?;
                         a.copy_advice(|| "", &mut region, config.c, 4)?;
+                        Ok(())
                     }
                     #[cfg(feature = "halo2-axiom")]
                     {
@@ -160,61 +152,57 @@ mod application {
                         let a = region.assign_advice(config.a, 2, Value::known(Fr::one()));
                         a.copy_advice(&mut region, config.b, 3);
                         a.copy_advice(&mut region, config.c, 4);
+                        Ok(())
                     }
-
-                    Ok(())
                 },
             )
         }
     }
 }
 
-fn gen_application_snark(params: &ParamsKZG<Bn256>) -> Snark {
-    let circuit = application::StandardPlonk::rand(OsRng);
-
-    let pk = gen_pk(params, &circuit, None);
-    gen_snark_shplonk(params, &pk, circuit, None::<&str>)
-}
-
 fn main() {
-    let params_app = gen_srs(8);
-
-    let k = 21u32;
-    let lookup_bits = k as usize - 1;
-    let params = gen_srs(k);
-    let snarks = [(); 1].map(|_| gen_application_snark(&params_app));
-
-    let mut agg_circuit = AggregationCircuit::new::<SHPLONK>(
-        CircuitBuilderStage::Keygen,
-        AggregationConfigParams { degree: k, lookup_bits, ..Default::default() },
-        &params,
-        snarks.clone(),
-        VerifierUniversality::Full,
-    );
-    let agg_config = agg_circuit.calculate_params(Some(10));
+    let k = 12;
+    let params = ParamsKZG::<Bls12>::setup(k, OsRng);
+    let circuit = application::StandardPlonk::rand(OsRng);
+    let num_instance = circuit.num_instance();
+    let instances = circuit.instances();
 
-    let pk = gen_pk(&params, &agg_circuit, None);
-    let break_points = agg_circuit.break_points();
-    drop(agg_circuit);
+    let pk = gen_pk(&params, &circuit, None);
+    let proof = gen_evm_proof_gwc(&params, &pk, circuit, instances.clone());
 
-    let agg_circuit = AggregationCircuit::new::<SHPLONK>(
-        CircuitBuilderStage::Prover,
-        agg_config,
-        &params,
-        snarks.clone(),
-        VerifierUniversality::Full,
-    )
-    .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());
-
-    let _deployment_code = gen_evm_verifier_shplonk::<AggregationCircuit>(
+    let deployment_code = gen_evm_verifier_gwc::<application::StandardPlonk>(
         &params,
         pk.get_vk(),
-        num_instances,
+        num_instance,
         Some(Path::new("examples/StandardPlonkVerifier.sol")),
     );
+
+    let deployment_bytecode = format!("0x{}", hex::encode(&deployment_code));
+    std::fs::write("examples/standard_plonk.bytecode", &deployment_bytecode).unwrap();
+    let calldata =
+        write_calldata(&instances, &proof, Path::new("examples/standard_plonk.calldata")).unwrap();
+
+    println!("proof size: {}", proof.len());
+    println!("deployment code len: {}", deployment_code.len());
+    println!("wrote examples/standard_plonk.bytecode");
+    println!("wrote examples/standard_plonk.calldata ({} hex chars)", calldata.len());
+
     #[cfg(feature = "revm")]
-    evm_verify(_deployment_code, instances, _proof).expect("evm_verify should succeed");
+    {
+        if std::env::var("RUN_REVM").ok().as_deref() == Some("1") {
+            match evm_verify(deployment_code, instances, proof) {
+                Ok(gas_cost) => println!("gas cost: {}", gas_cost),
+                Err(err) => {
+                    println!("revm verification failed: {}", err);
+                    println!(
+                        "note: local revm simulation still reverted; validate against a known BLS-enabled client/node for authoritative verification"
+                    );
+                }
+            }
+        } else {
+            println!(
+                "revm verification skipped (set RUN_REVM=1 to run local revm simulation)"
+            );
+        }
+    }
 }

snark-verifier-sdk/src/evm.rs

@@ -4,7 +4,7 @@ use super::{CircuitExt, PlonkVerifier};
 #[cfg(feature = "display")]
 use ark_std::{end_timer, start_timer};
 use halo2_base::halo2_proofs::{
-    halo2curves::bn256::{Bn256, Fq, Fr, G1Affine},
+    halo2curves::bls12_381::{Bls12, Fq, Fr, G1Affine},
     plonk::{create_proof, verify_proof, Circuit, ProvingKey, VerifyingKey},
     poly::{
         commitment::{ParamsProver, Prover, Verifier},
@@ -34,19 +34,19 @@ use std::{fs, io, path::Path, rc::Rc};
 
 /// Generates a proof for evm verification using either SHPLONK or GWC proving method. Uses Keccak for Fiat-Shamir.
 pub fn gen_evm_proof<'params, C, P, V>(
-    params: &'params ParamsKZG<Bn256>,
+    params: &'params ParamsKZG<Bls12>,
     pk: &'params ProvingKey<G1Affine>,
     circuit: C,
     instances: Vec<Vec<Fr>>,
 ) -> Vec<u8>
 where
     C: Circuit<Fr>,
-    P: Prover<'params, KZGCommitmentScheme<Bn256>>,
+    P: Prover<'params, KZGCommitmentScheme<Bls12>>,
     V: Verifier<
         'params,
-        KZGCommitmentScheme<Bn256>,
-        Guard = GuardKZG<'params, Bn256>,
-        MSMAccumulator = DualMSM<'params, Bn256>,
+        KZGCommitmentScheme<Bls12>,
+        Guard = GuardKZG<'params, Bls12>,
+        MSMAccumulator = DualMSM<'params, Bls12>,
     >,
 {
     let instances = instances.iter().map(|instances| instances.as_slice()).collect_vec();
@@ -56,7 +56,7 @@ where
     let rng = StdRng::from_entropy();
     let proof = {
         let mut transcript = TranscriptWriterBuffer::<_, G1Affine, _>::init(Vec::new());
-        create_proof::<KZGCommitmentScheme<Bn256>, P, _, _, EvmTranscript<_, _, _, _>, _>(
+        create_proof::<KZGCommitmentScheme<Bls12>, P, _, _, EvmTranscript<_, _, _, _>, _>(
             params,
             pk,
             &[circuit],
@@ -89,7 +89,7 @@ where
 }
 
 pub fn gen_evm_proof_gwc<'params, C: Circuit<Fr>>(
-    params: &'params ParamsKZG<Bn256>,
+    params: &'params ParamsKZG<Bls12>,
     pk: &'params ProvingKey<G1Affine>,
     circuit: C,
     instances: Vec<Vec<Fr>>,
@@ -98,7 +98,7 @@ pub fn gen_evm_proof_gwc<'params, C: Circuit<Fr>>(
 }
 
 pub fn gen_evm_proof_shplonk<'params, C: Circuit<Fr>>(
-    params: &'params ParamsKZG<Bn256>,
+    params: &'params ParamsKZG<Bls12>,
     pk: &'params ProvingKey<G1Affine>,
     circuit: C,
     instances: Vec<Vec<Fr>>,
@@ -117,15 +117,15 @@ pub trait EvmKzgAccumulationScheme:
         Rc<EvmLoader>,
         VerifyingKey = KzgAsVerifyingKey,
         Accumulator = KzgAccumulator<G1Affine, Rc<EvmLoader>>,
-    > + AccumulationDecider<G1Affine, Rc<EvmLoader>, DecidingKey = KzgDecidingKey<Bn256>>
+    > + AccumulationDecider<G1Affine, Rc<EvmLoader>, DecidingKey = KzgDecidingKey<Bls12>>
 {
 }
 
 impl EvmKzgAccumulationScheme for crate::GWC {}
 impl EvmKzgAccumulationScheme for crate::SHPLONK {}
 
 pub fn gen_evm_verifier_sol_code<C, AS>(
-    params: &ParamsKZG<Bn256>,
+    params: &ParamsKZG<Bls12>,
     vk: &VerifyingKey<G1Affine>,
     num_instance: Vec<usize>,
 ) -> String
@@ -155,7 +155,7 @@ where
 }
 
 pub fn gen_evm_verifier<C, AS>(
-    params: &ParamsKZG<Bn256>,
+    params: &ParamsKZG<Bls12>,
     vk: &VerifyingKey<G1Affine>,
     num_instance: Vec<usize>,
     path: Option<&Path>,
@@ -174,7 +174,7 @@ where
 }
 
 pub fn gen_evm_verifier_gwc<C: CircuitExt<Fr>>(
-    params: &ParamsKZG<Bn256>,
+    params: &ParamsKZG<Bls12>,
     vk: &VerifyingKey<G1Affine>,
     num_instance: Vec<usize>,
     path: Option<&Path>,
@@ -183,7 +183,7 @@ pub fn gen_evm_verifier_gwc<C: CircuitExt<Fr>>(
 }
 
 pub fn gen_evm_verifier_shplonk<C: CircuitExt<Fr>>(
-    params: &ParamsKZG<Bn256>,
+    params: &ParamsKZG<Bls12>,
     vk: &VerifyingKey<G1Affine>,
     num_instance: Vec<usize>,
     path: Option<&Path>,