fix num instances in solidity gen

ChainSafe · Dec 4, 2023 · fc741d8 · fc741d8
1 parent 1d7eb08
commit fc741d8
Showing 1 changed file with 46 additions and 37 deletions.
diff --git a/prover/src/cli.rs b/prover/src/cli.rs
@@ -174,7 +174,8 @@ fn get_config_path(pk_path: &Path, config_dir: &Path) -> PathBuf {
     config_dir.join(format!("{}.json", circuit_configuration))
 }
 
-#[cfg(feature = "experimental")]
+
+#[cfg(not(feature = "experimental"))]
 fn gen_evm_verifier<Circuit: AppCircuit>(
     params: &ParamsKZG<Bn256>,
     pk_path: &Path,
@@ -183,41 +184,44 @@ fn gen_evm_verifier<Circuit: AppCircuit>(
     estimate_gas: bool,
     default_witness: Circuit::Witness,
 ) -> eyre::Result<()> {
+    use lightclient_circuits::{halo2_base::gates::circuit::CircuitBuilderStage, halo2_proofs::poly::commitment::Params};
+    use snark_verifier_sdk::CircuitExt;
+
     let pk = Circuit::read_pk(params, pk_path, &default_witness);
 
-    let generator = SolidityGenerator::new(params, pk.get_vk(), BatchOpenScheme::Bdfg21, 1);
+    let num_instances = {
+        let circuit = Circuit::create_circuit(CircuitBuilderStage::Mock, &cfg_path, &default_witness, params.k()).unwrap();
+        circuit.num_instance().first().map_or(0, |x| *x)
+    };
 
-    let verifier_sol = generator
-        .render()
-        .map_err(|e| eyre::eyre!("Failed to generate Solidity verifier: {}", e))?;
+    path_out.set_extension("yul");
+    let deplyment_code =
+        Circuit::gen_evm_verifier_shplonk(params, &pk, Some(path_out.clone()), &default_witness)
+            .map_err(|e| eyre::eyre!("Failed to EVM verifier: {}", e))?;
+    println!("yul size: {}", deplyment_code.len());
 
+    let sol_contract = halo2_solidity_verifier::fix_verifier_sol(path_out.clone(), num_instances)
+        .map_err(|e| eyre::eyre!("Failed to generate Solidity verifier: {}", e))?;
     path_out.set_extension("sol");
     let mut f = File::create(path_out).unwrap();
-    f.write(verifier_sol.as_bytes())
+    f.write(sol_contract.as_bytes())
         .map_err(|e| eyre::eyre!("Failed to write Solidity verifier: {}", e))?;
 
     if estimate_gas {
-        let mut evm = Evm::default();
-        let verifier_creation_code = compile_solidity(&verifier_sol);
-        println!(
-            "Verifier creation code size: {}",
-            verifier_creation_code.len()
-        );
-        let verifier_address = evm.create(verifier_creation_code);
-
-        let (proof, instances) =
-            Circuit::gen_evm_proof_shplonk(params, &pk, cfg_path, None, &default_witness)
-                .map_err(|e| eyre::eyre!("Failed to generate proof: {}", e))?;
-        let calldata = encode_calldata(None, &proof, &instances[0]);
-        let (gas_cost, output) = evm.call(verifier_address, calldata);
-        assert_eq!(output, [vec![0; 31], vec![1]].concat());
-        println!("Gas cost of verifying proof: {gas_cost}");
+        let _ = Circuit::gen_evm_proof_shplonk(
+            params,
+            &pk,
+            cfg_path,
+            Some(deplyment_code),
+            &default_witness,
+        )
+        .map_err(|e| eyre::eyre!("Failed to generate proof: {}", e))?;
     }
 
     Ok(())
 }
 
-#[cfg(not(feature = "experimental"))]
+#[cfg(feature = "experimental")]
 fn gen_evm_verifier<Circuit: AppCircuit>(
     params: &ParamsKZG<Bn256>,
     pk_path: &Path,
@@ -228,28 +232,33 @@ fn gen_evm_verifier<Circuit: AppCircuit>(
 ) -> eyre::Result<()> {
     let pk = Circuit::read_pk(params, pk_path, &default_witness);
 
-    path_out.set_extension("yul");
-    let deplyment_code =
-        Circuit::gen_evm_verifier_shplonk(params, &pk, Some(path_out.clone()), &default_witness)
-            .map_err(|e| eyre::eyre!("Failed to EVM verifier: {}", e))?;
-    println!("yul size: {}", deplyment_code.len());
+    let generator = SolidityGenerator::new(params, pk.get_vk(), BatchOpenScheme::Bdfg21, 1);
 
-    let sol_contract = halo2_solidity_verifier::fix_verifier_sol(path_out.clone(), 1)
+    let verifier_sol = generator
+        .render()
         .map_err(|e| eyre::eyre!("Failed to generate Solidity verifier: {}", e))?;
+
     path_out.set_extension("sol");
     let mut f = File::create(path_out).unwrap();
-    f.write(sol_contract.as_bytes())
+    f.write(verifier_sol.as_bytes())
         .map_err(|e| eyre::eyre!("Failed to write Solidity verifier: {}", e))?;
 
     if estimate_gas {
-        let _ = Circuit::gen_evm_proof_shplonk(
-            params,
-            &pk,
-            cfg_path,
-            Some(deplyment_code),
-            &default_witness,
-        )
-        .map_err(|e| eyre::eyre!("Failed to generate proof: {}", e))?;
+        let mut evm = Evm::default();
+        let verifier_creation_code = compile_solidity(&verifier_sol);
+        println!(
+            "Verifier creation code size: {}",
+            verifier_creation_code.len()
+        );
+        let verifier_address = evm.create(verifier_creation_code);
+
+        let (proof, instances) =
+            Circuit::gen_evm_proof_shplonk(params, &pk, cfg_path, None, &default_witness)
+                .map_err(|e| eyre::eyre!("Failed to generate proof: {}", e))?;
+        let calldata = encode_calldata(None, &proof, &instances[0]);
+        let (gas_cost, output) = evm.call(verifier_address, calldata);
+        assert_eq!(output, [vec![0; 31], vec![1]].concat());
+        println!("Gas cost of verifying proof: {gas_cost}");
     }
 
     Ok(())