ci: update version string in docs

docs/python/requirements-docs.txt

@@ -1,4 +1,4 @@
-ezkl==10.4.1
+ezkl==10.3.5
 sphinx
 sphinx-rtd-theme
 sphinxcontrib-napoleon

docs/python/src/conf.py

@@ -1,7 +1,7 @@
 import ezkl
 
 project = 'ezkl'
-release = '10.4.1'
+release = '10.3.5'
 version = release
 
 

src/lib.rs

@@ -200,13 +200,13 @@ pub struct RunArgs {
     /// Hand-written parser for graph variables, eg. batch_size=1
     #[arg(short = 'V', long, value_parser = parse_key_val::<String, usize>, default_value = "batch_size->1", value_delimiter = ',')]
     pub variables: Vec<(String, usize)>,
-    /// Flags whether inputs are public, private, hashed, fixed, kzgcommit
+    /// Flags whether inputs are public, private, hashed
     #[arg(long, default_value = "private")]
     pub input_visibility: Visibility,
-    /// Flags whether outputs are public, private, fixed, hashed, kzgcommit
+    /// Flags whether outputs are public, private, hashed
     #[arg(long, default_value = "public")]
     pub output_visibility: Visibility,
-    /// Flags whether params are fixed, private, hashed, kzgcommit
+    /// Flags whether params are public, private, hashed
     #[arg(long, default_value = "private")]
     pub param_visibility: Visibility,
     #[arg(long, default_value = "false")]
@@ -248,12 +248,6 @@ impl Default for RunArgs {
 impl RunArgs {
     ///
     pub fn validate(&self) -> Result<(), Box<dyn std::error::Error>> {
-        if self.param_visibility == Visibility::Public {
-            return Err(
-                "params cannot be public instances, you are probably trying to use `fixed` or `kzgcommit`"
-                    .into(),
-            );
-        }
         if self.scale_rebase_multiplier < 1 {
             return Err("scale_rebase_multiplier must be >= 1".into());
         }

src/wasm.rs

@@ -1,4 +1,3 @@
-use crate::circuit::modules::polycommit::PolyCommitChip;
 use crate::circuit::modules::poseidon::spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH};
 use crate::circuit::modules::poseidon::PoseidonChip;
 use crate::circuit::modules::Module;
@@ -148,45 +147,6 @@ pub fn floatToFelt(
     )?))
 }
 
-/// Generate a kzg commitment.
-#[wasm_bindgen]
-#[allow(non_snake_case)]
-pub fn kzgCommit(
-    message: wasm_bindgen::Clamped<Vec<u8>>,
-    vk: wasm_bindgen::Clamped<Vec<u8>>,
-    settings: wasm_bindgen::Clamped<Vec<u8>>,
-    params_ser: wasm_bindgen::Clamped<Vec<u8>>,
-) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
-    let message: Vec<Fr> = serde_json::from_slice(&message[..])
-        .map_err(|e| JsError::new(&format!("Failed to deserialize message: {}", e)))?;
-
-    let mut reader = std::io::BufReader::new(&params_ser[..]);
-    let params: ParamsKZG<Bn256> =
-        halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader)
-            .map_err(|e| JsError::new(&format!("Failed to deserialize params: {}", e)))?;
-
-    let mut reader = std::io::BufReader::new(&vk[..]);
-    let circuit_settings: GraphSettings = serde_json::from_slice(&settings[..])
-        .map_err(|e| JsError::new(&format!("Failed to deserialize settings: {}", e)))?;
-    let vk = VerifyingKey::<G1Affine>::read::<_, GraphCircuit>(
-        &mut reader,
-        halo2_proofs::SerdeFormat::RawBytes,
-        circuit_settings,
-    )
-    .map_err(|e| JsError::new(&format!("Failed to deserialize vk: {}", e)))?;
-
-    let output = PolyCommitChip::commit::<KZGCommitmentScheme<Bn256>>(
-        message,
-        vk.cs().degree() as u32,
-        (vk.cs().blinding_factors() + 1) as u32,
-        &params,
-    );
-
-    Ok(wasm_bindgen::Clamped(
-        serde_json::to_vec(&output).map_err(|e| JsError::new(&format!("{}", e)))?,
-    ))
-}
-
 /// Converts a buffer to vector of 4 u64s representing a fixed point field element
 #[wasm_bindgen]
 #[allow(non_snake_case)]

