ci: update version string in docs

.github/workflows/rust.yml

@@ -345,8 +345,6 @@ jobs:
         run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_kzg_output_kzg_params_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + on chain outputs & kzg inputs + params)
         run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_output_kzg_input_kzg_params_prove_and_verify --test-threads 1
-      - name: KZG prove and verify tests (EVM + on chain all kzg)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_all_kzg_params_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + on chain inputs & outputs hashes)
         run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_output_hashed_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM)

Cargo.toml

@@ -203,7 +203,6 @@ det-prove = []
 icicle = ["halo2_proofs/icicle_gpu"]
 empty-cmd = []
 no-banner = []
-no-update = []
 metal = ["dep:metal", "dep:objc"]
 
 # icicle patch to 0.1.0 if feature icicle is enabled

contracts/AttestData.sol

@@ -93,6 +93,9 @@ contract LoadInstances {
     }
 }
 
+// Contract that checks that the COMMITMENT_KZG bytes is equal to the first part of the proof.
+pragma solidity ^0.8.0;
+
 // The kzg commitments of a given model, all aggregated into a single bytes array.
 // At solidity generation time, the commitments are hardcoded into the contract via the COMMITMENT_KZG constant.
 // It will be used to check that the proof commitments match the expected commitments.
@@ -160,7 +163,7 @@ contract SwapProofCommitments {
         }
 
         return equal; // Return true if the commitment comparison passed
-    } /// end checkKzgCommits
+    }
 }
 
 // This contract serves as a Data Attestation Verifier for the EZKL model.

docs/python/requirements-docs.txt

@@ -1,4 +1,4 @@
-ezkl==11.5.0
+ezkl==11.3.3
 sphinx
 sphinx-rtd-theme
 sphinxcontrib-napoleon

docs/python/src/conf.py

@@ -1,7 +1,7 @@
 import ezkl
 
 project = 'ezkl'
-release = '11.5.0'
+release = '11.3.3'
 version = release
 
 

src/commands.rs

