feat: allow for separate vk render on-chain (#697)

.github/workflows/rust.yml

@@ -313,6 +313,8 @@ jobs:
         run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
       - name: Install Anvil
         run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
+      - name: KZG prove and verify tests (EVM + VK rendered seperately)
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_prove_and_verify_render_seperately_ --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg all)
         run: cargo nextest run --release --verbose tests_evm::kzg_evm_kzg_all_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg inputs)
@@ -653,4 +655,3 @@ jobs:
         run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_ --no-capture
       # - name: Postgres tutorials
       #   run: source .env/bin/activate; cargo nextest run py_tests::tests::postgres_ --test-threads 1
-     

src/circuit/ops/poly.rs

@@ -237,7 +237,7 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
             }
             PolyOp::Neg => layouts::neg(config, region, values[..].try_into()?)?,
             PolyOp::Iff => layouts::iff(config, region, values[..].try_into()?)?,
-            PolyOp::Einsum { equation } => layouts::einsum(config, region, &values, equation)?,
+            PolyOp::Einsum { equation } => layouts::einsum(config, region, values, equation)?,
             PolyOp::Sum { axes } => {
                 layouts::sum_axes(config, region, values[..].try_into()?, axes)?
             }

src/commands.rs

@@ -59,6 +59,8 @@ pub const DEFAULT_SOL_CODE_DA: &str = "evm_deploy_da.sol";
 pub const DEFAULT_CONTRACT_ADDRESS: &str = "contract.address";
 /// Default contract address for data attestation
 pub const DEFAULT_CONTRACT_ADDRESS_DA: &str = "contract_da.address";
+/// Default contract address for vk
+pub const DEFAULT_CONTRACT_ADDRESS_VK: &str = "contract_vk.address";
 /// Default check mode
 pub const DEFAULT_CHECKMODE: &str = "safe";
 /// Default calibration target
@@ -75,6 +77,12 @@ pub const DEFAULT_CALIBRATION_FILE: &str = "calibration.json";
 pub const DEFAULT_LOOKUP_SAFETY_MARGIN: &str = "2";
 /// Default Compress selectors
 pub const DEFAULT_COMPRESS_SELECTORS: &str = "false";
+/// Default render vk seperately
+pub const DEFAULT_RENDER_VK_SEPERATELY: &str = "false";
+/// Default VK sol path
+pub const DEFAULT_VK_SOL: &str = "vk.sol";
+/// Default VK abi path
+pub const DEFAULT_VK_ABI: &str = "vk.abi";
 
 impl std::fmt::Display for TranscriptType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -584,6 +592,31 @@ pub enum Commands {
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VERIFIER_ABI)]
         abi_path: PathBuf,
