fix: reduce verbosity of common operations (#715)

src/circuit/modules/kzg.rs

@@ -41,7 +41,7 @@ pub struct KZGChip {
 }
 
 impl KZGChip {
-    /// Returns the number of inputs to the hash function
+    /// Commit to the message using the KZG commitment scheme
     pub fn commit(
         message: Vec<Fp>,
         degree: u32,

src/commands.rs

@@ -795,12 +795,4 @@ pub enum Commands {
         #[arg(long)]
         addr_vk: Option<H160>,
     },
-
-    /// Print the proof in hexadecimal
-    #[command(name = "print-proof-hex")]
-    PrintProofHex {
-        /// The path to the proof file
-        #[arg(long, default_value = DEFAULT_PROOF)]
-        proof_path: PathBuf,
-    },
 }

src/execute.rs

@@ -440,7 +440,6 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             addr_da,
             addr_vk,
         } => verify_evm(proof_path, addr_verifier, rpc_url, addr_da, addr_vk).await,
-        Commands::PrintProofHex { proof_path } => print_proof_hex(proof_path),
     }
 }
 
@@ -826,10 +825,7 @@ pub(crate) fn calibrate(
     let range = if let Some(scales) = scales {
         scales
     } else {
-        match target {
-            CalibrationTarget::Resources { .. } => (8..10).collect::<Vec<crate::Scale>>(),
-            CalibrationTarget::Accuracy => (10..14).collect::<Vec<crate::Scale>>(),
-        }
+        (10..14).collect::<Vec<crate::Scale>>()
     };
 
     let div_rebasing = if let Some(div_rebasing) = div_rebasing {
@@ -1172,16 +1168,6 @@ pub(crate) fn mock(
     Ok(String::new())
 }
 
-pub(crate) fn print_proof_hex(proof_path: PathBuf) -> Result<String, Box<dyn Error>> {
-    let proof = Snark::load::<KZGCommitmentScheme<Bn256>>(&proof_path)?;
-    for instance in proof.instances {
-        println!("{:?}", instance);
-    }
-    let hex_str = hex::encode(proof.proof);
-    info!("0x{}", hex_str);
-    Ok(format!("0x{}", hex_str))
-}
-
 #[cfg(feature = "render")]
 pub(crate) fn render(
     model: PathBuf,

src/graph/mod.rs

@@ -35,6 +35,8 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{self, Bn256, Fr as Fp, G1Affine};
 use halo2curves::ff::PrimeField;
+#[cfg(not(target_arch = "wasm32"))]
+use lazy_static::lazy_static;
 use log::{debug, error, info, trace, warn};
 use maybe_rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
 pub use model::*;
@@ -61,6 +63,20 @@ pub const RANGE_MULTIPLIER: i128 = 2;
 /// Max representation of a lookup table input
 pub const MAX_LOOKUP_ABS: i128 = 8 * 2_i128.pow(MAX_PUBLIC_SRS);
 
+#[cfg(not(target_arch = "wasm32"))]
+lazy_static! {
+    /// Max circuit area
+    pub static ref EZKL_MAX_CIRCUIT_AREA: Option<usize> =
+        if let Ok(max_circuit_area) = std::env::var("EZKL_MAX_CIRCUIT_AREA") {
+            Some(max_circuit_area.parse().unwrap_or(0))
+        } else {
+            None
+        };
+}
+
+#[cfg(target_arch = "wasm32")]
+const EZKL_MAX_CIRCUIT_AREA: Option<usize> = None;
+
 /// circuit related errors.
 #[derive(Debug, Error)]
 pub enum GraphError {
@@ -530,6 +546,7 @@ impl GraphSettings {
 pub struct GraphConfig {
     model_config: ModelConfig,
     module_configs: ModuleConfigs,
+    circuit_size: CircuitSize,
 }
 
 /// Defines the circuit for a computational graph / model loaded from a `.onnx` file.
@@ -809,7 +826,7 @@ impl GraphCircuit {
         let shapes = self.model().graph.input_shapes()?;
         let scales = self.model().graph.get_input_scales();
         let input_types = self.model().graph.get_input_types()?;
-        info!("input scales: {:?}", scales);
+        debug!("input scales: {:?}", scales);
 
         match &data.input_data {
             DataSource::File(file_data) => {
@@ -828,7 +845,7 @@ impl GraphCircuit {
         let shapes = self.model().graph.input_shapes()?;
         let scales = self.model().graph.get_input_scales();
         let input_types = self.model().graph.get_input_types()?;
-        info!("input scales: {:?}", scales);
+        debug!("input scales: {:?}", scales);
 
         self.process_data_source(&data.input_data, shapes, scales, input_types)
             .await
@@ -1028,7 +1045,7 @@ impl GraphCircuit {
                 "extended k is too large to accommodate the quotient polynomial with logrows {}",
                 min_logrows
             );
-            error!("{}", err_string);
+            debug!("{}", err_string);
             return Err(err_string.into());
         }
 
@@ -1048,7 +1065,7 @@ impl GraphCircuit {
                 "extended k is too large to accommodate the quotient polynomial with logrows {}",
                 max_logrows
             );
-            error!("{}", err_string);
+            debug!("{}", err_string);
             return Err(err_string.into());
         }
 
@@ -1114,7 +1131,7 @@ impl GraphCircuit {
 
         settings_mut.run_args.logrows = std::cmp::min(max_logrows, settings_mut.run_args.logrows);
 
-        info!(
+        debug!(
             "setting lookup_range to: {:?}, setting logrows to: {}",
             self.settings().run_args.lookup_range,
             self.settings().run_args.logrows
@@ -1366,7 +1383,6 @@ impl GraphCircuit {
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 struct CircuitSize {
     num_instances: usize,
@@ -1374,20 +1390,22 @@ struct CircuitSize {
     num_fixed: usize,
     num_challenges: usize,
     num_selectors: usize,
+    logrows: u32,
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 impl CircuitSize {
-    pub fn from_cs(cs: &ConstraintSystem<Fp>) -> Self {
+    pub fn from_cs(cs: &ConstraintSystem<Fp>, logrows: u32) -> Self {
         CircuitSize {
             num_instances: cs.num_instance_columns(),
             num_advice_columns: cs.num_advice_columns(),
             num_fixed: cs.num_fixed_columns(),
             num_challenges: cs.num_challenges(),
             num_selectors: cs.num_selectors(),
+            logrows,
         }
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
     /// Export the ezkl configuration as json
     pub fn as_json(&self) -> Result<String, Box<dyn std::error::Error>> {
         let serialized = match serde_json::to_string(&self) {
@@ -1398,6 +1416,25 @@ impl CircuitSize {
         };
         Ok(serialized)
     }
+
+    /// number of columns
+    pub fn num_columns(&self) -> usize {
+        self.num_instances + self.num_advice_columns + self.num_fixed
+    }
+
+    /// area of the circuit
+    pub fn area(&self) -> usize {
+        self.num_columns() * (1 << self.logrows)
+    }
+
+    /// area less than max
+    pub fn area_less_than_max(&self) -> bool {
+        if EZKL_MAX_CIRCUIT_AREA.is_some() {
+            self.area() < EZKL_MAX_CIRCUIT_AREA.unwrap()
+        } else {
+            true
+        }
+    }
 }
 
 impl Circuit<Fp> for GraphCircuit {
@@ -1472,10 +1509,12 @@ impl Circuit<Fp> for GraphCircuit {
             (cs.degree() as f32).log2().ceil()
         );
 
+        let circuit_size = CircuitSize::from_cs(cs, params.run_args.logrows);
+
         #[cfg(not(target_arch = "wasm32"))]
         info!(
             "circuit size: \n {}",
-            CircuitSize::from_cs(cs)
+            circuit_size
                 .as_json()
                 .unwrap()
                 .to_colored_json_auto()
@@ -1485,6 +1524,7 @@ impl Circuit<Fp> for GraphCircuit {
         GraphConfig {
             model_config,
             module_configs,
+            circuit_size,
         }
     }
 
@@ -1497,6 +1537,16 @@ impl Circuit<Fp> for GraphCircuit {
         config: Self::Config,
         mut layouter: impl Layouter<Fp>,
     ) -> Result<(), PlonkError> {
+        // check if the circuit area is less than the max
+        if !config.circuit_size.area_less_than_max() {
+            error!(
+                "circuit area {} is larger than the max allowed area {}",
+                config.circuit_size.area(),
+                EZKL_MAX_CIRCUIT_AREA.unwrap()
+            );
+            return Err(PlonkError::Synthesis);
+        }
+
         trace!("Setting input in synthesize");
         let input_vis = &self.settings().run_args.input_visibility;
         let output_vis = &self.settings().run_args.output_visibility;

src/graph/model.rs

@@ -493,7 +493,7 @@ impl Model {
     ) -> Result<GraphSettings, Box<dyn Error>> {
         let instance_shapes = self.instance_shapes()?;
         #[cfg(not(target_arch = "wasm32"))]
-        info!(
+        debug!(
             "{} {} {}",
             "model has".blue(),
             instance_shapes.len().to_string().blue(),
@@ -1132,7 +1132,7 @@ impl Model {
 
         // Then number of columns in the circuits
         #[cfg(not(target_arch = "wasm32"))]
-        info!(
+        debug!(
             "{} {} {} (coord={}, constants={})",
             "model uses".blue(),
             num_rows.to_string().blue(),
@@ -1341,7 +1341,7 @@ impl Model {
         run_args: &RunArgs,
         inputs: &[ValTensor<Fp>],
     ) -> Result<DummyPassRes, Box<dyn Error>> {
-        info!("calculating num of constraints using dummy model layout...");
+        debug!("calculating num of constraints using dummy model layout...");
 
         let start_time = instant::Instant::now();
 

src/pfsys/mod.rs

@@ -40,8 +40,24 @@ use std::ops::Deref;
 use std::path::PathBuf;
 use thiserror::Error as thisError;
 
+// not wasm
+#[cfg(not(target_arch = "wasm32"))]
+use lazy_static::lazy_static;
+
 use halo2curves::bn256::{Bn256, Fr, G1Affine};
 
+#[cfg(not(target_arch = "wasm32"))]
+// Buf writer capacity
+lazy_static! {
+    static ref EZKL_BUF_CAPACITY: usize = std::env::var("EZKL_BUF_CAPACITY")
+        .unwrap_or("8000".to_string())
+        .parse()
+        .unwrap();
+}
+
+#[cfg(target_arch = "wasm32")]
+const EZKL_BUF_CAPACITY: &usize = &8000;
+
 #[allow(missing_docs)]
 #[derive(
     ValueEnum, Copy, Clone, Default, Debug, PartialEq, Eq, Deserialize, Serialize, PartialOrd,
@@ -315,7 +331,7 @@ where
     /// Saves the Proof to a specified `proof_path`.
     pub fn save(&self, proof_path: &PathBuf) -> Result<(), Box<dyn Error>> {
         let file = std::fs::File::create(proof_path)?;
-        let mut writer = BufWriter::new(file);
+        let mut writer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, file);
         serde_json::to_writer(&mut writer, &self)?;
         Ok(())
     }
@@ -678,7 +694,7 @@ where
     info!("loading verification key from {:?}", path);
     let f =
         File::open(path.clone()).map_err(|_| format!("failed to load vk at {}", path.display()))?;
-    let mut reader = BufReader::new(f);
+    let mut reader = BufReader::with_capacity(*EZKL_BUF_CAPACITY, f);
     VerifyingKey::<Scheme::Curve>::read::<_, C>(
         &mut reader,
         halo2_proofs::SerdeFormat::RawBytes,
@@ -700,7 +716,7 @@ where
     info!("loading proving key from {:?}", path);
     let f =
         File::open(path.clone()).map_err(|_| format!("failed to load pk at {}", path.display()))?;
-    let mut reader = BufReader::new(f);
+    let mut reader = BufReader::with_capacity(*EZKL_BUF_CAPACITY, f);
     ProvingKey::<Scheme::Curve>::read::<_, C>(
         &mut reader,
         halo2_proofs::SerdeFormat::RawBytes,
@@ -720,7 +736,7 @@ where
 {
     info!("saving proving key 💾");
     let f = File::create(path)?;
-    let mut writer = BufWriter::new(f);
+    let mut writer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, f);
     vk.write(&mut writer, halo2_proofs::SerdeFormat::RawBytes)?;
     writer.flush()?;
     Ok(())
@@ -737,7 +753,7 @@ where
 {
     info!("saving verification key 💾");
     let f = File::create(path)?;
-    let mut writer = BufWriter::new(f);
+    let mut writer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, f);
     vk.write(&mut writer, halo2_proofs::SerdeFormat::RawBytes)?;
     writer.flush()?;
     Ok(())
@@ -750,7 +766,7 @@ pub fn save_params<Scheme: CommitmentScheme>(
 ) -> Result<(), io::Error> {
     info!("saving parameters 💾");
     let f = File::create(path)?;
-    let mut writer = BufWriter::new(f);
+    let mut writer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, f);
     params.write(&mut writer)?;
     writer.flush()?;
     Ok(())

src/python.rs

@@ -15,7 +15,7 @@ use crate::graph::{
 use crate::pfsys::evm::aggregation::AggregationCircuit;
 use crate::pfsys::{
     load_pk, load_vk, save_params, save_vk, srs::gen_srs as ezkl_gen_srs, srs::load_srs, ProofType,
-    Snark, TranscriptType,
+    TranscriptType,
 };
 use crate::RunArgs;
 use ethers::types::H160;
@@ -1097,16 +1097,6 @@ fn create_evm_verifier_aggr(
     Ok(true)
 }
 
-/// print hex representation of a proof
-#[pyfunction(signature = (proof_path))]
-fn print_proof_hex(proof_path: PathBuf) -> Result<String, PyErr> {
-    let proof = Snark::load::<KZGCommitmentScheme<Bn256>>(&proof_path)
-        .map_err(|_| PyIOError::new_err("Failed to load proof"))?;
-
-    let hex_str = hex::encode(proof.proof);
-    Ok(format!("0x{}", hex_str))
-}
-
 // Python Module
 #[pymodule]
 fn ezkl(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
@@ -1145,7 +1135,6 @@ fn ezkl(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     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)?)?;
     m.add_function(wrap_pyfunction!(setup_test_evm_witness, m)?)?;
     m.add_function(wrap_pyfunction!(create_evm_verifier_aggr, m)?)?;
     m.add_function(wrap_pyfunction!(create_evm_data_attestation, m)?)?;

tests/integration_tests.rs

@@ -560,7 +560,7 @@ mod native_tests {
                 crate::native_tests::setup_py_env();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                accuracy_measurement(path, test.to_string(), "private", "private", "public", 1, "resources", 18.0, false);
+                accuracy_measurement(path, test.to_string(), "private", "private", "public", 1, "resources", 3.1, false);
                 test_dir.close().unwrap();
             }
 

tests/python/binding_tests.py

@@ -113,13 +113,13 @@ def test_calibrate_over_user_range():
     data_path = os.path.join(
         examples_path,
         'onnx',
-        '1l_average',
+        '1l_relu',
         'input.json'
     )
     model_path = os.path.join(
         examples_path,
         'onnx',
-        '1l_average',
+        '1l_relu',
         'network.onnx'
     )
     output_path = os.path.join(
@@ -147,13 +147,13 @@ def test_calibrate():
     data_path = os.path.join(
         examples_path,
         'onnx',
-        '1l_average',
+        '1l_relu',
         'input.json'
     )
     model_path = os.path.join(
         examples_path,
         'onnx',
-        '1l_average',
+        '1l_relu',
         'network.onnx'
     )
     output_path = os.path.join(
@@ -183,7 +183,7 @@ def test_model_compile():
     model_path = os.path.join(
         examples_path,
         'onnx',
-        '1l_average',
+        '1l_relu',
         'network.onnx'
     )
     compiled_model_path = os.path.join(
@@ -205,7 +205,7 @@ def test_forward():
     data_path = os.path.join(
         examples_path,
         'onnx',
-        '1l_average',
+        '1l_relu',
         'input.json'
     )
     model_path = os.path.join(
@@ -392,9 +392,7 @@ def test_prove_evm():
     assert res['transcript_type'] == 'EVM'
     assert os.path.isfile(proof_path)
 
-    res = ezkl.print_proof_hex(proof_path)
-    # to figure out a better way of testing print_proof_hex
-    assert type(res) == str
+
 
 
 def test_create_evm_verifier():

tests/wasm.rs

@@ -258,15 +258,6 @@ mod wasm32 {
         assert!(value);
     }
 
-    #[wasm_bindgen_test]
-    async fn print_proof_hex_test() {
-        let proof = printProofHex(wasm_bindgen::Clamped(PROOF.to_vec()))
-            .map_err(|_| "failed")
-            .unwrap();
-
-        assert!(proof.len() > 0);
-    }
-
     #[wasm_bindgen_test]
     async fn verify_validations() {
         // Run witness validation on network (should fail)