@@ -379,9 +379,9 @@ pub enum Commands {
         #[arg(long = "target", default_value = DEFAULT_CALIBRATION_TARGET, value_hint = clap::ValueHint::Other)]
         /// Target for calibration. Set to "resources" to optimize for computational resource. Otherwise, set to "accuracy" to optimize for accuracy.
         target: CalibrationTarget,
-        /// the lookup safety margin to use for calibration. if the max lookup is 2^k, then the max lookup will be ceil(2^k * lookup_safety_margin). larger = safer but slower
+        /// the lookup safety margin to use for calibration. if the max lookup is 2^k, then the max lookup will be 2^k * lookup_safety_margin. larger = safer but slower
         #[arg(long, default_value = DEFAULT_LOOKUP_SAFETY_MARGIN, value_hint = clap::ValueHint::Other)]
-        lookup_safety_margin: f64,
+        lookup_safety_margin: i64,
         /// Optional scales to specifically try for calibration. Example, --scales 0,4
         #[arg(long, value_delimiter = ',', allow_hyphen_values = true, value_hint = clap::ValueHint::Other)]
         scales: Option<Vec<crate::Scale>>,
@@ -868,7 +868,6 @@ pub enum Commands {
         #[arg(long, value_hint = clap::ValueHint::Other)]
         addr_vk: Option<H160Flag>,
     },
-    #[cfg(not(feature = "no-update"))]
     /// Updates ezkl binary to version specified (or latest if not specified)
     Update {
         /// The version to update to

src/eth.rs

@@ -327,7 +327,11 @@ pub async fn setup_eth_backend(
         ProviderBuilder::new()
             .with_recommended_fillers()
             .signer(EthereumSigner::from(wallet))
-            .on_http(endpoint.parse().map_err(|_| EthError::UrlParse(endpoint))?),
+            .on_http(
+                endpoint
+                    .parse()
+                    .map_err(|_| EthError::UrlParse(endpoint.clone()))?,
+            ),
     );
 
     let chain_id = client.get_chain_id().await?;
@@ -350,7 +354,8 @@ pub async fn deploy_contract_via_solidity(
     let (abi, bytecode, runtime_bytecode) =
         get_contract_artifacts(sol_code_path, contract_name, runs).await?;
 
-    let factory = get_sol_contract_factory(abi, bytecode, runtime_bytecode, client, None::<()>)?;
+    let factory =
+        get_sol_contract_factory(abi, bytecode, runtime_bytecode, client.clone(), None::<()>)?;
     let contract = factory.deploy().await?;
 
     Ok(contract)
@@ -447,30 +452,20 @@ pub async fn deploy_da_verifier_via_solidity(
         }
     }
 
-    let (abi, bytecode, runtime_bytecode) =
-        get_contract_artifacts(sol_code_path, "DataAttestation", runs).await?;
-
     let (contract_addresses, call_data, decimals) = if !calls_to_accounts.is_empty() {
         parse_calls_to_accounts(calls_to_accounts)?
     } else {
-        // if calls to accounts is empty then we know need to check that atleast there kzg visibility in the settings file
-        let kzg_visibility = settings.run_args.input_visibility.is_polycommit()
-            || settings.run_args.output_visibility.is_polycommit()
-            || settings.run_args.param_visibility.is_polycommit();
-        if !kzg_visibility {
-            return Err(EthError::OnChainDataSource);
-        }
-        let factory =
-            get_sol_contract_factory::<_, ()>(abi, bytecode, runtime_bytecode, client, None)?;
-        let contract = factory.deploy().await?;
-        return Ok(contract);
+        return Err(EthError::OnChainDataSource);
     };
 
+    let (abi, bytecode, runtime_bytecode) =
+        get_contract_artifacts(sol_code_path, "DataAttestation", runs).await?;
+
     let factory = get_sol_contract_factory(
         abi,
         bytecode,
         runtime_bytecode,
-        client,
+        client.clone(),
         Some((
             // address[] memory _contractAddresses,
             DynSeqToken(
@@ -511,7 +506,7 @@ pub async fn deploy_da_verifier_via_solidity(
             ),
             //  uint8 _instanceOffset,
             WordToken(U256::from(contract_instance_offset as u32).into()),
-            // address _admin
+            //address _admin
             WordToken(client_address.into_word()),
         )),
     )?;
@@ -534,7 +529,7 @@ fn parse_calls_to_accounts(
     let mut call_data = vec![];
     let mut decimals: Vec<Vec<U256>> = vec![];
     for (i, val) in calls_to_accounts.iter().enumerate() {
-        let contract_address_bytes = hex::decode(&val.address)?;
+        let contract_address_bytes = hex::decode(val.address.clone())?;
         let contract_address = H160::from_slice(&contract_address_bytes);
         contract_addresses.push(contract_address);
         call_data.push(vec![]);
@@ -578,7 +573,7 @@ pub async fn update_account_calls(
 
     let (client, client_address) = setup_eth_backend(rpc_url, None).await?;
 
-    let contract = DataAttestation::new(addr, &client);
+    let contract = DataAttestation::new(addr, client.clone());
 
     info!("contract_addresses: {:#?}", contract_addresses);
 
@@ -809,7 +804,7 @@ pub async fn test_on_chain_data<M: 'static + Provider<Http<Client>, Ethereum>>(
     client: Arc<M>,
     data: &[Vec<FileSourceInner>],
 ) -> Result<Vec<CallsToAccount>, EthError> {
-    let (contract, decimals) = setup_test_contract(client, data).await?;
+    let (contract, decimals) = setup_test_contract(client.clone(), data).await?;
 
     // Get the encoded call data for each input
     let mut calldata = vec![];
@@ -841,10 +836,10 @@ pub async fn read_on_chain_inputs<M: 'static + Provider<Http<Client>, Ethereum>>
     let mut decimals = vec![];
     for on_chain_data in data {
         // Construct the address
-        let contract_address_bytes = hex::decode(&on_chain_data.address)?;
+        let contract_address_bytes = hex::decode(on_chain_data.address.clone())?;
         let contract_address = H160::from_slice(&contract_address_bytes);
         for (call_data, decimal) in &on_chain_data.call_data {
-            let call_data_bytes = hex::decode(call_data)?;
+            let call_data_bytes = hex::decode(call_data.clone())?;
             let input: TransactionInput = call_data_bytes.into();
 
             let tx = TransactionRequest::default()
@@ -871,8 +866,8 @@ pub async fn evm_quantize<M: 'static + Provider<Http<Client>, Ethereum>>(
 ) -> Result<Vec<Fr>, EthError> {
     let contract = QuantizeData::deploy(&client).await?;
 
-    let fetched_inputs = &data.0;
-    let decimals = &data.1;
+    let fetched_inputs = data.0.clone();
+    let decimals = data.1.clone();
 
     let fetched_inputs = fetched_inputs
         .iter()
@@ -948,7 +943,7 @@ fn get_sol_contract_factory<'a, M: 'static + Provider<Http<Client>, Ethereum>, T
         (None, false) => {
             return Err(EthError::NoConstructor);
         }
-        (None, true) => bytecode,
+        (None, true) => bytecode.clone(),
         (Some(_), _) => {
             let mut data = bytecode.to_vec();
 
@@ -960,7 +955,7 @@ fn get_sol_contract_factory<'a, M: 'static + Provider<Http<Client>, Ethereum>, T
         }
     };
 
-    Ok(CallBuilder::new_raw_deploy(client, data))
+    Ok(CallBuilder::new_raw_deploy(client.clone(), data))
 }
 
 /// Compiles a solidity verifier contract and returns the abi, bytecode, and runtime bytecode
@@ -1035,7 +1030,7 @@ pub fn fix_da_sol(
 
     // fill in the quantization params and total calls
     // as constants to the contract to save on gas
-    if let Some(input_data) = &input_data {
+    if let Some(input_data) = input_data {
         let input_calls: usize = input_data.iter().map(|v| v.call_data.len()).sum();
         accounts_len = input_data.len();
         contract = contract.replace(
@@ -1043,7 +1038,7 @@ pub fn fix_da_sol(
             &format!("uint256 constant INPUT_CALLS = {};", input_calls),
         );
     }
-    if let Some(output_data) = &output_data {
+    if let Some(output_data) = output_data {
         let output_calls: usize = output_data.iter().map(|v| v.call_data.len()).sum();
         accounts_len += output_data.len();
         contract = contract.replace(
@@ -1053,9 +1048,8 @@ pub fn fix_da_sol(
     }
     contract = contract.replace("AccountCall[]", &format!("AccountCall[{}]", accounts_len));
 
-    // The case where a combination of on-chain data source + kzg commit is provided.
-    if commitment_bytes.is_some() && !commitment_bytes.as_ref().unwrap().is_empty() {
-        let commitment_bytes = commitment_bytes.as_ref().unwrap();
+    if commitment_bytes.clone().is_some() && !commitment_bytes.clone().unwrap().is_empty() {
+        let commitment_bytes = commitment_bytes.unwrap();
         let hex_string = hex::encode(commitment_bytes);
         contract = contract.replace(
             "bytes constant COMMITMENT_KZG = hex\"\";",
@@ -1070,44 +1064,5 @@ pub fn fix_da_sol(
         );
     }
 
-    // if both input and output data is none then we will only deploy the DataAttest contract, adding in the verifyWithDataAttestation function
-    if input_data.is_none()
-        && output_data.is_none()
-        && commitment_bytes.as_ref().is_some()
-        && !commitment_bytes.as_ref().unwrap().is_empty()
-    {
-        contract = contract.replace(
-            "contract SwapProofCommitments {",
-            "contract DataAttestation {",
-        );
-
-        // Remove everything past the end of the checkKzgCommits function
-        if let Some(pos) = contract.find("    } /// end checkKzgCommits") {
-            contract.truncate(pos);
-            contract.push('}');
-        }
-
-        // Add the Solidity function below checkKzgCommits
-        contract.push_str(
-            r#"
-    function verifyWithDataAttestation(
-        address verifier,
-        bytes calldata encoded
-    ) public view returns (bool) {
-        require(verifier.code.length > 0, "Address: call to non-contract");
-        require(checkKzgCommits(encoded), "Invalid KZG commitments");
-        // static call the verifier contract to verify the proof
-        (bool success, bytes memory returndata) = verifier.staticcall(encoded);
-
-        if (success) {
-            return abi.decode(returndata, (bool));
-        } else {
-            revert("low-level call to verifier failed");
-        }
-    }
-}"#,
-        );
-    }
-
     Ok(contract)
 }

src/execute.rs

@@ -506,12 +506,10 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             )
             .await
         }
-        #[cfg(not(feature = "no-update"))]
         Commands::Update { version } => update_ezkl_binary(&version).map(|e| e.to_string()),
     }
 }
 
-#[cfg(not(feature = "no-update"))]
 /// Assert that the version is valid
 fn assert_version_is_valid(version: &str) -> Result<(), EZKLError> {
     let err_string = "Invalid version string. Must be in the format v0.0.0";
@@ -529,10 +527,8 @@ fn assert_version_is_valid(version: &str) -> Result<(), EZKLError> {
     Ok(())
 }
 
-#[cfg(not(feature = "no-update"))]
 const INSTALL_BYTES: &[u8] = include_bytes!("../install_ezkl_cli.sh");
 
-#[cfg(not(feature = "no-update"))]
 fn update_ezkl_binary(version: &Option<String>) -> Result<String, EZKLError> {
     // run the install script with the version
     let install_script = std::str::from_utf8(INSTALL_BYTES)?;
@@ -1013,7 +1009,7 @@ pub(crate) async fn calibrate(
     data: PathBuf,
     settings_path: PathBuf,
     target: CalibrationTarget,
-    lookup_safety_margin: f64,
+    lookup_safety_margin: i64,
     scales: Option<Vec<crate::Scale>>,
     scale_rebase_multiplier: Vec<u32>,
     only_range_check_rebase: bool,

src/graph/errors.rs

@@ -41,9 +41,9 @@ pub enum GraphError {
     /// Error when attempting to rescale an operation
     #[error("failed to rescale inputs for {0}")]
     RescalingError(String),
-    /// Reading a file failed
-    #[error("[io] ({0}) {1}")]
-    ReadWriteFileError(String, String),
+    /// Error when attempting to load a model from a file
+    #[error("failed to load model")]
+    ModelLoad(#[from] std::io::Error),
     /// Model serialization error
     #[error("failed to ser/deser model: {0}")]
     ModelSerialize(#[from] bincode::Error),

src/graph/input.rs

@@ -485,25 +485,18 @@ impl GraphData {
 
     /// Load the model input from a file
     pub fn from_path(path: std::path::PathBuf) -> Result<Self, GraphError> {
-        let reader = std::fs::File::open(&path).map_err(|e| {
-            GraphError::ReadWriteFileError(path.display().to_string(), e.to_string())
-        })?;
+        let reader = std::fs::File::open(path)?;
         let mut reader = BufReader::with_capacity(*EZKL_BUF_CAPACITY, reader);
         let mut buf = String::new();
-        reader.read_to_string(&mut buf).map_err(|e| {
-            GraphError::ReadWriteFileError(path.display().to_string(), e.to_string())
-        })?;
+        reader.read_to_string(&mut buf)?;
         let graph_input = serde_json::from_str(&buf)?;
         Ok(graph_input)
     }
 
     /// Save the model input to a file
     pub fn save(&self, path: std::path::PathBuf) -> Result<(), GraphError> {
-        let file = std::fs::File::create(path.clone()).map_err(|e| {
-            GraphError::ReadWriteFileError(path.display().to_string(), e.to_string())
-        })?;
         // buf writer
-        let writer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, file);
+        let writer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, std::fs::File::create(path)?);
         serde_json::to_writer(writer, self)?;
         Ok(())
     }

src/graph/mod.rs

@@ -267,9 +267,7 @@ impl GraphWitness {
 
     /// Load the model input from a file
     pub fn from_path(path: std::path::PathBuf) -> Result<Self, GraphError> {
-        let file = std::fs::File::open(path.clone()).map_err(|e| {
-            GraphError::ReadWriteFileError(path.display().to_string(), e.to_string())
-        })?;
+        let file = std::fs::File::open(path.clone())?;
 
         let reader = std::io::BufReader::with_capacity(*EZKL_BUF_CAPACITY, file);
         serde_json::from_reader(reader).map_err(|e| e.into())
@@ -277,11 +275,9 @@ impl GraphWitness {
 
     /// Save the model input to a file
     pub fn save(&self, path: std::path::PathBuf) -> Result<(), GraphError> {
-        let file = std::fs::File::create(path.clone()).map_err(|e| {
-            GraphError::ReadWriteFileError(path.display().to_string(), e.to_string())
-        })?;
         // use buf writer
-        let writer = std::io::BufWriter::with_capacity(*EZKL_BUF_CAPACITY, file);
+        let writer =
+            std::io::BufWriter::with_capacity(*EZKL_BUF_CAPACITY, std::fs::File::create(path)?);
 
         serde_json::to_writer(writer, &self).map_err(|e| e.into())
     }
@@ -644,9 +640,7 @@ impl GraphCircuit {
     }
     ///
     pub fn save(&self, path: std::path::PathBuf) -> Result<(), GraphError> {
-        let f = std::fs::File::create(&path).map_err(|e| {
-            GraphError::ReadWriteFileError(path.display().to_string(), e.to_string())
-        })?;
+        let f = std::fs::File::create(path)?;
         let writer = std::io::BufWriter::with_capacity(*EZKL_BUF_CAPACITY, f);
         bincode::serialize_into(writer, &self)?;
         Ok(())
@@ -655,9 +649,7 @@ impl GraphCircuit {
     ///
     pub fn load(path: std::path::PathBuf) -> Result<Self, GraphError> {
         // read bytes from file
-        let f = std::fs::File::open(&path).map_err(|e| {
-            GraphError::ReadWriteFileError(path.display().to_string(), e.to_string())
-        })?;
+        let f = std::fs::File::open(path)?;
         let reader = std::io::BufReader::with_capacity(*EZKL_BUF_CAPACITY, f);
         let result: GraphCircuit = bincode::deserialize_from(reader)?;
 
@@ -1034,10 +1026,10 @@ impl GraphCircuit {
         Ok(data)
     }
 
-    fn calc_safe_lookup_range(min_max_lookup: Range, lookup_safety_margin: f64) -> Range {
+    fn calc_safe_lookup_range(min_max_lookup: Range, lookup_safety_margin: i64) -> Range {
         (
-            (lookup_safety_margin * min_max_lookup.0 as f64).floor() as i64,
-            (lookup_safety_margin * min_max_lookup.1 as f64).ceil() as i64,
+            lookup_safety_margin * min_max_lookup.0,
+            lookup_safety_margin * min_max_lookup.1,
         )
     }
 
@@ -1070,7 +1062,7 @@ impl GraphCircuit {
         min_max_lookup: Range,
         max_range_size: i64,
         max_logrows: Option<u32>,
-        lookup_safety_margin: f64,
+        lookup_safety_margin: i64,
     ) -> Result<(), GraphError> {
         // load the max logrows
         let max_logrows = max_logrows.unwrap_or(MAX_PUBLIC_SRS);
@@ -1080,13 +1072,9 @@ impl GraphCircuit {
 
         let safe_lookup_range = Self::calc_safe_lookup_range(min_max_lookup, lookup_safety_margin);
 
-        // check if subtraction overflows
-
-        let lookup_size =
-            (safe_lookup_range.1.saturating_sub(safe_lookup_range.0)).saturating_abs();
+        let lookup_size = (safe_lookup_range.1 - safe_lookup_range.0).abs();
         // check if has overflowed max lookup input
-
-        if lookup_size > (MAX_LOOKUP_ABS as f64 / lookup_safety_margin).floor() as i64 {
+        if lookup_size > MAX_LOOKUP_ABS / lookup_safety_margin {
             return Err(GraphError::LookupRangeTooLarge(
                 lookup_size.unsigned_abs() as usize
             ));

src/graph/model.rs

@@ -483,9 +483,7 @@ impl Model {
 
     ///
     pub fn save(&self, path: PathBuf) -> Result<(), GraphError> {
-        let f = std::fs::File::create(&path).map_err(|e| {
-            GraphError::ReadWriteFileError(path.display().to_string(), e.to_string())
-        })?;
+        let f = std::fs::File::create(path)?;
         let writer = std::io::BufWriter::new(f);
         bincode::serialize_into(writer, &self)?;
         Ok(())
@@ -494,16 +492,10 @@ impl Model {
     ///
     pub fn load(path: PathBuf) -> Result<Self, GraphError> {
         // read bytes from file
-        let mut f = std::fs::File::open(&path).map_err(|e| {
-            GraphError::ReadWriteFileError(path.display().to_string(), e.to_string())
-        })?;
-        let metadata = fs::metadata(&path).map_err(|e| {
-            GraphError::ReadWriteFileError(path.display().to_string(), e.to_string())
-        })?;
+        let mut f = std::fs::File::open(&path)?;
+        let metadata = fs::metadata(&path)?;
         let mut buffer = vec![0; metadata.len() as usize];
-        f.read_exact(&mut buffer).map_err(|e| {
-            GraphError::ReadWriteFileError(path.display().to_string(), e.to_string())
-        })?;
+        f.read_exact(&mut buffer)?;
         let result = bincode::deserialize(&buffer)?;
         Ok(result)
     }
@@ -983,11 +975,8 @@ impl Model {
     ) -> Result<Vec<Vec<Tensor<f32>>>, GraphError> {
         use tract_onnx::tract_core::internal::IntoArcTensor;
 
-        let mut file = std::fs::File::open(model_path).map_err(|e| {
-            GraphError::ReadWriteFileError(model_path.display().to_string(), e.to_string())
-        })?;
-
-        let (model, _) = Model::load_onnx_using_tract(&mut file, run_args)?;
+        let (model, _) =
+            Model::load_onnx_using_tract(&mut std::fs::File::open(model_path)?, run_args)?;
 
         let datum_types: Vec<DatumType> = model
             .input_outlets()?
@@ -1016,10 +1005,7 @@ impl Model {
     /// * `params` - A [GraphSettings] struct holding parsed CLI arguments.
     #[cfg(not(target_arch = "wasm32"))]
     pub fn from_run_args(run_args: &RunArgs, model: &std::path::Path) -> Result<Self, GraphError> {
-        let mut file = std::fs::File::open(model).map_err(|e| {
-            GraphError::ReadWriteFileError(model.display().to_string(), e.to_string())
-        })?;
-        Model::new(&mut file, run_args)
+        Model::new(&mut std::fs::File::open(model)?, run_args)
     }
 
     /// Configures a model for the circuit

src/python.rs

@@ -887,7 +887,7 @@ fn calibrate_settings(
     model: PathBuf,
     settings: PathBuf,
     target: CalibrationTarget,
-    lookup_safety_margin: f64,
+    lookup_safety_margin: i64,
     scales: Option<Vec<crate::Scale>>,
     scale_rebase_multiplier: Vec<u32>,
     max_logrows: Option<u32>,
@@ -1491,7 +1491,7 @@ fn encode_evm_calldata<'a>(
 ///     The path to the SRS file
 ///
 /// render_vk_separately: bool
-///     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
+///     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
 ///
 /// Returns
 /// -------
@@ -1533,56 +1533,6 @@ fn create_evm_verifier(
     })
 }
 
-/// Creates an Evm verifer key. This command should be called after create_evm_verifier with the render_vk_separately arg set to true. By rendering a verification key separately you can reuse the same verifier for similar circuit setups with different verifying keys, helping to reduce the amount of state our verifiers store on the blockchain.
-///
-/// Arguments
-/// ---------
-/// vk_path: str
-///     The path to the verification key file
-///
-/// settings_path: str
-///     The path to the settings file
-///
-/// sol_code_path: str
-///     The path to the create the solidity verifying key.
-///
-/// abi_path: str
-///     The path to create the ABI for the solidity verifier
-///
-/// srs_path: str
-///     The path to the SRS file
-///
-/// Returns
-/// -------
-/// bool
-///
-#[pyfunction(signature = (
-    vk_path=PathBuf::from(DEFAULT_VK),
-    settings_path=PathBuf::from(DEFAULT_SETTINGS),
-    sol_code_path=PathBuf::from(DEFAULT_VK_SOL),
-    abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
-    srs_path=None
-))]
-fn create_evm_vk(
-    py: Python,
-    vk_path: PathBuf,
-    settings_path: PathBuf,
-    sol_code_path: PathBuf,
-    abi_path: PathBuf,
-    srs_path: Option<PathBuf>,
-) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_asyncio::tokio::future_into_py(py, async move {
-        crate::execute::create_evm_vk(vk_path, srs_path, settings_path, sol_code_path, abi_path)
-            .await
-            .map_err(|e| {
-                let err_str = format!("Failed to run create_evm_verifier: {}", e);
-                PyRuntimeError::new_err(err_str)
-            })?;
-
-        Ok(true)
-    })
-}
-
 /// Creates an EVM compatible data attestation verifier, you will need solc installed in your environment to run this
 ///
 /// Arguments
@@ -1812,7 +1762,7 @@ fn deploy_da_evm(
 /// Arguments
 /// ---------
 /// addr_verifier: str
-///     The verifier contract's address as a hex string
+///     The path to verifier contract's address
 ///
 /// proof_path: str
 ///     The path to the proof file (generated using the prove command)
@@ -1824,7 +1774,7 @@ fn deploy_da_evm(
 ///     does the verifier use data attestation ?
 ///
 /// addr_vk: str
-///     The addess of the separate VK contract (if the verifier key is rendered as a separate contract)
+///
 /// Returns
 /// -------
 /// bool
@@ -1975,7 +1925,6 @@ fn ezkl(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(compile_circuit, m)?)?;
     m.add_function(wrap_pyfunction!(verify_aggr, m)?)?;
     m.add_function(wrap_pyfunction!(create_evm_verifier, m)?)?;
-    m.add_function(wrap_pyfunction!(create_evm_vk, 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)?)?;

tests/integration_tests.rs

@@ -1066,15 +1066,6 @@ mod native_tests {
                     kzg_evm_on_chain_input_prove_and_verify(path, test.to_string(), "file", "on-chain", "polycommit", "public", "polycommit");
                     test_dir.close().unwrap();
                 }
-                #(#[test_case(TESTS_ON_CHAIN_INPUT[N])])*
-                fn kzg_evm_on_chain_all_kzg_params_prove_and_verify_(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(true, Hardfork::Latest);
-                    kzg_evm_on_chain_input_prove_and_verify(path, test.to_string(), "file", "file", "polycommit", "polycommit", "polycommit");
-                    test_dir.close().unwrap();
-                }
             });
 
 
@@ -2339,6 +2330,7 @@ mod native_tests {
 
         let model_path = format!("{}/{}/network.compiled", test_dir, example_name);
         let settings_path = format!("{}/{}/settings.json", test_dir, example_name);
+
         init_params(settings_path.clone().into());
 
         let data_path = format!("{}/{}/input.json", test_dir, example_name);
@@ -2350,6 +2342,62 @@ mod native_tests {
         let test_input_source = format!("--input-source={}", input_source);
         let test_output_source = format!("--output-source={}", output_source);
 
+        // load witness
+        let witness: GraphWitness = GraphWitness::from_path(witness_path.clone().into()).unwrap();
+        let mut input: GraphData = GraphData::from_path(data_path.clone().into()).unwrap();
+
+        if input_visibility == "hashed" {
+            let hashes = witness.processed_inputs.unwrap().poseidon_hash.unwrap();
+            input.input_data = DataSource::File(
+                hashes
+                    .iter()
+                    .map(|h| vec![FileSourceInner::Field(*h)])
+                    .collect(),
+            );
+        }
+        if output_visibility == "hashed" {
+            let hashes = witness.processed_outputs.unwrap().poseidon_hash.unwrap();
+            input.output_data = Some(DataSource::File(
+                hashes
+                    .iter()
+                    .map(|h| vec![FileSourceInner::Field(*h)])
+                    .collect(),
+            ));
+        } else {
+            input.output_data = Some(DataSource::File(
+                witness
+                    .pretty_elements
+                    .unwrap()
+                    .rescaled_outputs
+                    .iter()
+                    .map(|o| {
+                        o.iter()
+                            .map(|f| FileSourceInner::Float(f.parse().unwrap()))
+                            .collect()
+                    })
+                    .collect(),
+            ));
+        }
+
+        input.save(data_path.clone().into()).unwrap();
+
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args([
+                "setup-test-evm-data",
+                "-D",
+                data_path.as_str(),
+                "-M",
+                &model_path,
+                "--test-data",
+                test_on_chain_data_path.as_str(),
+                rpc_arg.as_str(),
+                test_input_source.as_str(),
+                test_output_source.as_str(),
+            ])
+            .status()
+            .expect("failed to execute process");
+        assert!(status.success());
+
         let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "setup",
@@ -2364,82 +2412,6 @@ mod native_tests {
             .expect("failed to execute process");
         assert!(status.success());
 
-        // generate the witness, passing the vk path to generate the necessary kzg commits
-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
-            .args([
-                "gen-witness",
-                "-D",
-                &data_path,
-                "-M",
-                &model_path,
-                "-O",
-                &witness_path,
-                "--vk-path",
-                &format!("{}/{}/key.vk", test_dir, example_name),
-            ])
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
-
-        // load witness
-        let witness: GraphWitness = GraphWitness::from_path(witness_path.clone().into()).unwrap();
-        // print out the witness
-        println!("WITNESS: {:?}", witness);
-        let mut input: GraphData = GraphData::from_path(data_path.clone().into()).unwrap();
-        if input_source != "file" || output_source != "file" {
-            println!("on chain input");
-            if input_visibility == "hashed" {
-                let hashes = witness.processed_inputs.unwrap().poseidon_hash.unwrap();
-                input.input_data = DataSource::File(
-                    hashes
-                        .iter()
-                        .map(|h| vec![FileSourceInner::Field(*h)])
-                        .collect(),
-                );
-            }
-            if output_visibility == "hashed" {
-                let hashes = witness.processed_outputs.unwrap().poseidon_hash.unwrap();
-                input.output_data = Some(DataSource::File(
-                    hashes
-                        .iter()
-                        .map(|h| vec![FileSourceInner::Field(*h)])
-                        .collect(),
-                ));
-            } else {
-                input.output_data = Some(DataSource::File(
-                    witness
-                        .pretty_elements
-                        .unwrap()
-                        .rescaled_outputs
-                        .iter()
-                        .map(|o| {
-                            o.iter()
-                                .map(|f| FileSourceInner::Float(f.parse().unwrap()))
-                                .collect()
-                        })
-                        .collect(),
-                ));
-            }
-            input.save(data_path.clone().into()).unwrap();
-
-            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
-                .args([
-                    "setup-test-evm-data",
-                    "-D",
-                    data_path.as_str(),
-                    "-M",
-                    &model_path,
-                    "--test-data",
-                    test_on_chain_data_path.as_str(),
-                    rpc_arg.as_str(),
-                    test_input_source.as_str(),
-                    test_output_source.as_str(),
-                ])
-                .status()
-                .expect("failed to execute process");
-            assert!(status.success());
-        }
-
         let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "prove",
@@ -2530,19 +2502,13 @@ mod native_tests {
             .expect("failed to execute process");
         assert!(status.success());
 
-        let deploy_evm_data_path = if input_source != "file" || output_source != "file" {
-            test_on_chain_data_path.clone()
-        } else {
-            data_path.clone()
-        };
-
         let addr_path_da_arg = format!("--addr-path={}/{}/addr_da.txt", test_dir, example_name);
         let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "deploy-evm-da",
                 format!("--settings-path={}", settings_path).as_str(),
                 "-D",
-                deploy_evm_data_path.as_str(),
+                test_on_chain_data_path.as_str(),
                 "--sol-code-path",
                 sol_arg.as_str(),
                 rpc_arg.as_str(),
@@ -2580,42 +2546,40 @@ mod native_tests {
             .status()
             .expect("failed to execute process");
         assert!(status.success());
-        // Create a new set of test on chain data only for the on-chain input source
-        if input_source != "file" || output_source != "file" {
-            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
-                .args([
-                    "setup-test-evm-data",
-                    "-D",
-                    data_path.as_str(),
-                    "-M",
-                    &model_path,
-                    "--test-data",
-                    test_on_chain_data_path.as_str(),
-                    rpc_arg.as_str(),
-                    test_input_source.as_str(),
-                    test_output_source.as_str(),
-                ])
-                .status()
-                .expect("failed to execute process");
-
-            assert!(status.success());
-
-            let deployed_addr_arg = format!("--addr={}", addr_da);
-
-            let args: Vec<&str> = vec![
-                "test-update-account-calls",
-                deployed_addr_arg.as_str(),
+        // Create a new set of test on chain data
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args([
+                "setup-test-evm-data",
                 "-D",
+                data_path.as_str(),
+                "-M",
+                &model_path,
+                "--test-data",
                 test_on_chain_data_path.as_str(),
                 rpc_arg.as_str(),
-            ];
-            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
-                .args(&args)
-                .status()
-                .expect("failed to execute process");
+                test_input_source.as_str(),
+                test_output_source.as_str(),
+            ])
+            .status()
+            .expect("failed to execute process");
 
-            assert!(status.success());
-        }
+        assert!(status.success());
+
+        let deployed_addr_arg = format!("--addr={}", addr_da);
+
+        let args = vec![
+            "test-update-account-calls",
+            deployed_addr_arg.as_str(),
+            "-D",
+            test_on_chain_data_path.as_str(),
+            rpc_arg.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.
         let args = vec![
             "verify-evm",

tests/python/binding_tests.py

@@ -423,74 +423,6 @@ async def test_create_evm_verifier():
     assert res == True
     assert os.path.isfile(sol_code_path)
 
-async def test_create_evm_verifier_separate_vk():
-    """
-    Create EVM a verifier with solidity code and separate vk
-    In order to run this test you will need to install solc in your environment
-    """
-    vk_path = os.path.join(folder_path, 'test_evm.vk')
-    settings_path = os.path.join(folder_path, 'settings.json')
-    sol_code_path = os.path.join(folder_path, 'test_separate.sol')
-    vk_code_path = os.path.join(folder_path, 'test_vk.sol')
-    abi_path = os.path.join(folder_path, 'test_separate.abi')
-    abi_vk_path = os.path.join(folder_path, 'test_vk_separate.abi')
-    proof_path = os.path.join(folder_path, 'test_evm.pf')
-    calldata_path = os.path.join(folder_path, 'calldata.bytes')
-
-    # # res is now a vector of bytes
-    # res = ezkl.encode_evm_calldata(proof_path, calldata_path)
-
-    # assert os.path.isfile(calldata_path)
-    # assert len(res) > 0
-
-
-    res = await ezkl.create_evm_verifier(
-        vk_path,
-        settings_path,
-        sol_code_path,
-        abi_path,
-        srs_path=srs_path,
-        render_vk_seperately=True
-    )
-
-    res = await ezkl.create_evm_vk(
-        vk_path,
-        settings_path,
-        vk_code_path,
-        abi_vk_path,
-        srs_path=srs_path,
-    )
-
-    assert res == True
-    assert os.path.isfile(sol_code_path)
-
-
-async def test_deploy_evm_separate_vk():
-    """
-    Test deployment of the separate verifier smart contract + vk
-    In order to run this you will need to install solc in your environment
-    """
-    addr_path_verifier = os.path.join(folder_path, 'address_separate.json')
-    addr_path_vk = os.path.join(folder_path, 'address_vk.json')
-    sol_code_path = os.path.join(folder_path, 'test_separate.sol')
-    vk_code_path = os.path.join(folder_path, 'test_vk.sol')
-
-    # TODO: without optimization there will be out of gas errors
-    # sol_code_path = os.path.join(folder_path, 'test.sol')
-
-    res = await ezkl.deploy_evm(
-        addr_path_verifier,
-        sol_code_path,
-        rpc_url=anvil_url,
-    )
-
-    res = await ezkl.deploy_vk_evm(
-        addr_path_vk,
-        vk_code_path,
-        rpc_url=anvil_url,
-    )
-
-    assert res == True
 
 async def test_deploy_evm():
     """
@@ -571,47 +503,6 @@ async def test_verify_evm():
 
     assert res == True
 
-async def test_verify_evm_separate_vk():
-    """
-    Verifies an evm proof
-    In order to run this you will need to install solc in your environment
-    """
-    proof_path = os.path.join(folder_path, 'test_evm.pf')
-    addr_path_verifier = os.path.join(folder_path, 'address_separate.json')
-    addr_path_vk = os.path.join(folder_path, 'address_vk.json')
-    proof_path = os.path.join(folder_path, 'test_evm.pf')
-    calldata_path = os.path.join(folder_path, 'calldata_separate.bytes')
-
-    with open(addr_path_verifier, 'r') as file:
-        addr_verifier = file.read().rstrip()
-
-    print(addr_verifier)
-
-    with open(addr_path_vk, 'r') as file:
-        addr_vk = file.read().rstrip()
-
-    print(addr_vk)
-
-    # res is now a vector of bytes
-    res = ezkl.encode_evm_calldata(proof_path, calldata_path, addr_vk=addr_vk)
-
-    assert os.path.isfile(calldata_path)
-    assert len(res) > 0
-
-    # TODO: without optimization there will be out of gas errors
-    # sol_code_path = os.path.join(folder_path, 'test.sol')
-
-    res = await ezkl.verify_evm(
-        addr_verifier,
-        proof_path,
-        rpc_url=anvil_url,
-        addr_vk=addr_vk,
-        # sol_code_path
-        # optimizer_runs
-    )
-
-    assert res == True
-
 
 async def test_aggregate_and_verify_aggr():
     data_path = os.path.join(