+        /// Whether the verifier key should be rendered as a separate contract.
+        /// We recommend disabling selector compression if this is enabled.
+        /// To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command.        
+        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY)]
+        render_vk_seperately: bool,
+    },
+    #[cfg(not(target_arch = "wasm32"))]
+    /// Creates an EVM verifier for a single proof
+    #[command(name = "create-evm-vk")]
+    CreateEVMVK {
+        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        #[arg(long)]
+        srs_path: Option<PathBuf>,
+        /// The path to load circuit settings .json file from (generated using the gen-settings command)
+        #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
+        settings_path: PathBuf,
+        /// The path to load the desired verification key file
+        #[arg(long, default_value = DEFAULT_VK)]
+        vk_path: PathBuf,
+        /// The path to output the Solidity code
+        #[arg(long, default_value = DEFAULT_VK_SOL)]
+        sol_code_path: PathBuf,
+        /// The path to output the Solidity verifier ABI
+        #[arg(long, default_value = DEFAULT_VK_ABI)]
+        abi_path: PathBuf,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Creates an EVM verifier that attests to on-chain inputs for a single proof
@@ -629,6 +662,11 @@ pub enum Commands {
         // logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
         logrows: u32,
+        /// Whether the verifier key should be rendered as a separate contract.
+        /// We recommend disabling selector compression if this is enabled.
+        /// To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command.        
+        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY)]
+        render_vk_seperately: bool,
     },
     /// Verifies a proof, returning accept or reject
     Verify {
@@ -680,6 +718,25 @@ pub enum Commands {
         private_key: Option<String>,
     },
     #[cfg(not(target_arch = "wasm32"))]
+    /// Deploys an evm verifier that is generated by ezkl
+    DeployEvmVK {
+        /// The path to the Solidity code (generated using the create-evm-verifier command)
+        #[arg(long, default_value = DEFAULT_VK_SOL)]
+        sol_code_path: PathBuf,
+        /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
+        #[arg(short = 'U', long)]
+        rpc_url: Option<String>,
+        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_VK)]
+        /// The path to output the contract address
+        addr_path: PathBuf,
+        /// The optimizer runs to set on the verifier. Lower values optimize for deployment cost, while higher values optimize for gas cost.
+        #[arg(long, default_value = DEFAULT_OPTIMIZER_RUNS)]
+        optimizer_runs: usize,
+        /// Private secp256K1 key in hex format, 64 chars, no 0x prefix, of the account signing transactions. If None the private key will be generated by Anvil
+        #[arg(short = 'P', long)]
+        private_key: Option<String>,
+    },
+    #[cfg(not(target_arch = "wasm32"))]
     /// Deploys an evm verifier that allows for data attestation
     #[command(name = "deploy-evm-da")]
     DeployEvmDataAttestation {
@@ -721,6 +778,9 @@ pub enum Commands {
         /// does the verifier use data attestation ?
         #[arg(long)]
         addr_da: Option<H160>,
+        // is the vk rendered seperately, if so specify an address
+        #[arg(long)]
+        addr_vk: Option<H160>,
     },
 
     /// Print the proof in hexadecimal

src/eth.rs

@@ -101,17 +101,18 @@ pub async fn setup_eth_backend(
 }
 
 ///
-pub async fn deploy_verifier_via_solidity(
+pub async fn deploy_contract_via_solidity(
     sol_code_path: PathBuf,
     rpc_url: Option<&str>,
     runs: usize,
     private_key: Option<&str>,
+    contract_name: &str,
 ) -> Result<ethers::types::Address, Box<dyn Error>> {
     // anvil instance must be alive at least until the factory completes the deploy
     let (anvil, client) = setup_eth_backend(rpc_url, private_key).await?;
 
     let (abi, bytecode, runtime_bytecode) =
-        get_contract_artifacts(sol_code_path, "Halo2Verifier", runs)?;
+        get_contract_artifacts(sol_code_path, contract_name, runs)?;
 
     let factory = get_sol_contract_factory(abi, bytecode, runtime_bytecode, client.clone())?;
     let contract = factory.deploy(())?.send().await?;
@@ -335,11 +336,16 @@ pub async fn update_account_calls(
 pub async fn verify_proof_via_solidity(
     proof: Snark<Fr, G1Affine>,
     addr: ethers::types::Address,
+    addr_vk: Option<H160>,
     rpc_url: Option<&str>,
 ) -> Result<bool, Box<dyn Error>> {
     let flattened_instances = proof.instances.into_iter().flatten();
 
-    let encoded = encode_calldata(None, &proof.proof, &flattened_instances.collect::<Vec<_>>());
+    let encoded = encode_calldata(
+        addr_vk.as_ref().map(|x| x.0),
+        &proof.proof,
+        &flattened_instances.collect::<Vec<_>>(),
+    );
 
     info!("encoded: {:#?}", hex::encode(&encoded));
     let (anvil, client) = setup_eth_backend(rpc_url, None).await?;
@@ -439,6 +445,7 @@ pub async fn verify_proof_with_data_attestation(
     proof: Snark<Fr, G1Affine>,
     addr_verifier: ethers::types::Address,
     addr_da: ethers::types::Address,
+    addr_vk: Option<H160>,
     rpc_url: Option<&str>,
 ) -> Result<bool, Box<dyn Error>> {
     use ethers::abi::{Function, Param, ParamType, StateMutability, Token};
@@ -452,8 +459,11 @@ pub async fn verify_proof_with_data_attestation(
         public_inputs.push(u);
     }
 
-    let encoded_verifier =
-        encode_calldata(None, &proof.proof, &flattened_instances.collect::<Vec<_>>());
+    let encoded_verifier = encode_calldata(
+        addr_vk.as_ref().map(|x| x.0),
+        &proof.proof,
+        &flattened_instances.collect::<Vec<_>>(),
+    );
 
     info!("encoded: {:#?}", hex::encode(&encoded_verifier));
 

src/execute.rs

@@ -3,7 +3,7 @@ use crate::circuit::CheckMode;
 use crate::commands::CalibrationTarget;
 use crate::commands::Commands;
 #[cfg(not(target_arch = "wasm32"))]
-use crate::eth::{deploy_da_verifier_via_solidity, deploy_verifier_via_solidity};
+use crate::eth::{deploy_contract_via_solidity, deploy_da_verifier_via_solidity};
 #[cfg(not(target_arch = "wasm32"))]
 #[allow(unused_imports)]
 use crate::eth::{fix_da_sol, get_contract_artifacts, verify_proof_via_solidity};
@@ -204,7 +204,22 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             settings_path,
             sol_code_path,
             abi_path,
-        } => create_evm_verifier(vk_path, srs_path, settings_path, sol_code_path, abi_path),
+            render_vk_seperately,
+        } => create_evm_verifier(
+            vk_path,
+            srs_path,
+            settings_path,
+            sol_code_path,
+            abi_path,
+            render_vk_seperately,
+        ),
+        Commands::CreateEVMVK {
+            vk_path,
+            srs_path,
+            settings_path,
+            sol_code_path,
+            abi_path,
+        } => create_evm_vk(vk_path, srs_path, settings_path, sol_code_path, abi_path),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::CreateEVMDataAttestation {
             settings_path,
@@ -220,6 +235,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             abi_path,
             aggregation_settings,
             logrows,
+            render_vk_seperately,
         } => create_evm_aggregate_verifier(
             vk_path,
             srs_path,
@@ -227,6 +243,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             abi_path,
             aggregation_settings,
             logrows,
+            render_vk_seperately,
         ),
         Commands::CompileCircuit {
             model,
@@ -368,6 +385,25 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
                 addr_path,
                 optimizer_runs,
                 private_key,
+                "Halo2Verifier",
+            )
+            .await
+        }
+        #[cfg(not(target_arch = "wasm32"))]
+        Commands::DeployEvmVK {
+            sol_code_path,
+            rpc_url,
+            addr_path,
+            optimizer_runs,
+            private_key,
+        } => {
+            deploy_evm(
+                sol_code_path,
+                rpc_url,
+                addr_path,
+                optimizer_runs,
+                private_key,
+                "Halo2VerifyingKey",
             )
             .await
         }
@@ -398,7 +434,8 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             addr_verifier,
             rpc_url,
             addr_da,
-        } => verify_evm(proof_path, addr_verifier, rpc_url, addr_da).await,
+            addr_vk,
+        } => verify_evm(proof_path, addr_verifier, rpc_url, addr_da, addr_vk).await,
         Commands::PrintProofHex { proof_path } => print_proof_hex(proof_path),
     }
 }