tests/wasm.rs

@@ -1,29 +1,21 @@
 #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
 #[cfg(test)]
 mod wasm32 {
-    use ezkl::circuit::modules::polycommit::PolyCommitChip;
     use ezkl::circuit::modules::poseidon::spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH};
     use ezkl::circuit::modules::poseidon::PoseidonChip;
     use ezkl::circuit::modules::Module;
     use ezkl::graph::modules::POSEIDON_LEN_GRAPH;
-    use ezkl::graph::GraphCircuit;
-    use ezkl::graph::{GraphSettings, GraphWitness};
+    use ezkl::graph::GraphWitness;
     use ezkl::pfsys;
     use ezkl::wasm::{
         bufferToVecOfFelt, compiledCircuitValidation, encodeVerifierCalldata, feltToBigEndian,
         feltToFloat, feltToInt, feltToLittleEndian, genPk, genVk, genWitness, inputValidation,
-        kzgCommit, pkValidation, poseidonHash, proofValidation, prove, settingsValidation,
-        srsValidation, u8_array_to_u128_le, verify, verifyAggr, vkValidation, witnessValidation,
+        pkValidation, poseidonHash, proofValidation, prove, settingsValidation, srsValidation,
+        u8_array_to_u128_le, verify, verifyAggr, vkValidation, witnessValidation,
     };
-    use halo2_proofs::plonk::VerifyingKey;
-    use halo2_proofs::poly::commitment::CommitmentScheme;
-    use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-    use halo2_proofs::poly::kzg::commitment::ParamsKZG;
     use halo2_solidity_verifier::encode_calldata;
-    use halo2curves::bn256::Bn256;
     use halo2curves::bn256::{Fr, G1Affine};
     use snark_verifier::util::arithmetic::PrimeField;
-    use wasm_bindgen::JsError;
     #[cfg(feature = "web")]
     pub use wasm_bindgen_rayon::init_thread_pool;
     use wasm_bindgen_test::*;
@@ -98,46 +90,6 @@ mod wasm32 {
         assert_eq!(calldata, reference_calldata);
     }
 
-    #[wasm_bindgen_test]
-    fn verify_kzg_commit() {
-        // create a vector of field elements Vec<Fr> and assign it to the message variable
-        let mut message: Vec<Fr> = vec![];
-        for i in 0..32 {
-            message.push(Fr::from(i as u64));
-        }
-        let message_ser = serde_json::to_vec(&message).unwrap();
-
-        let settings: GraphSettings = serde_json::from_slice(&SETTINGS).unwrap();
-        let mut reader = std::io::BufReader::new(SRS);
-        let params: ParamsKZG<Bn256> =
-            halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader).unwrap();
-        let mut reader = std::io::BufReader::new(VK);
-        let vk = VerifyingKey::<G1Affine>::read::<_, GraphCircuit>(
-            &mut reader,
-            halo2_proofs::SerdeFormat::RawBytes,
-            settings.clone(),
-        )
-        .unwrap();
-        let commitment_ser = kzgCommit(
-            wasm_bindgen::Clamped(message_ser),
-            wasm_bindgen::Clamped(VK.to_vec()),
-            wasm_bindgen::Clamped(SETTINGS.to_vec()),
-            wasm_bindgen::Clamped(SRS.to_vec()),
-        )
-        .map_err(|_| "failed")
-        .unwrap();
-        let commitment: Vec<halo2curves::bn256::G1Affine> =
-            serde_json::from_slice(&commitment_ser[..]).unwrap();
-        let reference_commitment = PolyCommitChip::commit::<KZGCommitmentScheme<Bn256>>(
-            message,
-            vk.cs().degree() as u32,
-            (vk.cs().blinding_factors() + 1) as u32,
-            &params,
-        );
-
-        assert_eq!(commitment, reference_commitment);
-    }
-
     #[wasm_bindgen_test]
     async fn verify_field_serialization_roundtrip() {
         for i in 0..32 {