@@ -448,7 +485,7 @@ async fn fetch_srs(uri: &str) -> Result<Vec<u8>, Box<dyn Error>> {
 #[cfg(not(target_arch = "wasm32"))]
 fn check_srs_hash(logrows: u32, srs_path: Option<PathBuf>) -> Result<String, Box<dyn Error>> {
     let path = get_srs_path(logrows, srs_path);
-    let hash = sha256::digest(&std::fs::read(path.clone())?);
+    let hash = sha256::digest(std::fs::read(path.clone())?);
     info!("SRS hash: {}", hash);
 
     let predefined_hash = match { crate::srs_sha::PUBLIC_SRS_SHA256_HASHES.get(&logrows) } {
@@ -456,7 +493,7 @@ fn check_srs_hash(logrows: u32, srs_path: Option<PathBuf>) -> Result<String, Box
         None => return Err(format!("SRS (k={}) hash not found in public set", logrows).into()),
     };
 
-    if hash != predefined_hash.to_string() {
+    if hash != *predefined_hash {
         // delete file
         warn!("removing SRS file at {}", path.display());
         std::fs::remove_file(path)?;
@@ -679,7 +716,7 @@ impl AccuracyResults {
             let abs_error = error.map(|x| x.abs());
             let squared_error = error.map(|x| x.powi(2));
             let percentage_error =
-                error.enum_map(|i, x| Ok::<_, TensorError>(x / original[i].clone()))?;
+                error.enum_map(|i, x| Ok::<_, TensorError>(x / original[i]))?;
             let abs_percentage_error = percentage_error.map(|x| x.abs());
 
             errors.extend(error.into_iter());
@@ -695,29 +732,25 @@ impl AccuracyResults {
             abs_percentage_errors.iter().sum::<f32>() / abs_percentage_errors.len() as f32;
         let mean_error = errors.iter().sum::<f32>() / errors.len() as f32;
         let median_error = errors[errors.len() / 2];
-        let max_error = errors
+        let max_error = *errors
             .iter()
             .max_by(|a, b| a.partial_cmp(b).unwrap())
-            .unwrap()
-            .clone();
-        let min_error = errors
+            .unwrap();
+        let min_error = *errors
             .iter()
             .min_by(|a, b| a.partial_cmp(b).unwrap())
-            .unwrap()
-            .clone();
+            .unwrap();
 
         let mean_abs_error = abs_errors.iter().sum::<f32>() / abs_errors.len() as f32;
         let median_abs_error = abs_errors[abs_errors.len() / 2];
-        let max_abs_error = abs_errors
+        let max_abs_error = *abs_errors
             .iter()
             .max_by(|a, b| a.partial_cmp(b).unwrap())
-            .unwrap()
-            .clone();
-        let min_abs_error = abs_errors
+            .unwrap();
+        let min_abs_error = *abs_errors
             .iter()
             .min_by(|a, b| a.partial_cmp(b).unwrap())
-            .unwrap()
-            .clone();
+            .unwrap();
 
         let mean_squared_error = squared_errors.iter().sum::<f32>() / squared_errors.len() as f32;
 
@@ -1157,6 +1190,7 @@ pub(crate) fn create_evm_verifier(
     settings_path: PathBuf,
     sol_code_path: PathBuf,
     abi_path: PathBuf,
+    render_vk_seperately: bool,
 ) -> Result<String, Box<dyn Error>> {
     check_solc_requirement();
     let circuit_settings = GraphSettings::load(&settings_path)?;
@@ -1174,7 +1208,11 @@ pub(crate) fn create_evm_verifier(
         halo2_solidity_verifier::BatchOpenScheme::Bdfg21,
         num_instance,
     );
-    let verifier_solidity = generator.render()?;
+    let verifier_solidity = if render_vk_seperately {
+        generator.render_separately()?.0 // ignore the rendered vk for now and generate it in create_evm_vk
+    } else {
+        generator.render()?
+    };
 
     File::create(sol_code_path.clone())?.write_all(verifier_solidity.as_bytes())?;
 
@@ -1186,6 +1224,43 @@ pub(crate) fn create_evm_verifier(
     Ok(String::new())
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) fn create_evm_vk(
+    vk_path: PathBuf,
+    srs_path: Option<PathBuf>,
+    settings_path: PathBuf,
+    sol_code_path: PathBuf,
+    abi_path: PathBuf,
+) -> Result<String, Box<dyn Error>> {
+    check_solc_requirement();
+    let circuit_settings = GraphSettings::load(&settings_path)?;
+    let params = load_params_cmd(srs_path, circuit_settings.run_args.logrows)?;
+
+    let num_instance = circuit_settings.total_instances();
+    let num_instance: usize = num_instance.iter().sum::<usize>();
+
+    let vk = load_vk::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(vk_path, circuit_settings)?;
+    trace!("params computed");
+
+    let generator = halo2_solidity_verifier::SolidityGenerator::new(
+        &params,
+        &vk,
+        halo2_solidity_verifier::BatchOpenScheme::Bdfg21,
+        num_instance,
+    );
+
+    let vk_solidity = generator.render_separately()?.1;
+
+    File::create(sol_code_path.clone())?.write_all(vk_solidity.as_bytes())?;
+
+    // fetch abi of the contract
+    let (abi, _, _) = get_contract_artifacts(sol_code_path, "Halo2VerifyingKey", 0)?;
+    // save abi to file
+    serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
+
+    Ok(String::new())
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn create_evm_data_attestation(
     settings_path: PathBuf,
@@ -1281,13 +1356,15 @@ pub(crate) async fn deploy_evm(
     addr_path: PathBuf,
     runs: usize,
     private_key: Option<String>,
+    contract_name: &str,
 ) -> Result<String, Box<dyn Error>> {
     check_solc_requirement();
-    let contract_address = deploy_verifier_via_solidity(
+    let contract_address = deploy_contract_via_solidity(
         sol_code_path,
         rpc_url.as_deref(),
         runs,
         private_key.as_deref(),
+        contract_name,
     )
     .await?;
 
@@ -1304,6 +1381,7 @@ pub(crate) async fn verify_evm(
     addr_verifier: H160,
     rpc_url: Option<String>,
     addr_da: Option<H160>,
+    addr_vk: Option<H160>,
 ) -> Result<String, Box<dyn Error>> {
     use crate::eth::verify_proof_with_data_attestation;
     check_solc_requirement();
@@ -1315,11 +1393,12 @@ pub(crate) async fn verify_evm(
             proof.clone(),
             addr_verifier,
             addr_da,
+            addr_vk,
             rpc_url.as_deref(),
         )
         .await?
     } else {
-        verify_proof_via_solidity(proof.clone(), addr_verifier, rpc_url.as_deref()).await?
+        verify_proof_via_solidity(proof.clone(), addr_verifier, addr_vk, rpc_url.as_deref()).await?
     };
 
     info!("Solidity verification result: {}", result);
@@ -1339,6 +1418,7 @@ pub(crate) fn create_evm_aggregate_verifier(
     abi_path: PathBuf,
     circuit_settings: Vec<PathBuf>,
     logrows: u32,
+    render_vk_seperately: bool,
 ) -> Result<String, Box<dyn Error>> {
     check_solc_requirement();
     let srs_path = get_srs_path(logrows, srs_path);
@@ -1377,7 +1457,11 @@ pub(crate) fn create_evm_aggregate_verifier(
 
     generator = generator.set_acc_encoding(Some(acc_encoding));
 
-    let verifier_solidity = generator.render()?;
+    let verifier_solidity = if render_vk_seperately {
+        generator.render_separately()?.0 // ignore the rendered vk for now and generate it in create_evm_vk
+    } else {
+        generator.render()?
+    };
 
     File::create(sol_code_path.clone())?.write_all(verifier_solidity.as_bytes())?;
 

src/graph/mod.rs

@@ -763,18 +763,18 @@ impl GraphCircuit {
         if self.settings().run_args.input_visibility.is_public() {
             public_inputs.rescaled_inputs = elements.rescaled_inputs.clone();
             public_inputs.inputs = elements.inputs.clone();
-        } else if let Some(_) = &data.processed_inputs {
+        } else if data.processed_inputs.is_some() {
             public_inputs.processed_inputs = elements.processed_inputs.clone();
         }
 
-        if let Some(_) = &data.processed_params {
+        if data.processed_params.is_some() {
             public_inputs.processed_params = elements.processed_params.clone();
         }
 
         if self.settings().run_args.output_visibility.is_public() {
             public_inputs.rescaled_outputs = elements.rescaled_outputs.clone();
             public_inputs.outputs = elements.outputs.clone();
-        } else if let Some(_) = &data.processed_outputs {
+        } else if data.processed_outputs.is_some() {
             public_inputs.processed_outputs = elements.processed_outputs.clone();
         }
 
@@ -1133,7 +1133,7 @@ impl GraphCircuit {
 
         while (1 << extended_k) < (n * quotient_poly_degree) {
             extended_k += 1;
-            if !(extended_k <= bn256::Fr::S) {
+            if extended_k > bn256::Fr::S {
                 return false;
             }
         }

src/graph/utilities.rs

@@ -71,8 +71,8 @@ pub fn quantize_float(elem: &f64, shift: f64, scale: crate::Scale) -> Result<i12
 pub fn dequantize(felt: Fp, scale: crate::Scale, shift: f64) -> f64 {
     let int_rep = crate::fieldutils::felt_to_i128(felt);
     let multiplier = scale_to_multiplier(scale);
-    let float_rep = int_rep as f64 / multiplier - shift;
-    float_rep
+    
+    int_rep as f64 / multiplier - shift
 }
 
 /// Converts a scale (log base 2) to a fixed point multiplier.

src/python.rs

@@ -807,6 +807,7 @@ fn verify_aggr(
     sol_code_path=PathBuf::from(DEFAULT_SOL_CODE),
     abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
     srs_path=None,
+    render_vk_seperately = DEFAULT_RENDER_VK_SEPERATELY.parse().unwrap(),
 ))]
 fn create_evm_verifier(
     vk_path: PathBuf,
@@ -814,12 +815,20 @@ fn create_evm_verifier(
     sol_code_path: PathBuf,
     abi_path: PathBuf,
     srs_path: Option<PathBuf>,
+    render_vk_seperately: bool,
 ) -> Result<bool, PyErr> {
-    crate::execute::create_evm_verifier(vk_path, srs_path, settings_path, sol_code_path, abi_path)
-        .map_err(|e| {
-            let err_str = format!("Failed to run create_evm_verifier: {}", e);
-            PyRuntimeError::new_err(err_str)
-        })?;
+    crate::execute::create_evm_verifier(
+        vk_path,
+        srs_path,
+        settings_path,
+        sol_code_path,
+        abi_path,
+        render_vk_seperately,
+    )
+    .map_err(|e| {
+        let err_str = format!("Failed to run create_evm_verifier: {}", e);
+        PyRuntimeError::new_err(err_str)
+    })?;
 
     Ok(true)
 }
@@ -885,7 +894,7 @@ fn setup_test_evm_witness(
     sol_code_path=PathBuf::from(DEFAULT_SOL_CODE),
     rpc_url=None,
     optimizer_runs=DEFAULT_OPTIMIZER_RUNS.parse().unwrap(),
-    private_key=None
+    private_key=None,
 ))]
 fn deploy_evm(
     addr_path: PathBuf,
@@ -902,6 +911,39 @@ fn deploy_evm(
             addr_path,
             optimizer_runs,
             private_key,
+            "Halo2Verifier",
+        ))
+        .map_err(|e| {
+            let err_str = format!("Failed to run deploy_evm: {}", e);
+            PyRuntimeError::new_err(err_str)
+        })?;
+
+    Ok(true)
+}
+
+#[pyfunction(signature = (
+    addr_path,
+    sol_code_path=PathBuf::from(DEFAULT_VK_SOL),
+    rpc_url=None,
+    optimizer_runs=DEFAULT_OPTIMIZER_RUNS.parse().unwrap(),
+    private_key=None,
+))]
+fn deploy_vk_evm(
+    addr_path: PathBuf,
+    sol_code_path: PathBuf,
+    rpc_url: Option<String>,
+    optimizer_runs: usize,
+    private_key: Option<String>,
+) -> Result<bool, PyErr> {
+    Runtime::new()
+        .unwrap()
+        .block_on(crate::execute::deploy_evm(
+            sol_code_path,
+            rpc_url,
+            addr_path,
+            optimizer_runs,
+            private_key,
+            "Halo2VerifyingKey",
         ))
         .map_err(|e| {
             let err_str = format!("Failed to run deploy_evm: {}", e);
@@ -953,12 +995,14 @@ fn deploy_da_evm(
     proof_path=PathBuf::from(DEFAULT_PROOF),
     rpc_url=None,
     addr_da = None,
+    addr_vk = None,
 ))]
 fn verify_evm(
     addr_verifier: &str,
     proof_path: PathBuf,
     rpc_url: Option<String>,
     addr_da: Option<&str>,
+    addr_vk: Option<&str>,
 ) -> Result<bool, PyErr> {
     let addr_verifier = H160::from_str(addr_verifier).map_err(|e| {
         let err_str = format!("address is invalid: {}", e);
@@ -973,6 +1017,15 @@ fn verify_evm(
     } else {
         None
     };
+    let addr_vk = if let Some(addr_vk) = addr_vk {
+        let addr_vk = H160::from_str(addr_vk).map_err(|e| {
+            let err_str = format!("address is invalid: {}", e);
+            PyRuntimeError::new_err(err_str)
+        })?;
+        Some(addr_vk)
+    } else {
+        None
+    };
 
     Runtime::new()
         .unwrap()
@@ -981,6 +1034,7 @@ fn verify_evm(
             addr_verifier,
             rpc_url,
             addr_da,
+            addr_vk,
         ))
         .map_err(|e| {
             let err_str = format!("Failed to run verify_evm: {}", e);
@@ -998,6 +1052,7 @@ fn verify_evm(
     abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
     logrows=DEFAULT_AGGREGATED_LOGROWS.parse().unwrap(),
     srs_path=None,
+    render_vk_seperately = DEFAULT_RENDER_VK_SEPERATELY.parse().unwrap(),
 ))]
 fn create_evm_verifier_aggr(
     aggregation_settings: Vec<PathBuf>,
@@ -1006,6 +1061,7 @@ fn create_evm_verifier_aggr(
     abi_path: PathBuf,
     logrows: u32,
     srs_path: Option<PathBuf>,
+    render_vk_seperately: bool,
 ) -> Result<bool, PyErr> {
     crate::execute::create_evm_aggregate_verifier(
         vk_path,
@@ -1014,6 +1070,7 @@ fn create_evm_verifier_aggr(
         abi_path,
         aggregation_settings,
         logrows,
+        render_vk_seperately,
     )
     .map_err(|e| {
         let err_str = format!("Failed to run create_evm_verifier_aggr: {}", e);
@@ -1067,6 +1124,7 @@ fn ezkl(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(verify_aggr, m)?)?;
     m.add_function(wrap_pyfunction!(create_evm_verifier, m)?)?;
     m.add_function(wrap_pyfunction!(deploy_evm, m)?)?;
+    m.add_function(wrap_pyfunction!(deploy_vk_evm, m)?)?;
     m.add_function(wrap_pyfunction!(deploy_da_evm, m)?)?;
     m.add_function(wrap_pyfunction!(verify_evm, m)?)?;
     m.add_function(wrap_pyfunction!(print_proof_hex, m)?)?;

tests/integration_tests.rs

@@ -882,7 +882,8 @@ mod native_tests {
             use crate::native_tests::TESTS_EVM_AGGR;
             use test_case::test_case;
             use crate::native_tests::kzg_evm_prove_and_verify;
-            use crate::native_tests::run_js_tests;
+            use crate::native_tests::kzg_evm_prove_and_verify_render_seperately;
+            
             use crate::native_tests::kzg_evm_on_chain_input_prove_and_verify;
             use crate::native_tests::kzg_evm_aggr_prove_and_verify;
             use crate::native_tests::kzg_fuzz;
@@ -988,6 +989,19 @@ mod native_tests {
 
                 }
 
+                #(#[test_case(TESTS_EVM[N])])*
+                fn kzg_evm_prove_and_verify_render_seperately_(test: &str) {
+                    crate::native_tests::init_binary();
+                    let test_dir = TempDir::new(test).unwrap();
+                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
+                    let _anvil_child = crate::native_tests::start_anvil(false, Hardfork::Latest);
+                    kzg_evm_prove_and_verify_render_seperately(2, path, test.to_string(), "private", "private", "public");
+                    // #[cfg(not(feature = "icicle"))]
+                    // run_js_tests(path, test.to_string(), "testBrowserEvmVerify");
+                    test_dir.close().unwrap();
+
+                }
+
 
                 #(#[test_case(TESTS_EVM[N])])*
                 fn kzg_evm_hashed_input_prove_and_verify_(test: &str) {
@@ -1833,6 +1847,137 @@ mod native_tests {
         assert!(!status.success());
     }
 
+    // prove-serialize-verify, the usual full path
+    fn kzg_evm_prove_and_verify_render_seperately(
+        num_inner_columns: usize,
+        test_dir: &str,
+        example_name: String,
+        input_visibility: &str,
+        param_visibility: &str,
+        output_visibility: &str,
+    ) {
+        let anvil_url = ANVIL_URL.as_str();
+
+        kzg_prove_and_verify(
+            test_dir,
+            example_name.clone(),
+            "safe",
+            input_visibility,
+            param_visibility,
+            output_visibility,
+            num_inner_columns,
+            None,
+            false,
+            "single",
+        );
+
+        let settings_path = format!("{}/{}/settings.json", test_dir, example_name);
+        init_params(settings_path.clone().into());
+
+        let vk_arg = format!("{}/{}/key.vk", test_dir, example_name);
+        let rpc_arg = format!("--rpc-url={}", anvil_url);
+        let addr_path_arg = format!("--addr-path={}/{}/addr.txt", test_dir, example_name);
+        let settings_arg = format!("--settings-path={}", settings_path);
+        let sol_arg = format!("--sol-code-path={}/{}/kzg.sol", test_dir, example_name);
+
+        // create the verifier
+        let args = vec![
+            "create-evm-verifier",
+            "--vk-path",
+            &vk_arg,
+            &settings_arg,
+            &sol_arg,
+            "--render-vk-seperately",
+        ];
+
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args(&args)
+            .status()
+            .expect("failed to execute process");
+        assert!(status.success());
+
+        let addr_path_arg_vk = format!("--addr-path={}/{}/addr_vk.txt", test_dir, example_name);
+        let sol_arg_vk = format!("--sol-code-path={}/{}/vk.sol", test_dir, example_name);
+        // create the verifier
+        let args = vec![
+            "create-evm-vk",
+            "--vk-path",
+            &vk_arg,
+            &settings_arg,
+            &sol_arg_vk,
+        ];
+
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args(&args)
+            .status()
+            .expect("failed to execute process");
+        assert!(status.success());
+
+        // deploy the verifier
+        let args = vec![
+            "deploy-evm-verifier",
+            rpc_arg.as_str(),
+            addr_path_arg.as_str(),
+            sol_arg.as_str(),
+        ];
+
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args(&args)
+            .status()
+            .expect("failed to execute process");
+        assert!(status.success());
+
+        // read in the address
+        let addr = std::fs::read_to_string(format!("{}/{}/addr.txt", test_dir, example_name))
+            .expect("failed to read address file");
+
+        let deployed_addr_arg = format!("--addr-verifier={}", addr);
+
+        // deploy the vk
+        let args = vec![
+            "deploy-evm-vk",
+            rpc_arg.as_str(),
+            addr_path_arg_vk.as_str(),
+            sol_arg_vk.as_str(),
+        ];
+
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args(&args)
+            .status()
+            .expect("failed to execute process");
+        assert!(status.success());
+
+        // read in the address
+        let addr_vk = std::fs::read_to_string(format!("{}/{}/addr_vk.txt", test_dir, example_name))
+            .expect("failed to read address file");
+
+        let deployed_addr_arg_vk = format!("--addr-vk={}", addr_vk);
+
+        // now verify the proof
+        let pf_arg = format!("{}/{}/proof.pf", test_dir, example_name);
+        let mut args = vec![
+            "verify-evm",
+            "--proof-path",
+            pf_arg.as_str(),
+            rpc_arg.as_str(),
+            deployed_addr_arg.as_str(),
+            deployed_addr_arg_vk.as_str(),
+        ];
+
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args(&args)
+            .status()
+            .expect("failed to execute process");
+        assert!(status.success());
+        // As sanity check, add example that should fail.
+        args[2] = PF_FAILURE;
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args(args)
+            .status()
+            .expect("failed to execute process");
+        assert!(!status.success());
+    }
+
     // run js browser evm verify tests for a given example
     fn run_js_tests(test_dir: &str, example_name: String, js_test: &str) {
         let status = Command::new("pnpm")