fix: transcript should serialize as lc flag (#726 )

fix!: cleanup felt serialization language in python and wasm (#724 )
BREAKING CHANGE: python and wasm felt utilities have new names
2026-01-13 16:27:59 -05:00 · 2024-02-26 22:02:47 +00:00 · 2024-02-25 14:06:48 +00:00 · 2024-02-23 01:28:59 +00:00 · 2024-02-21 12:45:42 +00:00 · 2024-02-21 00:38:26 +00:00
36 changed files with 1062 additions and 721 deletions
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -236,6 +236,8 @@ jobs:
        with:
          crate: cargo-nextest
          locked: true
+      - name: public outputs and tolerance > 0
+        run: cargo nextest run --release --verbose tests::mock_tolerance_public_outputs_ --test-threads 32
      - name: public outputs + batch size == 10
        run: cargo nextest run --release --verbose tests::mock_large_batch_public_outputs_ --test-threads 32
      - name: kzg inputs
@@ -498,7 +500,7 @@ jobs:

  prove-and-verify-aggr-tests:
    runs-on: large-self-hosted
-    needs: [build, library-tests, python-tests]
+    needs: [build, library-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
@@ -511,11 +513,11 @@ jobs:
          crate: cargo-nextest
          locked: true
      - name: KZG )tests
-        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 8 -- --include-ignored
+        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 4 -- --include-ignored

  prove-and-verify-aggr-evm-tests:
    runs-on: large-self-hosted
-    needs: [build, library-tests, python-tests]
+    needs: [build, library-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -112,7 +112,7 @@ checksum = "c0391754c09fab4eae3404d19d0d297aa1c670c1775ab51d8a5312afeca23157"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -464,7 +464,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "serde",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -490,7 +490,7 @@ checksum = "c980ee35e870bd1a4d2c8294d4c04d0499e67bca1e4b5cefcc693c2fa00caea9"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -855,7 +855,7 @@ dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -1491,7 +1491,7 @@ checksum = "48016319042fb7c87b78d2993084a831793a897a5cd1a2a67cab9d1eeb4b7d76"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -1657,7 +1657,7 @@ dependencies = [
 "regex",
 "serde",
 "serde_json",
- "syn 2.0.48",
+ "syn 2.0.50",
 "toml",
 "walkdir",
 ]
@@ -1675,7 +1675,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "serde_json",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -1701,7 +1701,7 @@ dependencies = [
 "serde",
 "serde_json",
 "strum",
- "syn 2.0.48",
+ "syn 2.0.50",
 "tempfile",
 "thiserror",
 "tiny-keccak",
@@ -1902,6 +1902,7 @@ dependencies = [
 "thiserror",
 "tokio",
 "tokio-util",
+ "tosubcommand",
 "tract-onnx",
 "unzip-n",
 "wasm-bindgen",
@@ -2103,7 +2104,7 @@ checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -2975,7 +2976,7 @@ checksum = "fc2fb41a9bb4257a3803154bdf7e2df7d45197d1941c9b1a90ad815231630721"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -3285,7 +3286,7 @@ dependencies = [
 "proc-macro-crate",
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -3369,7 +3370,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -3570,7 +3571,7 @@ dependencies = [
 "pest_meta",
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -3647,7 +3648,7 @@ dependencies = [
 "phf_shared 0.11.2",
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -3685,7 +3686,7 @@ checksum = "39407670928234ebc5e6e580247dd567ad73a3578460c5990f9503df207e8f07"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -3821,7 +3822,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9825a04601d60621feed79c4e6b56d65db77cdca55cef43b46b0de1096d1c282"
 dependencies = [
 "proc-macro2",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -4011,7 +4012,7 @@ dependencies = [
 "proc-macro2",
 "pyo3-macros-backend",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -4023,7 +4024,7 @@ dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -4735,7 +4736,7 @@ checksum = "d9735b638ccc51c28bf6914d90a2e9725b377144fc612c49a611fddd1b631d68"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -5044,7 +5045,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "rustversion",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -5079,9 +5080,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.48"
+version = "2.0.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
+checksum = "74f1bdc9872430ce9b75da68329d1c1746faf50ffac5f19e02b71e37ff881ffb"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -5259,7 +5260,7 @@ checksum = "f9456a42c5b0d803c8cd86e73dd7cc9edd429499f37a3550d286d5e86720569f"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -5348,7 +5349,7 @@ checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -5444,6 +5445,24 @@ dependencies = [
 "winnow 0.5.39",
 ]

+[[package]]
+name = "tosubcommand"
+version = "0.1.0"
+source = "git+https://github.com/zkonduit/enum_to_subcommand#42e9870f1f757932bab64ab30ebf1ff08a392265"
+dependencies = [
+ "tosubcommand_derive",
+]
+
+[[package]]
+name = "tosubcommand_derive"
+version = "0.1.0"
+source = "git+https://github.com/zkonduit/enum_to_subcommand#42e9870f1f757932bab64ab30ebf1ff08a392265"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.50",
+]
+
 [[package]]
 name = "tower-service"
 version = "0.3.2"
@@ -5470,7 +5489,7 @@ checksum = "5f4f31f56159e98206da9efd823404b79b6ef3143b4a7ab76e67b1751b25a4ab"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]

 [[package]]
@@ -5854,7 +5873,7 @@ dependencies = [
 "once_cell",
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 "wasm-bindgen-shared",
 ]

@@ -5898,7 +5917,7 @@ checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 "wasm-bindgen-backend",
 "wasm-bindgen-shared",
 ]
@@ -6309,5 +6328,5 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.48",
+ "syn 2.0.50",
 ]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,6 +35,8 @@ ark-std = { version = "^0.3.0", default-features = false }
 unzip-n = "0.1.2"
 num = "0.4.1"
 portable-atomic = "1.6.0"
+tosubcommand = { git =  "https://github.com/zkonduit/enum_to_subcommand", package = "tosubcommand" }
+

 # evm related deps
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
@@ -159,6 +161,7 @@ mv-lookup = ["halo2_proofs/mv-lookup", "snark-verifier/mv-lookup", "halo2_solidi
 det-prove = []
 icicle = ["halo2_proofs/icicle_gpu"]
 empty-cmd = []
+no-banner = []

 # icicle patch to 0.1.0 if feature icicle is enabled
 [patch.'https://github.com/ingonyama-zk/icicle']
--- a/examples/notebooks/data_attest_hashed.ipynb
+++ b/examples/notebooks/data_attest_hashed.ipynb
@@ -309,7 +309,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "print(ezkl.string_to_felt(res['processed_outputs']['poseidon_hash'][0]))"
+                "print(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]))"
            ]
        },
        {
@@ -325,7 +325,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "from web3 import Web3, HTTPProvider, utils\n",
+                "from web3 import Web3, HTTPProvider\n",
                "from solcx import compile_standard\n",
                "from decimal import Decimal\n",
                "import json\n",
@@ -338,7 +338,7 @@
                "\n",
                "def test_on_chain_data(res):\n",
                "    # Step 0: Convert the tensor to a flat list\n",
-                "    data = [int(ezkl.string_to_felt(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
+                "    data = [int(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
                "\n",
                "    # Step 1: Prepare the data\n",
                "    # Step 2: Prepare and compile the contract.\n",
@@ -648,7 +648,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.9.13"
+            "version": "3.9.15"
        },
        "orig_nbformat": 4
    },
--- a/examples/notebooks/ezkl_demo.ipynb
+++ b/examples/notebooks/ezkl_demo.ipynb
@@ -695,7 +695,7 @@
        "formatted_output = \"[\"\n",
        "for i, value in enumerate(proof[\"instances\"]):\n",
        "    for j, field_element in enumerate(value):\n",
-        "        onchain_input_array.append(ezkl.string_to_felt(field_element))\n",
+        "        onchain_input_array.append(ezkl.felt_to_big_endian(field_element))\n",
        "        formatted_output += str(onchain_input_array[-1])\n",
        "        if j != len(value) - 1:\n",
        "            formatted_output += \", \"\n",
@@ -705,7 +705,7 @@
        "# copy them over to remix and see if they verify\n",
        "# What happens when you change a value?\n",
        "print(\"pubInputs: \", formatted_output)\n",
-        "print(\"proof: \", \"0x\" + proof[\"proof\"])"
+        "print(\"proof: \", proof[\"proof\"])"
      ]
    },
    {
--- a/examples/notebooks/set_membership.ipynb
+++ b/examples/notebooks/set_membership.ipynb
@@ -122,8 +122,8 @@
        "# Loop through each element in the y tensor\n",
        "for e in y_input:\n",
        "    # Apply the custom function and append the result to the list\n",
-        "    print(ezkl.float_to_string(e,7))\n",
-        "    result.append(ezkl.poseidon_hash([ezkl.float_to_string(e, 7)])[0])\n",
+        "    print(ezkl.float_to_felt(e,7))\n",
+        "    result.append(ezkl.poseidon_hash([ezkl.float_to_felt(e, 7)])[0])\n",
        "\n",
        "y = y.unsqueeze(0)\n",
        "y = y.reshape(1, 9)\n",
--- a/examples/notebooks/solvency.ipynb
+++ b/examples/notebooks/solvency.ipynb
@@ -126,7 +126,7 @@
        "# Loop through each element in the y tensor\n",
        "for e in user_preimages:\n",
        "    # Apply the custom function and append the result to the list\n",
-        "    users.append(ezkl.poseidon_hash([ezkl.float_to_string(e, 0)])[0])\n",
+        "    users.append(ezkl.poseidon_hash([ezkl.float_to_felt(e, 0)])[0])\n",
        "\n",
        "users_t = torch.tensor(user_preimages)\n",
        "users_t = users_t.reshape(1, 6)\n",
@@ -303,7 +303,7 @@
        "# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
        "# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
        "witness = json.load(open(witness_path, \"r\"))\n",
-        "witness[\"outputs\"][0] = [ezkl.float_to_string(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_felt(1.0, 0)]\n",
        "json.dump(witness, open(witness_path, \"w\"))"
      ]
    },
@@ -417,7 +417,7 @@
        "# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
        "# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
        "witness = json.load(open(witness_path, \"r\"))\n",
-        "witness[\"outputs\"][0] = [ezkl.float_to_string(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_felt(1.0, 0)]\n",
        "json.dump(witness, open(witness_path, \"w\"))\n"
      ]
    },
@@ -510,7 +510,7 @@
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
-      "version": "3.9.13"
+      "version": "3.9.15"
    }
  },
  "nbformat": 4,
--- a/examples/notebooks/world_rotation.ipynb
+++ b/examples/notebooks/world_rotation.ipynb
@@ -503,11 +503,11 @@
    "pyplot.arrow(0, 0, 1, 0, width=0.02, alpha=0.5)\n",
    "pyplot.arrow(0, 0, 0, 1, width=0.02, alpha=0.5)\n",
    "\n",
-    "arrow_x = ezkl.string_to_float(witness['outputs'][0][0], out_scale)\n",
-    "arrow_y = ezkl.string_to_float(witness['outputs'][0][1], out_scale)\n",
+    "arrow_x = ezkl.felt_to_float(witness['outputs'][0][0], out_scale)\n",
+    "arrow_y = ezkl.felt_to_float(witness['outputs'][0][1], out_scale)\n",
    "pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)\n",
-    "arrow_x = ezkl.string_to_float(witness['outputs'][0][2], out_scale)\n",
-    "arrow_y = ezkl.string_to_float(witness['outputs'][0][3], out_scale)\n",
+    "arrow_x = ezkl.felt_to_float(witness['outputs'][0][2], out_scale)\n",
+    "arrow_y = ezkl.felt_to_float(witness['outputs'][0][3], out_scale)\n",
    "pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)"
   ]
  }
--- a/src/bin/ezkl.rs
+++ b/src/bin/ezkl.rs
@@ -11,8 +11,8 @@ use ezkl::execute::run;
 #[cfg(not(target_arch = "wasm32"))]
 use ezkl::logger::init_logger;
 #[cfg(not(target_arch = "wasm32"))]
-use log::{error, info};
-#[cfg(not(target_arch = "wasm32"))]
+use log::{debug, error, info};
+#[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
 use rand::prelude::SliceRandom;
 #[cfg(not(target_arch = "wasm32"))]
 #[cfg(feature = "icicle")]
@@ -25,6 +25,7 @@ use std::error::Error;
 pub async fn main() -> Result<(), Box<dyn Error>> {
    let args = Cli::parse();
    init_logger();
+    #[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
    banner();
    #[cfg(feature = "icicle")]
    if env::var("ENABLE_ICICLE_GPU").is_ok() {
@@ -32,7 +33,7 @@ pub async fn main() -> Result<(), Box<dyn Error>> {
    } else {
        info!("Running with CPU");
    }
-    info!("command: \n {}", &args.as_json()?.to_colored_json_auto()?);
+    debug!("command: \n {}", &args.as_json()?.to_colored_json_auto()?);
    let res = run(args.command).await;
    match &res {
        Ok(_) => info!("succeeded"),
@@ -44,7 +45,7 @@ pub async fn main() -> Result<(), Box<dyn Error>> {
 #[cfg(target_arch = "wasm32")]
 pub fn main() {}

-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
 fn banner() {
    let ell: Vec<&str> = vec![
        "for Neural Networks",
--- a/src/circuit/modules/planner.rs
+++ b/src/circuit/modules/planner.rs
@@ -15,7 +15,7 @@ use halo2_proofs::{
        Instance, Selector, TableColumn,
    },
 };
-use log::{trace, warn};
+use log::{debug, trace};

 /// A simple [`FloorPlanner`] that performs minimal optimizations.
 #[derive(Debug)]
@@ -119,7 +119,7 @@ impl<'a, F: Field, CS: Assignment<F> + 'a + SyncDeps> Layouter<F> for ModuleLayo
                Error::Synthesis
            })?;
            if !self.regions.contains_key(&index) {
-                warn!("spawning module {}", index)
+                debug!("spawning module {}", index)
            };
            self.current_module = index;
        }
--- a/src/circuit/ops/chip.rs
+++ b/src/circuit/ops/chip.rs
@@ -16,10 +16,11 @@ use pyo3::{
    types::PyString,
 };
 use serde::{Deserialize, Serialize};
+use tosubcommand::ToFlags;

 use crate::{
-    circuit::ops::base::BaseOp,
    circuit::{
+        ops::base::BaseOp,
        table::{Range, RangeCheck, Table},
        utils,
    },
@@ -61,6 +62,22 @@ pub enum CheckMode {
    UNSAFE,
 }

+impl std::fmt::Display for CheckMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CheckMode::SAFE => write!(f, "safe"),
+            CheckMode::UNSAFE => write!(f, "unsafe"),
+        }
+    }
+}
+
+impl ToFlags for CheckMode {
+    /// Convert the struct to a subcommand string
+    fn to_flags(&self) -> Vec<String> {
+        vec![format!("{}", self)]
+    }
+}
+
 impl From<String> for CheckMode {
    fn from(value: String) -> Self {
        match value.to_lowercase().as_str() {
@@ -83,6 +100,19 @@ pub struct Tolerance {
    pub scale: utils::F32,
 }

+impl std::fmt::Display for Tolerance {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:.2}", self.val)
+    }
+}
+
+impl ToFlags for Tolerance {
+    /// Convert the struct to a subcommand string
+    fn to_flags(&self) -> Vec<String> {
+        vec![format!("{}", self)]
+    }
+}
+
 impl FromStr for Tolerance {
    type Err = String;

@@ -510,7 +540,9 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
        &mut self,
        cs: &mut ConstraintSystem<F>,
        input: &VarTensor,
+        index: &VarTensor,
        range: Range,
+        logrows: usize,
    ) -> Result<(), Box<dyn Error>>
    where
        F: Field,
@@ -523,43 +555,72 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {

        // we borrow mutably twice so we need to do this dance

-        let range_check = if let std::collections::btree_map::Entry::Vacant(e) = self.range_checks.entry(range) {
-            // as all tables have the same input we see if there's another table who's input we can reuse
-            let range_check = RangeCheck::<F>::configure(cs, range);
-            e.insert(range_check.clone());
-            range_check
-        } else {
-            return Ok(());
-        };
+        let range_check =
+            if let std::collections::btree_map::Entry::Vacant(e) = self.range_checks.entry(range) {
+                // as all tables have the same input we see if there's another table who's input we can reuse
+                let range_check = RangeCheck::<F>::configure(cs, range, logrows);
+                e.insert(range_check.clone());
+                range_check
+            } else {
+                return Ok(());
+            };

        for x in 0..input.num_blocks() {
            for y in 0..input.num_inner_cols() {
-                let single_col_sel = cs.complex_selector();
+                let len = range_check.selector_constructor.degree;
+                let multi_col_selector = cs.complex_selector();

-                cs.lookup("", |cs| {
-                    let mut res = vec![];
-                    let sel = cs.query_selector(single_col_sel);
+                for (col_idx, input_col) in range_check.inputs.iter().enumerate() {
+                    cs.lookup("", |cs| {
+                        let mut res = vec![];
+                        let sel = cs.query_selector(multi_col_selector);

-                    let input_query = match &input {
-                        VarTensor::Advice { inner: advices, .. } => {
-                            cs.query_advice(advices[x][y], Rotation(0))
-                        }
-                        _ => unreachable!(),
-                    };
+                        let synthetic_sel = match len {
+                            1 => Expression::Constant(F::from(1)),
+                            _ => match index {
+                                VarTensor::Advice { inner: advices, .. } => {
+                                    cs.query_advice(advices[x][y], Rotation(0))
+                                }
+                                _ => unreachable!(),
+                            },
+                        };

-                    let default_x = range_check.get_first_element();
+                        let input_query = match &input {
+                            VarTensor::Advice { inner: advices, .. } => {
+                                cs.query_advice(advices[x][y], Rotation(0))
+                            }
+                            _ => unreachable!(),
+                        };

-                    let not_sel = Expression::Constant(F::ONE) - sel.clone();
+                        let default_x = range_check.get_first_element(col_idx);

-                    res.extend([(
-                        sel.clone() * input_query.clone()
-                            + not_sel.clone() * Expression::Constant(default_x),
-                        range_check.input,
-                    )]);
+                        let col_expr = sel.clone()
+                            * range_check
+                                .selector_constructor
+                                .get_expr_at_idx(col_idx, synthetic_sel);

-                    res
-                });
-                selectors.insert((range, x, y), single_col_sel);
+                        let multiplier = range_check
+                            .selector_constructor
+                            .get_selector_val_at_idx(col_idx);
+
+                        let not_expr = Expression::Constant(multiplier) - col_expr.clone();
+
+                        res.extend([(
+                            col_expr.clone() * input_query.clone()
+                                + not_expr.clone() * Expression::Constant(default_x),
+                            *input_col,
+                        )]);
+
+                        log::trace!("---------------- col {:?} ------------------", col_idx,);
+                        log::trace!("expr: {:?}", col_expr,);
+                        log::trace!("multiplier: {:?}", multiplier);
+                        log::trace!("not_expr: {:?}", not_expr);
+                        log::trace!("default x: {:?}", default_x);
+
+                        res
+                    });
+                }
+                selectors.insert((range, x, y), multi_col_selector);
            }
        }
        self.range_check_selectors.extend(selectors);
@@ -569,6 +630,11 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
            self.lookup_input = input.clone();
        }

+        if let VarTensor::Empty = self.lookup_index {
+            debug!("assigning lookup index");
+            self.lookup_index = index.clone();
+        }
+
        Ok(())
    }

--- a/src/circuit/ops/layouts.rs
+++ b/src/circuit/ops/layouts.rs
@@ -20,7 +20,7 @@ use super::{
 use crate::{
    circuit::{
        ops::base::BaseOp,
-        utils::{self},
+        utils::{self, F32},
    },
    fieldutils::{felt_to_i128, i128_to_felt},
    tensor::{
@@ -105,6 +105,8 @@ pub fn div<F: PrimeField + TensorType + PartialOrd>(
        BaseOp::Sub,
    )?;

+    log::debug!("diff_with_input: {:?}", diff_with_input.get_int_evals()?);
+
    range_check(
        config,
        region,
@@ -1854,7 +1856,7 @@ pub fn sumpool<F: PrimeField + TensorType + PartialOrd>(
    let shape = &res[0].dims()[2..];
    let mut last_elem = res[1..]
        .iter()
-        .fold(Ok(res[0].clone()), |acc, elem| acc?.concat(elem.clone()))?;
+        .try_fold(res[0].clone(), |acc, elem| acc.concat(elem.clone()))?;
    last_elem.reshape(&[&[batch_size, image_channels], shape].concat())?;

    if normalized {
@@ -2482,6 +2484,28 @@ pub fn range_check<F: PrimeField + TensorType + PartialOrd>(

    let is_dummy = region.is_dummy();

+    let table_index: ValTensor<F> = w
+        .get_inner_tensor()?
+        .par_enum_map(|_, e| {
+            Ok::<ValType<F>, TensorError>(if let Some(f) = e.get_felt_eval() {
+                let col_idx = if !is_dummy {
+                    let table = config
+                        .range_checks
+                        .get(range)
+                        .ok_or(TensorError::TableLookupError)?;
+                    table.get_col_index(f)
+                } else {
+                    F::ZERO
+                };
+                Value::known(col_idx).into()
+            } else {
+                Value::<F>::unknown().into()
+            })
+        })?
+        .into();
+
+    region.assign(&config.lookup_index, &table_index)?;
+
    if !is_dummy {
        (0..assigned_len)
            .map(|i| {
@@ -2953,8 +2977,17 @@ pub fn range_check_percent<F: PrimeField + TensorType + PartialOrd>(
        return enforce_equality(config, region, values);
    }

+    let mut values = [values[0].clone(), values[1].clone()];
+
+    values[0] = region.assign(&config.inputs[0], &values[0])?;
+    values[1] = region.assign(&config.inputs[1], &values[1])?;
+    let total_assigned_0 = values[0].len();
+    let total_assigned_1 = values[1].len();
+    let total_assigned = std::cmp::max(total_assigned_0, total_assigned_1);
+    region.increment(total_assigned);
+
    // Calculate the difference between the expected output and actual output
-    let diff = pairwise(config, region, values, BaseOp::Sub)?;
+    let diff = pairwise(config, region, &values, BaseOp::Sub)?;

    // Calculate the reciprocal of the expected output tensor, scaling by double the scaling factor
    let recip = nonlinearity(
@@ -2963,44 +2996,22 @@ pub fn range_check_percent<F: PrimeField + TensorType + PartialOrd>(
        &[values[0].clone()],
        &LookupOp::Recip {
            input_scale: scale,
-            output_scale: scale,
+            // multiply by 100 to get the percent error
+            output_scale: F32(scale.0 * 100.0),
        },
    )?;

    // Multiply the difference by the recip
    let product = pairwise(config, region, &[diff, recip], BaseOp::Mult)?;
+    let rebased_product = div(config, region, &[product], F::from(scale.0 as u64))?;

-    let scale_squared = scale.0 * scale.0;
+    let scaled_tol = (tol * scale.0) as i128;

-    // Use the greater than look up table to check if the percent error is within the tolerance for upper bound
-    let tol = tol / 100.0;
-    let upper_bound = nonlinearity(
+    // check that it is within the tolerance range
+    range_check(
        config,
        region,
-        &[product.clone()],
-        &LookupOp::GreaterThan {
-            a: utils::F32(tol * scale_squared),
-        },
-    )?;
-
-    // Negate the product
-    let neg_product = neg(config, region, &[product])?;
-
-    // Use the greater than look up table to check if the percent error is within the tolerance for lower bound
-    let lower_bound = nonlinearity(
-        config,
-        region,
-        &[neg_product],
-        &LookupOp::GreaterThan {
-            a: utils::F32(tol * scale_squared),
-        },
-    )?;
-
-    // Add the lower_bound and upper_bound
-    let sum = pairwise(config, region, &[lower_bound, upper_bound], BaseOp::Add)?;
-
-    // Constrain the sum to be all zeros
-    is_zero_identity(config, region, &[sum.clone()], false)?;
-
-    Ok(sum)
+        &[rebased_product],
+        &(-scaled_tol, scaled_tol),
+    )
 }
--- a/src/circuit/ops/lookup.rs
+++ b/src/circuit/ops/lookup.rs
@@ -243,10 +243,10 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for LookupOp {
            LookupOp::Max { scale, a } => format!("MAX(scale={}, a={})", scale, a),
            LookupOp::Min { scale, a } => format!("MIN(scale={}, a={})", scale, a),
            LookupOp::Sign => "SIGN".into(),
-            LookupOp::GreaterThan { .. } => "GREATER_THAN".into(),
-            LookupOp::GreaterThanEqual { .. } => "GREATER_THAN_EQUAL".into(),
-            LookupOp::LessThan { .. } => "LESS_THAN".into(),
-            LookupOp::LessThanEqual { .. } => "LESS_THAN_EQUAL".into(),
+            LookupOp::GreaterThan { a } => format!("GREATER_THAN(a={})", a),
+            LookupOp::GreaterThanEqual { a } => format!("GREATER_THAN_EQUAL(a={})", a),
+            LookupOp::LessThan { a } => format!("LESS_THAN(a={})", a),
+            LookupOp::LessThanEqual { a } => format!("LESS_THAN_EQUAL(a={})", a),
            LookupOp::Recip {
                input_scale,
                output_scale,
--- a/src/circuit/ops/poly.rs
+++ b/src/circuit/ops/poly.rs
@@ -234,7 +234,7 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
                    inputs[1].clone().map(|x| felt_to_i128(x) as usize)
                };

-                let src = if let Some(_) = constant_idx {
+                let src = if constant_idx.is_some() {
                    inputs[1].clone()
                } else {
                    inputs[2].clone()
--- a/src/circuit/ops/region.rs
+++ b/src/circuit/ops/region.rs
@@ -70,6 +70,8 @@ pub struct RegionCtx<'a, F: PrimeField + TensorType + PartialOrd> {
    used_range_checks: HashSet<Range>,
    max_lookup_inputs: i128,
    min_lookup_inputs: i128,
+    min_range_check: i128,
+    max_range_check: i128,
 }

 impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
@@ -93,6 +95,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            used_range_checks: HashSet::new(),
            max_lookup_inputs: 0,
            min_lookup_inputs: 0,
+            max_range_check: 0,
+            min_range_check: 0,
        }
    }
    /// Create a new region context from a wrapped region
@@ -112,6 +116,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            used_range_checks: HashSet::new(),
            max_lookup_inputs: 0,
            min_lookup_inputs: 0,
+            max_range_check: 0,
+            min_range_check: 0,
        }
    }

@@ -130,6 +136,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            used_range_checks: HashSet::new(),
            max_lookup_inputs: 0,
            min_lookup_inputs: 0,
+            max_range_check: 0,
+            min_range_check: 0,
        }
    }

@@ -153,6 +161,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            used_range_checks,
            max_lookup_inputs: 0,
            min_lookup_inputs: 0,
+            max_range_check: 0,
+            min_range_check: 0,
        }
    }

@@ -203,10 +213,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        let row = AtomicUsize::new(self.row());
        let linear_coord = AtomicUsize::new(self.linear_coord());
        let constants = AtomicUsize::new(self.total_constants());
-        let max_lookup_inputs =
-            AtomicInt::new(self.max_lookup_inputs().try_into().unwrap_or_default());
-        let min_lookup_inputs =
-            AtomicInt::new(self.min_lookup_inputs().try_into().unwrap_or_default());
+        let max_lookup_inputs = AtomicInt::new(self.max_lookup_inputs());
+        let min_lookup_inputs = AtomicInt::new(self.min_lookup_inputs());
        let lookups = Arc::new(Mutex::new(self.used_lookups.clone()));
        let range_checks = Arc::new(Mutex::new(self.used_range_checks.clone()));

@@ -239,13 +247,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
                    Ordering::SeqCst,
                );

-                let local_max_lookup_inputs =
-                    local_reg.max_lookup_inputs().try_into().unwrap_or_default();
-                let local_min_lookup_inputs =
-                    local_reg.min_lookup_inputs().try_into().unwrap_or_default();
-
-                max_lookup_inputs.fetch_max(local_max_lookup_inputs, Ordering::SeqCst);
-                min_lookup_inputs.fetch_min(local_min_lookup_inputs, Ordering::SeqCst);
+                max_lookup_inputs.fetch_max(local_reg.max_lookup_inputs(), Ordering::SeqCst);
+                min_lookup_inputs.fetch_min(local_reg.min_lookup_inputs(), Ordering::SeqCst);
                // update the lookups
                let mut lookups = lookups.lock().unwrap();
                lookups.extend(local_reg.used_lookups());
@@ -261,8 +264,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        self.linear_coord = linear_coord.into_inner();
        #[allow(trivial_numeric_casts)]
        {
-            self.max_lookup_inputs = max_lookup_inputs.into_inner() as i128;
-            self.min_lookup_inputs = min_lookup_inputs.into_inner() as i128;
+            self.max_lookup_inputs = max_lookup_inputs.into_inner();
+            self.min_lookup_inputs = min_lookup_inputs.into_inner();
        }
        self.row = row.into_inner();
        self.used_lookups = Arc::try_unwrap(lookups)
@@ -307,8 +310,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            return Err("update_max_min_lookup_range: invalid range".into());
        }

-        self.max_lookup_inputs = self.max_lookup_inputs.max(range.1);
-        self.min_lookup_inputs = self.min_lookup_inputs.min(range.0);
+        self.max_range_check = self.max_range_check.max(range.1);
+        self.min_range_check = self.min_range_check.min(range.0);
        Ok(())
    }

@@ -368,6 +371,16 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        self.min_lookup_inputs
    }

+    /// min range check
+    pub fn min_range_check(&self) -> i128 {
+        self.min_range_check
+    }
+
+    /// max range check
+    pub fn max_range_check(&self) -> i128 {
+        self.max_range_check
+    }
+
    /// Assign a constant value
    pub fn assign_constant(&mut self, var: &VarTensor, value: F) -> Result<ValType<F>, Error> {
        self.total_constants += 1;
--- a/src/circuit/table.rs
+++ b/src/circuit/table.rs
@@ -130,14 +130,14 @@ impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
    pub fn cal_bit_range(bits: usize, reserved_blinding_rows: usize) -> usize {
        2usize.pow(bits as u32) - reserved_blinding_rows
    }
+}

-    ///
-    pub fn num_cols_required(range: Range, col_size: usize) -> usize {
-        // double it to be safe
-        let range_len = range.1 - range.0;
-        // number of cols needed to store the range
-        (range_len / (col_size as i128)) as usize + 1
-    }
+///
+pub fn num_cols_required(range: Range, col_size: usize) -> usize {
+    // double it to be safe
+    let range_len = range.1 - range.0;
+    // number of cols needed to store the range
+    (range_len / (col_size as i128)) as usize + 1
 }

 impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
@@ -152,7 +152,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
        let factors = cs.blinding_factors() + RESERVED_BLINDING_ROWS_PAD;
        let col_size = Self::cal_col_size(logrows, factors);
        // number of cols needed to store the range
-        let num_cols = Self::num_cols_required(range, col_size);
+        let num_cols = num_cols_required(range, col_size);

        log::debug!("table range: {:?}", range);

@@ -265,7 +265,9 @@ impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
 #[derive(Clone, Debug)]
 pub struct RangeCheck<F: PrimeField> {
    /// Input to table.
-    pub input: TableColumn,
+    pub inputs: Vec<TableColumn>,
+    /// col size
+    pub col_size: usize,
    /// selector cn
    pub selector_constructor: SelectorConstructor<F>,
    /// Flags if table has been previously assigned to.
@@ -277,8 +279,10 @@ pub struct RangeCheck<F: PrimeField> {

 impl<F: PrimeField + TensorType + PartialOrd> RangeCheck<F> {
    /// get first_element of column
-    pub fn get_first_element(&self) -> F {
-        i128_to_felt(self.range.0)
+    pub fn get_first_element(&self, chunk: usize) -> F {
+        let chunk = chunk as i128;
+        // we index from 1 to prevent soundness issues
+        i128_to_felt(chunk * (self.col_size as i128) + self.range.0)
    }

    ///
@@ -290,24 +294,58 @@ impl<F: PrimeField + TensorType + PartialOrd> RangeCheck<F> {
    pub fn cal_bit_range(bits: usize, reserved_blinding_rows: usize) -> usize {
        2usize.pow(bits as u32) - reserved_blinding_rows
    }
+
+    /// get column index given input
+    pub fn get_col_index(&self, input: F) -> F {
+        //    range is split up into chunks of size col_size, find the chunk that input is in
+        let chunk =
+            (crate::fieldutils::felt_to_i128(input) - self.range.0).abs() / (self.col_size as i128);
+
+        i128_to_felt(chunk)
+    }
 }

 impl<F: PrimeField + TensorType + PartialOrd> RangeCheck<F> {
    /// Configures the table.
-    pub fn configure(cs: &mut ConstraintSystem<F>, range: Range) -> RangeCheck<F> {
+    pub fn configure(cs: &mut ConstraintSystem<F>, range: Range, logrows: usize) -> RangeCheck<F> {
        log::debug!("range check range: {:?}", range);

-        let inputs = cs.lookup_table_column();
+        let factors = cs.blinding_factors() + RESERVED_BLINDING_ROWS_PAD;
+        let col_size = Self::cal_col_size(logrows, factors);
+        // number of cols needed to store the range
+        let num_cols = num_cols_required(range, col_size);
+
+        let inputs = {
+            let mut cols = vec![];
+            for _ in 0..num_cols {
+                cols.push(cs.lookup_table_column());
+            }
+            cols
+        };
+
+        let num_cols = inputs.len();
+
+        if num_cols > 1 {
+            warn!("Using {} columns for range-check.", num_cols);
+        }

        RangeCheck {
-            input: inputs,
+            inputs,
+            col_size,
            is_assigned: false,
-            selector_constructor: SelectorConstructor::new(2),
+            selector_constructor: SelectorConstructor::new(num_cols),
            range,
            _marker: PhantomData,
        }
    }

+    /// Take a linear coordinate and output the (column, row) position in the storage block.
+    pub fn cartesian_coord(&self, linear_coord: usize) -> (usize, usize) {
+        let x = linear_coord / self.col_size;
+        let y = linear_coord % self.col_size;
+        (x, y)
+    }
+
    /// Assigns values to the constraints generated when calling `configure`.
    pub fn layout(&mut self, layouter: &mut impl Layouter<F>) -> Result<(), Box<dyn Error>> {
        if self.is_assigned {
@@ -318,28 +356,43 @@ impl<F: PrimeField + TensorType + PartialOrd> RangeCheck<F> {
        let largest = self.range.1;

        let inputs: Tensor<F> = Tensor::from(smallest..=largest).map(|x| i128_to_felt(x));
+        let chunked_inputs = inputs.chunks(self.col_size);

        self.is_assigned = true;

-        layouter.assign_table(
-            || "range check table",
-            |mut table| {
-                let _ = inputs
-                    .iter()
-                    .enumerate()
-                    .map(|(row_offset, input)| {
-                        table.assign_cell(
-                            || format!("rc_i_col row {}", row_offset),
-                            self.input,
-                            row_offset,
-                            || Value::known(*input),
-                        )?;
+        let col_multipliers: Vec<F> = (0..chunked_inputs.len())
+            .map(|x| self.selector_constructor.get_selector_val_at_idx(x))
+            .collect();
+
+        let _ = chunked_inputs
+            .enumerate()
+            .map(|(chunk_idx, inputs)| {
+                layouter.assign_table(
+                    || "range check table",
+                    |mut table| {
+                        let _ = inputs
+                            .iter()
+                            .enumerate()
+                            .map(|(mut row_offset, input)| {
+                                let col_multiplier = col_multipliers[chunk_idx];
+
+                                row_offset += chunk_idx * self.col_size;
+                                let (x, y) = self.cartesian_coord(row_offset);
+                                table.assign_cell(
+                                    || format!("rc_i_col row {}", row_offset),
+                                    self.inputs[x],
+                                    y,
+                                    || Value::known(*input * col_multiplier),
+                                )?;
+
+                                Ok(())
+                            })
+                            .collect::<Result<Vec<()>, halo2_proofs::plonk::Error>>()?;
                        Ok(())
-                    })
-                    .collect::<Result<Vec<()>, halo2_proofs::plonk::Error>>()?;
-                Ok(())
-            },
-        )?;
+                    },
+                )
+            })
+            .collect::<Result<Vec<()>, halo2_proofs::plonk::Error>>()?;
        Ok(())
    }
 }
--- a/src/circuit/tests.rs
+++ b/src/circuit/tests.rs
@@ -2140,148 +2140,6 @@ mod matmul_relu {
    }
 }

-#[cfg(test)]
-mod rangecheckpercent {
-    use crate::circuit::Tolerance;
-    use crate::{circuit, tensor::Tensor};
-    use halo2_proofs::{
-        circuit::{Layouter, SimpleFloorPlanner, Value},
-        dev::MockProver,
-        plonk::{Circuit, ConstraintSystem, Error},
-    };
-
-    const RANGE: f32 = 1.0; // 1 percent error tolerance
-    const K: usize = 18;
-    const LEN: usize = 1;
-    const SCALE: usize = i128::pow(2, 7) as usize;
-
-    use super::*;
-
-    #[derive(Clone)]
-    struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
-        input: ValTensor<F>,
-        output: ValTensor<F>,
-        _marker: PhantomData<F>,
-    }
-
-    impl Circuit<F> for MyCircuit<F> {
-        type Config = BaseConfig<F>;
-        type FloorPlanner = SimpleFloorPlanner;
-        type Params = TestParams;
-
-        fn without_witnesses(&self) -> Self {
-            self.clone()
-        }
-
-        fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
-            let scale = utils::F32(SCALE as f32);
-            let a = VarTensor::new_advice(cs, K, 1, LEN);
-            let b = VarTensor::new_advice(cs, K, 1, LEN);
-            let output = VarTensor::new_advice(cs, K, 1, LEN);
-            let mut config =
-                Self::Config::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::SAFE);
-            // set up a new GreaterThan and Recip tables
-            let nl = &LookupOp::GreaterThan {
-                a: circuit::utils::F32((RANGE * SCALE.pow(2) as f32) / 100.0),
-            };
-            config
-                .configure_lookup(cs, &b, &output, &a, (-32768, 32768), K, nl)
-                .unwrap();
-
-            config
-                .configure_lookup(
-                    cs,
-                    &b,
-                    &output,
-                    &a,
-                    (-32768, 32768),
-                    K,
-                    &LookupOp::Recip {
-                        input_scale: scale,
-                        output_scale: scale,
-                    },
-                )
-                .unwrap();
-            config
-        }
-
-        fn synthesize(
-            &self,
-            mut config: Self::Config,
-            mut layouter: impl Layouter<F>,
-        ) -> Result<(), Error> {
-            config.layout_tables(&mut layouter).unwrap();
-            layouter
-                .assign_region(
-                    || "",
-                    |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
-                        config
-                            .layout(
-                                &mut region,
-                                &[self.output.clone(), self.input.clone()],
-                                Box::new(HybridOp::RangeCheck(Tolerance {
-                                    val: RANGE,
-                                    scale: SCALE.into(),
-                                })),
-                            )
-                            .map_err(|_| Error::Synthesis)
-                    },
-                )
-                .unwrap();
-            Ok(())
-        }
-    }
-
-    #[test]
-    #[allow(clippy::assertions_on_constants)]
-    fn test_range_check_percent() {
-        // Successful cases
-        {
-            let inp = Tensor::new(Some(&[Value::<F>::known(F::from(100_u64))]), &[1]).unwrap();
-            let out = Tensor::new(Some(&[Value::<F>::known(F::from(101_u64))]), &[1]).unwrap();
-            let circuit = MyCircuit::<F> {
-                input: ValTensor::from(inp),
-                output: ValTensor::from(out),
-                _marker: PhantomData,
-            };
-            let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-            prover.assert_satisfied();
-        }
-        {
-            let inp = Tensor::new(Some(&[Value::<F>::known(F::from(200_u64))]), &[1]).unwrap();
-            let out = Tensor::new(Some(&[Value::<F>::known(F::from(199_u64))]), &[1]).unwrap();
-            let circuit = MyCircuit::<F> {
-                input: ValTensor::from(inp),
-                output: ValTensor::from(out),
-                _marker: PhantomData,
-            };
-            let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-            prover.assert_satisfied();
-        }
-
-        // Unsuccessful case
-        {
-            let inp = Tensor::new(Some(&[Value::<F>::known(F::from(100_u64))]), &[1]).unwrap();
-            let out = Tensor::new(Some(&[Value::<F>::known(F::from(102_u64))]), &[1]).unwrap();
-            let circuit = MyCircuit::<F> {
-                input: ValTensor::from(inp),
-                output: ValTensor::from(out),
-                _marker: PhantomData,
-            };
-            let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-            match prover.verify() {
-                Ok(_) => {
-                    assert!(false)
-                }
-                Err(_) => {
-                    assert!(true)
-                }
-            }
-        }
-    }
-}
-
 #[cfg(test)]
 mod relu {
    use super::*;
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -1,4 +1,4 @@
-use clap::{Parser, Subcommand, ValueEnum};
+use clap::{Parser, Subcommand};
 #[cfg(not(target_arch = "wasm32"))]
 use ethers::types::H160;
 #[cfg(feature = "python-bindings")]
@@ -9,8 +9,9 @@ use pyo3::{
    types::PyString,
 };
 use serde::{Deserialize, Serialize};
-use std::error::Error;
 use std::path::PathBuf;
+use std::{error::Error, str::FromStr};
+use tosubcommand::{ToFlags, ToSubcommand};

 use crate::{pfsys::ProofType, RunArgs};

@@ -87,15 +88,9 @@ pub const DEFAULT_VK_ABI: &str = "vk.abi";
 pub const DEFAULT_SCALE_REBASE_MULTIPLIERS: &str = "1,2,10";
 /// Default use reduced srs for verification
 pub const DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION: &str = "false";
+/// Default only check for range check rebase
+pub const DEFAULT_ONLY_RANGE_CHECK_REBASE: &str = "false";

-impl std::fmt::Display for TranscriptType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.to_possible_value()
-            .expect("no values are skipped")
-            .get_name()
-            .fmt(f)
-    }
-}
 #[cfg(feature = "python-bindings")]
 /// Converts TranscriptType into a PyObject (Required for TranscriptType to be compatible with Python)
 impl IntoPy<PyObject> for TranscriptType {
@@ -140,17 +135,27 @@ impl Default for CalibrationTarget {
    }
 }

-impl ToString for CalibrationTarget {
-    fn to_string(&self) -> String {
-        match self {
-            CalibrationTarget::Resources { col_overflow: true } => {
-                "resources/col-overflow".to_string()
+impl std::fmt::Display for CalibrationTarget {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                CalibrationTarget::Resources { col_overflow: true } => {
+                    "resources/col-overflow".to_string()
+                }
+                CalibrationTarget::Resources {
+                    col_overflow: false,
+                } => "resources".to_string(),
+                CalibrationTarget::Accuracy => "accuracy".to_string(),
            }
-            CalibrationTarget::Resources {
-                col_overflow: false,
-            } => "resources".to_string(),
-            CalibrationTarget::Accuracy => "accuracy".to_string(),
-        }
+        )
+    }
+}
+
+impl ToFlags for CalibrationTarget {
+    fn to_flags(&self) -> Vec<String> {
+        vec![format!("{}", self)]
    }
 }

@@ -171,6 +176,36 @@ impl From<&str> for CalibrationTarget {
    }
 }

+#[cfg(not(target_arch = "wasm32"))]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, PartialOrd)]
+/// wrapper for H160 to make it easy to parse into flag vals
+pub struct H160Flag {
+    inner: H160,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl From<H160Flag> for H160 {
+    fn from(val: H160Flag) -> H160 {
+        val.inner
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl ToFlags for H160Flag {
+    fn to_flags(&self) -> Vec<String> {
+        vec![format!("{:#x}", self.inner)]
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl From<&str> for H160Flag {
+    fn from(s: &str) -> Self {
+        Self {
+            inner: H160::from_str(s).unwrap(),
+        }
+    }
+}
+
 #[cfg(feature = "python-bindings")]
 /// Converts CalibrationTarget into a PyObject (Required for CalibrationTarget to be compatible with Python)
 impl IntoPy<PyObject> for CalibrationTarget {
@@ -203,7 +238,7 @@ impl<'source> FromPyObject<'source> for CalibrationTarget {
        }
    }
 }
-
+// not wasm
 use lazy_static::lazy_static;

 // if CARGO VERSION is 0.0.0 replace with "source - no compatibility guaranteed"
@@ -244,7 +279,7 @@ impl Cli {
 }

 #[allow(missing_docs)]
-#[derive(Debug, Subcommand, Clone, Deserialize, Serialize, PartialEq, PartialOrd)]
+#[derive(Debug, Subcommand, Clone, Deserialize, Serialize, PartialEq, PartialOrd, ToSubcommand)]
 pub enum Commands {
    #[cfg(feature = "empty-cmd")]
    /// Creates an empty buffer
@@ -338,9 +373,9 @@ pub enum Commands {
        /// max logrows to use for calibration, 26 is the max public SRS size
        #[arg(long)]
        max_logrows: Option<u32>,
-        // whether to fix the div_rebasing value truthiness during calibration. this changes how we rebase
-        #[arg(long)]
-        div_rebasing: Option<bool>,
+        // whether to only range check rebases (instead of trying both range check and lookup)
+        #[arg(long, default_value = DEFAULT_ONLY_RANGE_CHECK_REBASE)]
+        only_range_check_rebase: bool,
    },

    /// Generates a dummy SRS
@@ -436,7 +471,7 @@ pub enum Commands {
            long,
            require_equals = true,
            num_args = 0..=1,
-            default_value_t = TranscriptType::EVM,
+            default_value_t = TranscriptType::default(),
            value_enum
        )]
        transcript: TranscriptType,
@@ -491,13 +526,13 @@ pub enum Commands {
        #[arg(short = 'W', long, default_value = DEFAULT_WITNESS)]
        witness: PathBuf,
        /// The path to the compiled model file (generated using the compile-circuit command)
-        #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT)]
+        #[arg(short = 'M', long)]
        compiled_circuit: PathBuf,
        #[arg(
            long,
            require_equals = true,
            num_args = 0..=1,
-            default_value_t = TranscriptType::EVM,
+            default_value_t = TranscriptType::default(),
            value_enum
        )]
        transcript: TranscriptType,
@@ -511,7 +546,7 @@ pub enum Commands {
    #[cfg(not(target_arch = "wasm32"))]
    /// Deploys a test contact that the data attester reads from and creates a data attestation formatted input.json file that contains call data information
    #[command(arg_required_else_help = true)]
-    SetupTestEVMData {
+    SetupTestEvmData {
        /// The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
        #[arg(short = 'D', long)]
        data: PathBuf,
@@ -539,7 +574,7 @@ pub enum Commands {
    TestUpdateAccountCalls {
        /// The path to the verifier contract's address
        #[arg(long)]
-        addr: H160,
+        addr: H160Flag,
        /// The path to the .json data file.
        #[arg(short = 'D', long)]
        data: PathBuf,
@@ -589,9 +624,9 @@ pub enum Commands {
        check_mode: CheckMode,
    },
    #[cfg(not(target_arch = "wasm32"))]
-    /// Creates an EVM verifier for a single proof
+    /// Creates an Evm verifier for a single proof
    #[command(name = "create-evm-verifier")]
-    CreateEVMVerifier {
+    CreateEvmVerifier {
        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
        #[arg(long)]
        srs_path: Option<PathBuf>,
@@ -614,9 +649,9 @@ pub enum Commands {
        render_vk_seperately: bool,
    },
    #[cfg(not(target_arch = "wasm32"))]
-    /// Creates an EVM verifier for a single proof
+    /// Creates an Evm verifier for a single proof
    #[command(name = "create-evm-vk")]
-    CreateEVMVK {
+    CreateEvmVK {
        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
        #[arg(long)]
        srs_path: Option<PathBuf>,
@@ -634,9 +669,9 @@ pub enum Commands {
        abi_path: PathBuf,
    },
    #[cfg(not(target_arch = "wasm32"))]
-    /// Creates an EVM verifier that attests to on-chain inputs for a single proof
+    /// Creates an Evm verifier that attests to on-chain inputs for a single proof
    #[command(name = "create-evm-da")]
-    CreateEVMDataAttestation {
+    CreateEvmDataAttestation {
        /// 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,
@@ -656,9 +691,9 @@ pub enum Commands {
    },

    #[cfg(not(target_arch = "wasm32"))]
-    /// Creates an EVM verifier for an aggregate proof
+    /// Creates an Evm verifier for an aggregate proof
    #[command(name = "create-evm-verifier-aggr")]
-    CreateEVMVerifierAggr {
+    CreateEvmVerifierAggr {
        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
        #[arg(long)]
        srs_path: Option<PathBuf>,
@@ -699,7 +734,7 @@ pub enum Commands {
        srs_path: Option<PathBuf>,
        /// Reduce SRS logrows to the number of instances rather than the number of logrows used for proofs (only works if the srs were generated in the same ceremony)
        #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION)]
-        reduced_srs: Option<bool>,
+        reduced_srs: bool,
    },
    /// Verifies an aggregate proof, returning accept or reject
    VerifyAggr {
@@ -781,23 +816,23 @@ pub enum Commands {
        private_key: Option<String>,
    },
    #[cfg(not(target_arch = "wasm32"))]
-    /// Verifies a proof using a local EVM executor, returning accept or reject
+    /// Verifies a proof using a local Evm executor, returning accept or reject
    #[command(name = "verify-evm")]
-    VerifyEVM {
+    VerifyEvm {
        /// The path to the proof file (generated using the prove command)
        #[arg(long, default_value = DEFAULT_PROOF)]
        proof_path: PathBuf,
        /// The path to verifier contract's address
        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS)]
-        addr_verifier: H160,
+        addr_verifier: H160Flag,
        /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
        #[arg(short = 'U', long)]
        rpc_url: Option<String>,
        /// does the verifier use data attestation ?
        #[arg(long)]
-        addr_da: Option<H160>,
+        addr_da: Option<H160Flag>,
        // is the vk rendered seperately, if so specify an address
        #[arg(long)]
-        addr_vk: Option<H160>,
+        addr_vk: Option<H160Flag>,
    },
 }
--- a/src/execute.rs
+++ b/src/execute.rs
@@ -3,6 +3,8 @@ use crate::circuit::CheckMode;
 use crate::commands::CalibrationTarget;
 use crate::commands::Commands;
 #[cfg(not(target_arch = "wasm32"))]
+use crate::commands::H160Flag;
+#[cfg(not(target_arch = "wasm32"))]
 use crate::eth::{deploy_contract_via_solidity, deploy_da_verifier_via_solidity};
 #[cfg(not(target_arch = "wasm32"))]
 #[allow(unused_imports)]
@@ -21,8 +23,6 @@ use crate::pfsys::{create_proof_circuit_kzg, verify_proof_circuit_kzg};
 use crate::pfsys::{save_vk, srs::*};
 use crate::tensor::TensorError;
 use crate::RunArgs;
-#[cfg(not(target_arch = "wasm32"))]
-use ethers::types::H160;
 use gag::Gag;
 use halo2_proofs::dev::VerifyFailure;
 use halo2_proofs::poly::commitment::Params;
@@ -178,7 +178,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
            scales,
            scale_rebase_multiplier,
            max_logrows,
-            div_rebasing,
+            only_range_check_rebase,
        } => calibrate(
            model,
            data,
@@ -187,7 +187,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
            lookup_safety_margin,
            scales,
            scale_rebase_multiplier,
-            div_rebasing,
+            only_range_check_rebase,
            max_logrows,
        )
        .map(|e| serde_json::to_string(&e).unwrap()),
@@ -202,7 +202,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
            .map(|e| serde_json::to_string(&e).unwrap()),
        Commands::Mock { model, witness } => mock(model, witness),
        #[cfg(not(target_arch = "wasm32"))]
-        Commands::CreateEVMVerifier {
+        Commands::CreateEvmVerifier {
            vk_path,
            srs_path,
            settings_path,
@@ -217,7 +217,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
            abi_path,
            render_vk_seperately,
        ),
-        Commands::CreateEVMVK {
+        Commands::CreateEvmVK {
            vk_path,
            srs_path,
            settings_path,
@@ -225,14 +225,14 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
            abi_path,
        } => create_evm_vk(vk_path, srs_path, settings_path, sol_code_path, abi_path),
        #[cfg(not(target_arch = "wasm32"))]
-        Commands::CreateEVMDataAttestation {
+        Commands::CreateEvmDataAttestation {
            settings_path,
            sol_code_path,
            abi_path,
            data,
        } => create_evm_data_attestation(settings_path, sol_code_path, abi_path, data),
        #[cfg(not(target_arch = "wasm32"))]
-        Commands::CreateEVMVerifierAggr {
+        Commands::CreateEvmVerifierAggr {
            vk_path,
            srs_path,
            sol_code_path,
@@ -270,7 +270,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
            compress_selectors,
        ),
        #[cfg(not(target_arch = "wasm32"))]
-        Commands::SetupTestEVMData {
+        Commands::SetupTestEvmData {
            data,
            compiled_circuit,
            test_data,
@@ -434,7 +434,7 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
            .await
        }
        #[cfg(not(target_arch = "wasm32"))]
-        Commands::VerifyEVM {
+        Commands::VerifyEvm {
            proof_path,
            addr_verifier,
            rpc_url,
@@ -488,8 +488,14 @@ 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>> {
+    use std::io::Read;
+
    let path = get_srs_path(logrows, srs_path);
-    let hash = sha256::digest(std::fs::read(path.clone())?);
+    let file = std::fs::File::open(path.clone())?;
+    let mut buffer = vec![];
+    let bytes_read = std::io::BufReader::new(file).read_to_end(&mut buffer)?;
+    debug!("read {} bytes from SRS file", bytes_read);
+    let hash = sha256::digest(buffer);
    info!("SRS hash: {}", hash);

    let predefined_hash = match { crate::srs_sha::PUBLIC_SRS_SHA256_HASHES.get(&logrows) } {
@@ -628,7 +634,7 @@ pub(crate) async fn gen_witness(
    );

    if let Some(output_path) = output {
-        serde_json::to_writer(&File::create(output_path)?, &witness)?;
+        witness.save(output_path)?;
    }

    // print the witness in debug
@@ -780,6 +786,7 @@ impl AccuracyResults {
 /// Calibrate the circuit parameters to a given a dataset
 #[cfg(not(target_arch = "wasm32"))]
 #[allow(trivial_casts)]
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn calibrate(
    model_path: PathBuf,
    data: PathBuf,
@@ -788,7 +795,7 @@ pub(crate) fn calibrate(
    lookup_safety_margin: i128,
    scales: Option<Vec<crate::Scale>>,
    scale_rebase_multiplier: Vec<u32>,
-    div_rebasing: Option<bool>,
+    only_range_check_rebase: bool,
    max_logrows: Option<u32>,
 ) -> Result<GraphSettings, Box<dyn Error>> {
    use std::collections::HashMap;
@@ -829,8 +836,8 @@ pub(crate) fn calibrate(
        (10..14).collect::<Vec<crate::Scale>>()
    };

-    let div_rebasing = if let Some(div_rebasing) = div_rebasing {
-        vec![div_rebasing]
+    let div_rebasing = if only_range_check_rebase {
+        vec![false]
    } else {
        vec![true, false]
    };
@@ -962,18 +969,34 @@ pub(crate) fn calibrate(
            .max()
            .unwrap_or(0);

+        let min_range_check = forward_pass_res
+            .get(&key)
+            .unwrap()
+            .iter()
+            .map(|x| x.min_range_check)
+            .min()
+            .unwrap_or(0);
+
+        let max_range_check = forward_pass_res
+            .get(&key)
+            .unwrap()
+            .iter()
+            .map(|x| x.max_range_check)
+            .max()
+            .unwrap_or(0);
+
        let res = circuit.calibrate_from_min_max(
-            min_lookup_range,
-            max_lookup_range,
+            (min_lookup_range, max_lookup_range),
+            (min_range_check, max_range_check),
            max_logrows,
            lookup_safety_margin,
        );

-        // drop the gag
-        #[cfg(unix)]
-        std::mem::drop(_r);
-        #[cfg(unix)]
-        std::mem::drop(_q);
+        // // drop the gag
+        // #[cfg(unix)]
+        // std::mem::drop(_r);
+        // #[cfg(unix)]
+        // std::mem::drop(_q);

        if res.is_ok() {
            let new_settings = circuit.settings().clone();
@@ -1387,10 +1410,10 @@ pub(crate) async fn deploy_evm(
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn verify_evm(
    proof_path: PathBuf,
-    addr_verifier: H160,
+    addr_verifier: H160Flag,
    rpc_url: Option<String>,
-    addr_da: Option<H160>,
-    addr_vk: Option<H160>,
+    addr_da: Option<H160Flag>,
+    addr_vk: Option<H160Flag>,
 ) -> Result<String, Box<dyn Error>> {
    use crate::eth::verify_proof_with_data_attestation;
    check_solc_requirement();
@@ -1400,14 +1423,20 @@ pub(crate) async fn verify_evm(
    let result = if let Some(addr_da) = addr_da {
        verify_proof_with_data_attestation(
            proof.clone(),
-            addr_verifier,
-            addr_da,
-            addr_vk,
+            addr_verifier.into(),
+            addr_da.into(),
+            addr_vk.map(|s| s.into()),
            rpc_url.as_deref(),
        )
        .await?
    } else {
-        verify_proof_via_solidity(proof.clone(), addr_verifier, addr_vk, rpc_url.as_deref()).await?
+        verify_proof_via_solidity(
+            proof.clone(),
+            addr_verifier.into(),
+            addr_vk.map(|s| s.into()),
+            rpc_url.as_deref(),
+        )
+        .await?
    };

    info!("Solidity verification result: {}", result);
@@ -1563,14 +1592,14 @@ pub(crate) async fn setup_test_evm_witness(
 use crate::pfsys::ProofType;
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn test_update_account_calls(
-    addr: H160,
+    addr: H160Flag,
    data: PathBuf,
    rpc_url: Option<String>,
 ) -> Result<String, Box<dyn Error>> {
    use crate::eth::update_account_calls;

    check_solc_requirement();
-    update_account_calls(addr, data, rpc_url.as_deref()).await?;
+    update_account_calls(addr.into(), data, rpc_url.as_deref()).await?;

    Ok(String::new())
 }
@@ -2037,16 +2066,12 @@ pub(crate) fn verify(
    settings_path: PathBuf,
    vk_path: PathBuf,
    srs_path: Option<PathBuf>,
-    reduced_srs: Option<bool>,
+    reduced_srs: bool,
 ) -> Result<bool, Box<dyn Error>> {
    let circuit_settings = GraphSettings::load(&settings_path)?;

-    let params = if let Some(reduced_srs) = reduced_srs {
-        if reduced_srs {
-            load_params_cmd(srs_path, circuit_settings.log2_total_instances())?
-        } else {
-            load_params_cmd(srs_path, circuit_settings.run_args.logrows)?
-        }
+    let params = if reduced_srs {
+        load_params_cmd(srs_path, circuit_settings.log2_total_instances())?
    } else {
        load_params_cmd(srs_path, circuit_settings.run_args.logrows)?
    };
--- a/src/graph/input.rs
+++ b/src/graph/input.rs
@@ -4,6 +4,7 @@ use crate::circuit::InputType;
 use crate::fieldutils::i128_to_felt;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::tensor::Tensor;
+use crate::EZKL_BUF_CAPACITY;
 use halo2curves::bn256::Fr as Fp;
 #[cfg(not(target_arch = "wasm32"))]
 use postgres::{Client, NoTls};
@@ -15,6 +16,8 @@ use pyo3::types::PyDict;
 use pyo3::ToPyObject;
 use serde::ser::SerializeStruct;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::io::BufReader;
+use std::io::BufWriter;
 use std::io::Read;
 use std::panic::UnwindSafe;
 #[cfg(not(target_arch = "wasm32"))]
@@ -490,16 +493,20 @@ impl GraphData {

    /// Load the model input from a file
    pub fn from_path(path: std::path::PathBuf) -> Result<Self, Box<dyn std::error::Error>> {
-        let mut file = std::fs::File::open(path.clone())
-            .map_err(|_| format!("failed to open input at {}", path.display()))?;
-        let mut data = String::new();
-        file.read_to_string(&mut data)?;
-        serde_json::from_str(&data).map_err(|e| e.into())
+        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)?;
+        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<(), Box<dyn std::error::Error>> {
-        serde_json::to_writer(std::fs::File::create(path)?, &self).map_err(|e| e.into())
+        // buf writer
+        let writer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, std::fs::File::create(path)?);
+        serde_json::to_writer(writer, self)?;
+        Ok(())
    }

    ///
@@ -617,13 +624,13 @@ impl ToPyObject for DataSource {
 }

 #[cfg(feature = "python-bindings")]
-use crate::pfsys::field_to_string_montgomery;
+use crate::pfsys::field_to_string;

 #[cfg(feature = "python-bindings")]
 impl ToPyObject for FileSourceInner {
    fn to_object(&self, py: Python) -> PyObject {
        match self {
-            FileSourceInner::Field(data) => field_to_string_montgomery(data).to_object(py),
+            FileSourceInner::Field(data) => field_to_string(data).to_object(py),
            FileSourceInner::Bool(data) => data.to_object(py),
            FileSourceInner::Float(data) => data.to_object(py),
        }
--- a/src/graph/mod.rs
+++ b/src/graph/mod.rs
@@ -16,6 +16,7 @@ use halo2_proofs::plonk::VerifyingKey;
 use halo2_proofs::poly::kzg::commitment::ParamsKZG;
 pub use input::DataSource;
 use itertools::Itertools;
+use tosubcommand::ToFlags;

 #[cfg(not(target_arch = "wasm32"))]
 use self::input::OnChainSource;
@@ -23,12 +24,13 @@ use self::input::{FileSource, GraphData};
 use self::modules::{GraphModules, ModuleConfigs, ModuleForwardResult, ModuleSizes};
 use crate::circuit::lookup::LookupOp;
 use crate::circuit::modules::ModulePlanner;
-use crate::circuit::table::{Range, Table, RESERVED_BLINDING_ROWS_PAD};
+use crate::circuit::table::{num_cols_required, Range, Table, RESERVED_BLINDING_ROWS_PAD};
 use crate::circuit::{CheckMode, InputType};
 use crate::fieldutils::felt_to_f64;
 use crate::pfsys::PrettyElements;
 use crate::tensor::{Tensor, ValTensor};
-use crate::RunArgs;
+use crate::{RunArgs, EZKL_BUF_CAPACITY};
+
 use halo2_proofs::{
    circuit::Layouter,
    plonk::{Circuit, ConstraintSystem, Error as PlonkError},
@@ -37,7 +39,7 @@ 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 log::{debug, error, trace, warn};
 use maybe_rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
 pub use model::*;
 pub use node::*;
@@ -48,14 +50,13 @@ use pyo3::types::PyDict;
 #[cfg(feature = "python-bindings")]
 use pyo3::ToPyObject;
 use serde::{Deserialize, Serialize};
-use std::io::{Read, Write};
 use std::ops::Deref;
 use thiserror::Error;
 pub use utilities::*;
 pub use vars::*;

 #[cfg(feature = "python-bindings")]
-use crate::pfsys::field_to_string_montgomery;
+use crate::pfsys::field_to_string;

 /// The safety factor for the range of the lookup table.
 pub const RANGE_MULTIPLIER: i128 = 2;
@@ -170,6 +171,10 @@ pub struct GraphWitness {
    pub max_lookup_inputs: i128,
    /// max lookup input
    pub min_lookup_inputs: i128,
+    /// max range check input
+    pub max_range_check: i128,
+    /// max range check input
+    pub min_range_check: i128,
 }

 impl GraphWitness {
@@ -197,6 +202,8 @@ impl GraphWitness {
            processed_outputs: None,
            max_lookup_inputs: 0,
            min_lookup_inputs: 0,
+            max_range_check: 0,
+            min_range_check: 0,
        }
    }

@@ -207,42 +214,41 @@ impl GraphWitness {
        output_scales: Vec<crate::Scale>,
        visibility: VarVisibility,
    ) {
-        let mut pretty_elements = PrettyElements::default();
-        pretty_elements.rescaled_inputs = self
-            .inputs
-            .iter()
-            .enumerate()
-            .map(|(i, t)| {
-                let scale = input_scales[i];
-                t.iter()
-                    .map(|x| dequantize(*x, scale, 0.).to_string())
-                    .collect()
-            })
-            .collect();
-
-        pretty_elements.inputs = self
-            .inputs
-            .iter()
-            .map(|t| t.iter().map(|x| format!("{:?}", x)).collect())
-            .collect();
-
-        pretty_elements.rescaled_outputs = self
-            .outputs
-            .iter()
-            .enumerate()
-            .map(|(i, t)| {
-                let scale = output_scales[i];
-                t.iter()
-                    .map(|x| dequantize(*x, scale, 0.).to_string())
-                    .collect()
-            })
-            .collect();
-
-        pretty_elements.outputs = self
-            .outputs
-            .iter()
-            .map(|t| t.iter().map(|x| format!("{:?}", x)).collect())
-            .collect();
+        let mut pretty_elements = PrettyElements {
+            rescaled_inputs: self
+                .inputs
+                .iter()
+                .enumerate()
+                .map(|(i, t)| {
+                    let scale = input_scales[i];
+                    t.iter()
+                        .map(|x| dequantize(*x, scale, 0.).to_string())
+                        .collect()
+                })
+                .collect(),
+            inputs: self
+                .inputs
+                .iter()
+                .map(|t| t.iter().map(|x| format!("{:?}", x)).collect())
+                .collect(),
+            rescaled_outputs: self
+                .outputs
+                .iter()
+                .enumerate()
+                .map(|(i, t)| {
+                    let scale = output_scales[i];
+                    t.iter()
+                        .map(|x| dequantize(*x, scale, 0.).to_string())
+                        .collect()
+                })
+                .collect(),
+            outputs: self
+                .outputs
+                .iter()
+                .map(|t| t.iter().map(|x| format!("{:?}", x)).collect())
+                .collect(),
+            ..Default::default()
+        };

        if let Some(processed_inputs) = self.processed_inputs.clone() {
            pretty_elements.processed_inputs = processed_inputs
@@ -308,16 +314,20 @@ impl GraphWitness {

    /// Load the model input from a file
    pub fn from_path(path: std::path::PathBuf) -> Result<Self, Box<dyn std::error::Error>> {
-        let mut file = std::fs::File::open(path.clone())
+        let file = std::fs::File::open(path.clone())
            .map_err(|_| format!("failed to load model at {}", path.display()))?;
-        let mut data = String::new();
-        file.read_to_string(&mut data)?;
-        serde_json::from_str(&data).map_err(|e| e.into())
+
+        let reader = std::io::BufReader::with_capacity(*EZKL_BUF_CAPACITY, file);
+        serde_json::from_reader(reader).map_err(|e| e.into())
    }

    /// Save the model input to a file
    pub fn save(&self, path: std::path::PathBuf) -> Result<(), Box<dyn std::error::Error>> {
-        serde_json::to_writer(std::fs::File::create(path)?, &self).map_err(|e| e.into())
+        // use buf writer
+        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())
    }

    ///
@@ -351,19 +361,25 @@ impl ToPyObject for GraphWitness {
        let inputs: Vec<Vec<String>> = self
            .inputs
            .iter()
-            .map(|x| x.iter().map(field_to_string_montgomery).collect())
+            .map(|x| x.iter().map(field_to_string).collect())
            .collect();

        let outputs: Vec<Vec<String>> = self
            .outputs
            .iter()
-            .map(|x| x.iter().map(field_to_string_montgomery).collect())
+            .map(|x| x.iter().map(field_to_string).collect())
            .collect();

        dict.set_item("inputs", inputs).unwrap();
        dict.set_item("outputs", outputs).unwrap();
        dict.set_item("max_lookup_inputs", self.max_lookup_inputs)
            .unwrap();
+        dict.set_item("min_lookup_inputs", self.min_lookup_inputs)
+            .unwrap();
+        dict.set_item("max_range_check", self.max_range_check)
+            .unwrap();
+        dict.set_item("min_range_check", self.min_range_check)
+            .unwrap();

        if let Some(processed_inputs) = &self.processed_inputs {
            //poseidon_hash
@@ -405,10 +421,7 @@ impl ToPyObject for GraphWitness {

 #[cfg(feature = "python-bindings")]
 fn insert_poseidon_hash_pydict(pydict: &PyDict, poseidon_hash: &Vec<Fp>) -> Result<(), PyErr> {
-    let poseidon_hash: Vec<String> = poseidon_hash
-        .iter()
-        .map(field_to_string_montgomery)
-        .collect();
+    let poseidon_hash: Vec<String> = poseidon_hash.iter().map(field_to_string).collect();
    pydict.set_item("poseidon_hash", poseidon_hash)?;

    Ok(())
@@ -482,20 +495,23 @@ impl GraphSettings {

    /// save params to file
    pub fn save(&self, path: &std::path::PathBuf) -> Result<(), std::io::Error> {
-        let encoded = serde_json::to_string(&self)?;
-        let mut file = std::fs::File::create(path)?;
-        file.write_all(encoded.as_bytes())
+        // buf writer
+        let writer =
+            std::io::BufWriter::with_capacity(*EZKL_BUF_CAPACITY, std::fs::File::create(path)?);
+        serde_json::to_writer(writer, &self).map_err(|e| {
+            error!("failed to save settings file at {}", e);
+            std::io::Error::new(std::io::ErrorKind::Other, e)
+        })
    }
    /// load params from file
    pub fn load(path: &std::path::PathBuf) -> Result<Self, std::io::Error> {
-        let mut file = std::fs::File::open(path).map_err(|e| {
-            error!("failed to open settings file at {}", e);
-            e
-        })?;
-        let mut data = String::new();
-        file.read_to_string(&mut data)?;
-        let res = serde_json::from_str(&data)?;
-        Ok(res)
+        // buf reader
+        let reader =
+            std::io::BufReader::with_capacity(*EZKL_BUF_CAPACITY, std::fs::File::open(path)?);
+        serde_json::from_reader(reader).map_err(|e| {
+            error!("failed to load settings file at {}", e);
+            std::io::Error::new(std::io::ErrorKind::Other, e)
+        })
    }

    /// Export the ezkl configuration as json
@@ -591,7 +607,7 @@ impl GraphCircuit {
    ///
    pub fn save(&self, path: std::path::PathBuf) -> Result<(), Box<dyn std::error::Error>> {
        let f = std::fs::File::create(path)?;
-        let writer = std::io::BufWriter::new(f);
+        let writer = std::io::BufWriter::with_capacity(*EZKL_BUF_CAPACITY, f);
        bincode::serialize_into(writer, &self)?;
        Ok(())
    }
@@ -599,11 +615,10 @@ impl GraphCircuit {
    ///
    pub fn load(path: std::path::PathBuf) -> Result<Self, Box<dyn std::error::Error>> {
        // read bytes from file
-        let mut f = std::fs::File::open(&path)?;
-        let metadata = std::fs::metadata(&path)?;
-        let mut buffer = vec![0; metadata.len() as usize];
-        f.read_exact(&mut buffer)?;
-        let result = bincode::deserialize(&buffer)?;
+        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)?;
+
        Ok(result)
    }
 }
@@ -618,6 +633,17 @@ pub enum TestDataSource {
    OnChain,
 }

+impl std::fmt::Display for TestDataSource {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TestDataSource::File => write!(f, "file"),
+            TestDataSource::OnChain => write!(f, "on-chain"),
+        }
+    }
+}
+
+impl ToFlags for TestDataSource {}
+
 impl From<String> for TestDataSource {
    fn from(value: String) -> Self {
        match value.to_lowercase().as_str() {
@@ -983,14 +1009,10 @@ impl GraphCircuit {
        (ASSUMED_BLINDING_FACTORS + RESERVED_BLINDING_ROWS_PAD) as f64
    }

-    fn calc_safe_lookup_range(
-        min_lookup_inputs: i128,
-        max_lookup_inputs: i128,
-        lookup_safety_margin: i128,
-    ) -> Range {
+    fn calc_safe_lookup_range(min_max_lookup: Range, lookup_safety_margin: i128) -> Range {
        let mut margin = (
-            lookup_safety_margin * min_lookup_inputs,
-            lookup_safety_margin * max_lookup_inputs,
+            lookup_safety_margin * min_max_lookup.0,
+            lookup_safety_margin * min_max_lookup.1,
        );
        if lookup_safety_margin == 1 {
            margin.0 += 4;
@@ -1005,13 +1027,13 @@ impl GraphCircuit {
            max_logrows as usize,
            Self::reserved_blinding_rows() as usize,
        );
-        Table::<Fp>::num_cols_required(safe_range, max_col_size)
+        num_cols_required(safe_range, max_col_size)
    }

    fn calc_min_logrows(
        &mut self,
-        min_lookup_inputs: i128,
-        max_lookup_inputs: i128,
+        min_max_lookup: Range,
+        min_max_range_checks: Range,
        max_logrows: Option<u32>,
        lookup_safety_margin: i128,
    ) -> Result<(), Box<dyn std::error::Error>> {
@@ -1023,18 +1045,32 @@ impl GraphCircuit {

        let reserved_blinding_rows = Self::reserved_blinding_rows();
        // check if has overflowed max lookup input
-        if max_lookup_inputs > MAX_LOOKUP_ABS / lookup_safety_margin
-            || min_lookup_inputs < -MAX_LOOKUP_ABS / lookup_safety_margin
+        if min_max_lookup.1.abs() > MAX_LOOKUP_ABS / lookup_safety_margin
+            || min_max_lookup.0.abs() > MAX_LOOKUP_ABS / lookup_safety_margin
        {
-            let err_string = format!("max lookup input ({}) is too large", max_lookup_inputs);
+            let err_string = format!("max lookup input {:?} is too large", min_max_lookup);
            return Err(err_string.into());
        }

-        let safe_range = Self::calc_safe_lookup_range(
-            min_lookup_inputs,
-            max_lookup_inputs,
-            lookup_safety_margin,
-        );
+        if min_max_range_checks.1.abs() > MAX_LOOKUP_ABS
+            || min_max_range_checks.1.abs() > MAX_LOOKUP_ABS
+        {
+            let err_string = format!(
+                "max range check input {:?} is too large",
+                min_max_range_checks
+            );
+            return Err(err_string.into());
+        }
+
+        let safe_lookup_range = Self::calc_safe_lookup_range(min_max_lookup, lookup_safety_margin);
+        // pick the range with the largest absolute size between safe_lookup_range and min_max_range_checks
+        let safe_range = if (safe_lookup_range.1 - safe_lookup_range.0)
+            > (min_max_range_checks.1 - min_max_range_checks.0)
+        {
+            safe_lookup_range
+        } else {
+            min_max_range_checks
+        };

        // degrade the max logrows until the extended k is small enough
        while min_logrows < max_logrows
@@ -1118,7 +1154,7 @@ impl GraphCircuit {

        let model = self.model().clone();
        let settings_mut = self.settings_mut();
-        settings_mut.run_args.lookup_range = safe_range;
+        settings_mut.run_args.lookup_range = safe_lookup_range;
        settings_mut.run_args.logrows = logrows as u32;

        *settings_mut = GraphCircuit::new(model, &settings_mut.run_args)?
@@ -1171,14 +1207,14 @@ impl GraphCircuit {
    /// Calibrate the circuit to the supplied data.
    pub fn calibrate_from_min_max(
        &mut self,
-        min_lookup_inputs: i128,
-        max_lookup_inputs: i128,
+        min_max_lookup: Range,
+        min_max_range_checks: Range,
        max_logrows: Option<u32>,
        lookup_safety_margin: i128,
    ) -> Result<(), Box<dyn std::error::Error>> {
        self.calc_min_logrows(
-            min_lookup_inputs,
-            max_lookup_inputs,
+            min_max_lookup,
+            min_max_range_checks,
            max_logrows,
            lookup_safety_margin,
        )?;
@@ -1231,7 +1267,7 @@ impl GraphCircuit {
            }
        }

-        let mut model_results = self.model().forward(inputs)?;
+        let mut model_results = self.model().forward(inputs, &self.settings().run_args)?;

        if visibility.output.requires_processing() {
            let module_outlets = visibility.output.overwrites_inputs();
@@ -1274,6 +1310,8 @@ impl GraphCircuit {
            processed_outputs,
            max_lookup_inputs: model_results.max_lookup_inputs,
            min_lookup_inputs: model_results.min_lookup_inputs,
+            max_range_check: model_results.max_range_check,
+            min_range_check: model_results.min_range_check,
        };

        witness.generate_rescaled_elements(
@@ -1520,7 +1558,7 @@ impl Circuit<Fp> for GraphCircuit {
        let circuit_size = CircuitSize::from_cs(cs, params.run_args.logrows);

        #[cfg(not(target_arch = "wasm32"))]
-        info!(
+        debug!(
            "circuit size: \n {}",
            circuit_size
                .as_json()
--- a/src/graph/model.rs
+++ b/src/graph/model.rs
@@ -56,6 +56,8 @@ use unzip_n::unzip_n;

 unzip_n!(pub 3);

+#[cfg(not(target_arch = "wasm32"))]
+type TractResult = (Graph<TypedFact, Box<dyn TypedOp>>, SymbolValues);
 /// The result of a forward pass.
 #[derive(Clone, Debug)]
 pub struct ForwardResult {
@@ -65,6 +67,10 @@ pub struct ForwardResult {
    pub max_lookup_inputs: i128,
    /// The minimum value of any input to a lookup operation.
    pub min_lookup_inputs: i128,
+    /// The max range check value
+    pub max_range_check: i128,
+    /// The min range check value
+    pub min_range_check: i128,
 }

 impl From<DummyPassRes> for ForwardResult {
@@ -73,6 +79,8 @@ impl From<DummyPassRes> for ForwardResult {
            outputs: res.outputs,
            max_lookup_inputs: res.max_lookup_inputs,
            min_lookup_inputs: res.min_lookup_inputs,
+            min_range_check: res.min_range_check,
+            max_range_check: res.max_range_check,
        }
    }
 }
@@ -106,6 +114,10 @@ pub struct DummyPassRes {
    pub max_lookup_inputs: i128,
    /// min lookup inputs
    pub min_lookup_inputs: i128,
+    /// min range check
+    pub min_range_check: i128,
+    /// max range check
+    pub max_range_check: i128,
    /// outputs
    pub outputs: Vec<Tensor<Fp>>,
 }
@@ -554,12 +566,16 @@ impl Model {
    /// * `reader` - A reader for an Onnx file.
    /// * `model_inputs` - A vector of [Tensor]s to use as inputs to the model.
    /// * `run_args` - [RunArgs]
-    pub fn forward(&self, model_inputs: &[Tensor<Fp>]) -> Result<ForwardResult, Box<dyn Error>> {
+    pub fn forward(
+        &self,
+        model_inputs: &[Tensor<Fp>],
+        run_args: &RunArgs,
+    ) -> Result<ForwardResult, Box<dyn Error>> {
        let valtensor_inputs: Vec<ValTensor<Fp>> = model_inputs
            .iter()
            .map(|x| x.map(|elem| ValType::Value(Value::known(elem))).into())
            .collect();
-        let res = self.dummy_layout(&RunArgs::default(), &valtensor_inputs)?;
+        let res = self.dummy_layout(run_args, &valtensor_inputs)?;
        Ok(res.into())
    }

@@ -572,7 +588,7 @@ impl Model {
    fn load_onnx_using_tract(
        reader: &mut dyn std::io::Read,
        run_args: &RunArgs,
-    ) -> Result<(Graph<TypedFact, Box<dyn TypedOp>>, SymbolValues), Box<dyn Error>> {
+    ) -> Result<TractResult, Box<dyn Error>> {
        use tract_onnx::{
            tract_core::internal::IntoArcTensor, tract_hir::internal::GenericFactoid,
        };
@@ -1019,7 +1035,7 @@ impl Model {
        }

        for range in required_range_checks {
-            base_gate.configure_range_check(meta, input, range)?;
+            base_gate.configure_range_check(meta, input, index, range, logrows)?;
        }

        Ok(base_gate)
@@ -1369,27 +1385,26 @@ impl Model {
                ValType::Constant(Fp::ONE)
            };

-            let comparator = outputs
+            let output_scales = self.graph.get_output_scales()?;
+            let res = outputs
                .iter()
-                .map(|x| {
-                    let mut v: ValTensor<Fp> =
-                        vec![default_value.clone(); x.dims().iter().product::<usize>()].into();
-                    v.reshape(x.dims())?;
-                    Ok(v)
-                })
-                .collect::<Result<Vec<_>, Box<dyn Error>>>()?;
+                .enumerate()
+                .map(|(i, output)| {
+                    let mut tolerance = run_args.tolerance;
+                    tolerance.scale = scale_to_multiplier(output_scales[i]).into();
+
+                    let mut comparator: ValTensor<Fp> =
+                        vec![default_value.clone(); output.dims().iter().product::<usize>()].into();
+                    comparator.reshape(output.dims())?;

-            let _ = outputs
-                .iter()
-                .zip(comparator)
-                .map(|(o, c)| {
                    dummy_config.layout(
                        &mut region,
-                        &[o.clone(), c],
-                        Box::new(HybridOp::RangeCheck(run_args.tolerance)),
+                        &[output.clone(), comparator],
+                        Box::new(HybridOp::RangeCheck(tolerance)),
                    )
                })
-                .collect::<Result<Vec<_>, _>>()?;
+                .collect::<Result<Vec<_>, _>>();
+            res?;
        } else if !self.visibility.output.is_private() {
            for output in &outputs {
                region.increment_total_constants(output.num_constants());
@@ -1426,6 +1441,8 @@ impl Model {
            range_checks: region.used_range_checks(),
            max_lookup_inputs: region.max_lookup_inputs(),
            min_lookup_inputs: region.min_lookup_inputs(),
+            min_range_check: region.min_range_check(),
+            max_range_check: region.max_range_check(),
            outputs,
        };

--- a/src/graph/node.rs
+++ b/src/graph/node.rs
@@ -497,6 +497,7 @@ impl Node {
    /// * `public_params` - flag if parameters of model are public
    /// * `idx` - The node's unique identifier.
    #[cfg(not(target_arch = "wasm32"))]
+    #[allow(clippy::too_many_arguments)]
    pub fn new(
        node: OnnxNode<TypedFact, Box<dyn TypedOp>>,
        other_nodes: &mut BTreeMap<usize, super::NodeType>,
--- a/src/graph/vars.rs
+++ b/src/graph/vars.rs
@@ -1,4 +1,5 @@
 use std::error::Error;
+use std::fmt::Display;

 use crate::tensor::TensorType;
 use crate::tensor::{ValTensor, VarTensor};
@@ -14,6 +15,7 @@ use pyo3::{
 };

 use serde::{Deserialize, Serialize};
+use tosubcommand::ToFlags;

 use super::*;

@@ -40,6 +42,33 @@ pub enum Visibility {
    Fixed,
 }

+impl Display for Visibility {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Visibility::KZGCommit => write!(f, "kzgcommit"),
+            Visibility::Private => write!(f, "private"),
+            Visibility::Public => write!(f, "public"),
+            Visibility::Fixed => write!(f, "fixed"),
+            Visibility::Hashed {
+                hash_is_public,
+                outlets,
+            } => {
+                if *hash_is_public {
+                    write!(f, "hashed/public")
+                } else {
+                    write!(f, "hashed/private/{}", outlets.iter().join(","))
+                }
+            }
+        }
+    }
+}
+
+impl ToFlags for Visibility {
+    fn to_flags(&self) -> Vec<String> {
+        vec![format!("{}", self)]
+    }
+}
+
 impl<'a> From<&'a str> for Visibility {
    fn from(s: &'a str) -> Self {
        if s.contains("hashed/private") {
@@ -202,17 +231,6 @@ impl Visibility {
        vec![]
    }
 }
-impl std::fmt::Display for Visibility {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match self {
-            Visibility::KZGCommit => write!(f, "kzgcommit"),
-            Visibility::Private => write!(f, "private"),
-            Visibility::Public => write!(f, "public"),
-            Visibility::Fixed => write!(f, "fixed"),
-            Visibility::Hashed { .. } => write!(f, "hashed"),
-        }
-    }
-}

 /// Represents the scale of the model input, model parameters.
 #[derive(Clone, Debug, Default, Deserialize, Serialize, PartialEq, PartialOrd)]
@@ -410,7 +428,7 @@ impl<F: PrimeField + TensorType + PartialOrd> ModelVars<F> {
        num_constants: usize,
        module_requires_fixed: bool,
    ) -> Self {
-        info!("number of blinding factors: {}", cs.blinding_factors());
+        debug!("number of blinding factors: {}", cs.blinding_factors());

        let advices = (0..3)
            .map(|_| VarTensor::new_advice(cs, logrows, num_inner_cols, var_len))
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -32,6 +32,7 @@ use circuit::{table::Range, CheckMode, Tolerance};
 use clap::Args;
 use graph::Visibility;
 use serde::{Deserialize, Serialize};
+use tosubcommand::ToFlags;

 /// Methods for configuring tensor operations and assigning values to them in a Halo2 circuit.
 pub mod circuit;
@@ -70,11 +71,34 @@ pub mod tensor;
 #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
 pub mod wasm;

+#[cfg(not(target_arch = "wasm32"))]
+use lazy_static::lazy_static;
+
 /// The denominator in the fixed point representation used when quantizing inputs
 pub type Scale = i32;

+#[cfg(not(target_arch = "wasm32"))]
+// Buf writer capacity
+lazy_static! {
+    /// The capacity of the buffer used for writing to disk
+    pub static ref EZKL_BUF_CAPACITY: usize = std::env::var("EZKL_BUF_CAPACITY")
+        .unwrap_or("8000".to_string())
+        .parse()
+        .unwrap();
+
+    /// The serialization format for the keys
+    pub static ref EZKL_KEY_FORMAT: String = std::env::var("EZKL_KEY_FORMAT")
+        .unwrap_or("raw-bytes".to_string());
+}
+
+#[cfg(target_arch = "wasm32")]
+const EZKL_KEY_FORMAT: &str = "raw-bytes";
+
+#[cfg(target_arch = "wasm32")]
+const EZKL_BUF_CAPACITY: &usize = &8000;
+
 /// Parameters specific to a proving run
-#[derive(Debug, Args, Deserialize, Serialize, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Args, Deserialize, Serialize, Clone, PartialEq, PartialOrd, ToFlags)]
 pub struct RunArgs {
    /// The tolerance for error on model outputs
    #[arg(short = 'T', long, default_value = "0")]
@@ -89,7 +113,7 @@ pub struct RunArgs {
    #[arg(long, default_value = "1")]
    pub scale_rebase_multiplier: u32,
    /// The min and max elements in the lookup table input column
-    #[arg(short = 'B', long, value_parser = parse_tuple::<i128>, default_value = "(-32768,32768)")]
+    #[arg(short = 'B', long, value_parser = parse_key_val::<i128, i128>, default_value = "-32768->32768")]
    pub lookup_range: Range,
    /// The log_2 number of rows
    #[arg(short = 'K', long, default_value = "17")]
@@ -98,7 +122,7 @@ pub struct RunArgs {
    #[arg(short = 'N', long, default_value = "2")]
    pub num_inner_cols: usize,
    /// 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 = ',')]
+    #[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
    #[arg(long, default_value = "private")]
@@ -180,34 +204,15 @@ fn parse_key_val<T, U>(
    s: &str,
 ) -> Result<(T, U), Box<dyn std::error::Error + Send + Sync + 'static>>
 where
-    T: std::str::FromStr,
+    T: std::str::FromStr + std::fmt::Debug,
    T::Err: std::error::Error + Send + Sync + 'static,
-    U: std::str::FromStr,
+    U: std::str::FromStr + std::fmt::Debug,
    U::Err: std::error::Error + Send + Sync + 'static,
 {
    let pos = s
-        .find('=')
-        .ok_or_else(|| format!("invalid KEY=value: no `=` found in `{s}`"))?;
-    Ok((s[..pos].parse()?, s[pos + 1..].parse()?))
-}
-
-/// Parse a tuple
-fn parse_tuple<T>(s: &str) -> Result<(T, T), Box<dyn std::error::Error + Send + Sync + 'static>>
-where
-    T: std::str::FromStr + Clone,
-    T::Err: std::error::Error + Send + Sync + 'static,
-{
-    let res = s.trim_matches(|p| p == '(' || p == ')').split(',');
-
-    let res = res
-        .map(|x| {
-            // remove blank space
-            let x = x.trim();
-            x.parse::<T>()
-        })
-        .collect::<Result<Vec<_>, _>>()?;
-    if res.len() != 2 {
-        return Err("invalid tuple".into());
-    }
-    Ok((res[0].clone(), res[1].clone()))
+        .find("->")
+        .ok_or_else(|| format!("invalid x->y: no `->` found in `{s}`"))?;
+    let a = s[..pos].parse()?;
+    let b = s[pos + 2..].parse()?;
+    Ok((a, b))
 }
--- a/src/pfsys/mod.rs
+++ b/src/pfsys/mod.rs
@@ -8,6 +8,7 @@ use crate::circuit::CheckMode;
 use crate::graph::GraphWitness;
 use crate::pfsys::evm::aggregation::PoseidonTranscript;
 use crate::tensor::TensorType;
+use crate::{EZKL_BUF_CAPACITY, EZKL_KEY_FORMAT};
 use clap::ValueEnum;
 use halo2_proofs::circuit::Value;
 use halo2_proofs::plonk::{
@@ -39,25 +40,19 @@ use std::io::{self, BufReader, BufWriter, Cursor, Write};
 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 tosubcommand::ToFlags;

 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();
+fn serde_format_from_str(s: &str) -> halo2_proofs::SerdeFormat {
+    match s {
+        "processed" => halo2_proofs::SerdeFormat::Processed,
+        "raw-bytes-unchecked" => halo2_proofs::SerdeFormat::RawBytesUnchecked,
+        "raw-bytes" => halo2_proofs::SerdeFormat::RawBytes,
+        _ => panic!("invalid serde format"),
+    }
 }

-#[cfg(target_arch = "wasm32")]
-const EZKL_BUF_CAPACITY: &usize = &8000;
-
 #[allow(missing_docs)]
 #[derive(
    ValueEnum, Copy, Clone, Default, Debug, PartialEq, Eq, Deserialize, Serialize, PartialOrd,
@@ -68,6 +63,25 @@ pub enum ProofType {
    ForAggr,
 }

+impl std::fmt::Display for ProofType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                ProofType::Single => "single",
+                ProofType::ForAggr => "for-aggr",
+            }
+        )
+    }
+}
+
+impl ToFlags for ProofType {
+    fn to_flags(&self) -> Vec<String> {
+        vec![format!("{}", self)]
+    }
+}
+
 impl From<ProofType> for TranscriptType {
    fn from(val: ProofType) -> Self {
        match val {
@@ -170,6 +184,25 @@ pub enum TranscriptType {
    EVM,
 }

+impl std::fmt::Display for TranscriptType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                TranscriptType::Poseidon => "poseidon",
+                TranscriptType::EVM => "evm",
+            }
+        )
+    }
+}
+
+impl ToFlags for TranscriptType {
+    fn to_flags(&self) -> Vec<String> {
+        vec![format!("{}", self)]
+    }
+}
+
 #[cfg(feature = "python-bindings")]
 impl ToPyObject for TranscriptType {
    fn to_object(&self, py: Python) -> PyObject {
@@ -183,8 +216,8 @@ impl ToPyObject for TranscriptType {
 #[cfg(feature = "python-bindings")]
 ///
 pub fn g1affine_to_pydict(g1affine_dict: &PyDict, g1affine: &G1Affine) {
-    let g1affine_x = field_to_string_montgomery(&g1affine.x);
-    let g1affine_y = field_to_string_montgomery(&g1affine.y);
+    let g1affine_x = field_to_string(&g1affine.x);
+    let g1affine_y = field_to_string(&g1affine.y);
    g1affine_dict.set_item("x", g1affine_x).unwrap();
    g1affine_dict.set_item("y", g1affine_y).unwrap();
 }
@@ -194,23 +227,23 @@ use halo2curves::bn256::G1;
 #[cfg(feature = "python-bindings")]
 ///
 pub fn g1_to_pydict(g1_dict: &PyDict, g1: &G1) {
-    let g1_x = field_to_string_montgomery(&g1.x);
-    let g1_y = field_to_string_montgomery(&g1.y);
-    let g1_z = field_to_string_montgomery(&g1.z);
+    let g1_x = field_to_string(&g1.x);
+    let g1_y = field_to_string(&g1.y);
+    let g1_z = field_to_string(&g1.z);
    g1_dict.set_item("x", g1_x).unwrap();
    g1_dict.set_item("y", g1_y).unwrap();
    g1_dict.set_item("z", g1_z).unwrap();
 }

-/// converts fp into `Vec<u64>` in Montgomery form
-pub fn field_to_string_montgomery<F: PrimeField + SerdeObject + Serialize>(fp: &F) -> String {
+/// converts fp into a little endian Hex string
+pub fn field_to_string<F: PrimeField + SerdeObject + Serialize>(fp: &F) -> String {
    let repr = serde_json::to_string(&fp).unwrap();
    let b: String = serde_json::from_str(&repr).unwrap();
    b
 }

-/// converts `Vec<u64>` in Montgomery form into fp
-pub fn string_to_field_montgomery<F: PrimeField + SerdeObject + Serialize + DeserializeOwned>(
+/// converts a little endian Hex string into a field element
+pub fn string_to_field<F: PrimeField + SerdeObject + Serialize + DeserializeOwned>(
    b: &String,
 ) -> F {
    let repr = serde_json::to_string(&b).unwrap();
@@ -275,7 +308,7 @@ where
        let field_elems: Vec<Vec<String>> = self
            .instances
            .iter()
-            .map(|x| x.iter().map(|fp| field_to_string_montgomery(fp)).collect())
+            .map(|x| x.iter().map(|fp| field_to_string(fp)).collect())
            .collect::<Vec<_>>();
        dict.set_item("instances", field_elems).unwrap();
        let hex_proof = hex::encode(&self.proof);
@@ -344,8 +377,10 @@ where
        <C as CurveAffine>::ScalarExt: FromUniformBytes<64>,
    {
        trace!("reading proof");
-        let data = std::fs::read_to_string(proof_path)?;
-        serde_json::from_str(&data).map_err(|e| e.into())
+        let file = std::fs::File::open(proof_path)?;
+        let reader = BufReader::with_capacity(*EZKL_BUF_CAPACITY, file);
+        let proof: Self = serde_json::from_reader(reader)?;
+        Ok(proof)
    }
 }

@@ -697,12 +732,13 @@ where
    let f =
        File::open(path.clone()).map_err(|_| format!("failed to load vk at {}", path.display()))?;
    let mut reader = BufReader::with_capacity(*EZKL_BUF_CAPACITY, f);
-    VerifyingKey::<Scheme::Curve>::read::<_, C>(
+    let vk = VerifyingKey::<Scheme::Curve>::read::<_, C>(
        &mut reader,
-        halo2_proofs::SerdeFormat::RawBytes,
+        serde_format_from_str(&EZKL_KEY_FORMAT),
        params,
-    )
-    .map_err(Box::<dyn Error>::from)
+    )?;
+    info!("done loading verification key ✅");
+    Ok(vk)
 }

 /// Loads a [ProvingKey] at `path`.
@@ -719,18 +755,19 @@ where
    let f =
        File::open(path.clone()).map_err(|_| format!("failed to load pk at {}", path.display()))?;
    let mut reader = BufReader::with_capacity(*EZKL_BUF_CAPACITY, f);
-    ProvingKey::<Scheme::Curve>::read::<_, C>(
+    let pk = ProvingKey::<Scheme::Curve>::read::<_, C>(
        &mut reader,
-        halo2_proofs::SerdeFormat::RawBytes,
+        serde_format_from_str(&EZKL_KEY_FORMAT),
        params,
-    )
-    .map_err(Box::<dyn Error>::from)
+    )?;
+    info!("done loading proving key ✅");
+    Ok(pk)
 }

 /// Saves a [ProvingKey] to `path`.
 pub fn save_pk<Scheme: CommitmentScheme>(
    path: &PathBuf,
-    vk: &ProvingKey<Scheme::Curve>,
+    pk: &ProvingKey<Scheme::Curve>,
 ) -> Result<(), io::Error>
 where
    Scheme::Curve: SerdeObject + CurveAffine,
@@ -739,8 +776,9 @@ where
    info!("saving proving key 💾");
    let f = File::create(path)?;
    let mut writer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, f);
-    vk.write(&mut writer, halo2_proofs::SerdeFormat::RawBytes)?;
+    pk.write(&mut writer, serde_format_from_str(&EZKL_KEY_FORMAT))?;
    writer.flush()?;
+    info!("done saving proving key ✅");
    Ok(())
 }

@@ -756,8 +794,9 @@ where
    info!("saving verification key 💾");
    let f = File::create(path)?;
    let mut writer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, f);
-    vk.write(&mut writer, halo2_proofs::SerdeFormat::RawBytes)?;
+    vk.write(&mut writer, serde_format_from_str(&EZKL_KEY_FORMAT))?;
    writer.flush()?;
+    info!("done saving verification key ✅");
    Ok(())
 }

--- a/src/python.rs
+++ b/src/python.rs
@@ -18,7 +18,6 @@ use crate::pfsys::{
    TranscriptType,
 };
 use crate::RunArgs;
-use ethers::types::H160;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
 use halo2curves::bn256::{Bn256, Fq, Fr, G1Affine, G1};
 use pyo3::exceptions::{PyIOError, PyRuntimeError};
@@ -26,7 +25,6 @@ use pyo3::prelude::*;
 use pyo3::wrap_pyfunction;
 use pyo3_log;
 use snark_verifier::util::arithmetic::PrimeField;
-use std::str::FromStr;
 use std::{fs::File, path::PathBuf};
 use tokio::runtime::Runtime;

@@ -65,9 +63,9 @@ struct PyG1 {
 impl From<G1> for PyG1 {
    fn from(g1: G1) -> Self {
        PyG1 {
-            x: crate::pfsys::field_to_string_montgomery::<Fq>(&g1.x),
-            y: crate::pfsys::field_to_string_montgomery::<Fq>(&g1.y),
-            z: crate::pfsys::field_to_string_montgomery::<Fq>(&g1.z),
+            x: crate::pfsys::field_to_string::<Fq>(&g1.x),
+            y: crate::pfsys::field_to_string::<Fq>(&g1.y),
+            z: crate::pfsys::field_to_string::<Fq>(&g1.z),
        }
    }
 }
@@ -75,9 +73,9 @@ impl From<G1> for PyG1 {
 impl From<PyG1> for G1 {
    fn from(val: PyG1) -> Self {
        G1 {
-            x: crate::pfsys::string_to_field_montgomery::<Fq>(&val.x),
-            y: crate::pfsys::string_to_field_montgomery::<Fq>(&val.y),
-            z: crate::pfsys::string_to_field_montgomery::<Fq>(&val.z),
+            x: crate::pfsys::string_to_field::<Fq>(&val.x),
+            y: crate::pfsys::string_to_field::<Fq>(&val.y),
+            z: crate::pfsys::string_to_field::<Fq>(&val.z),
        }
    }
 }
@@ -108,8 +106,8 @@ pub struct PyG1Affine {
 impl From<G1Affine> for PyG1Affine {
    fn from(g1: G1Affine) -> Self {
        PyG1Affine {
-            x: crate::pfsys::field_to_string_montgomery::<Fq>(&g1.x),
-            y: crate::pfsys::field_to_string_montgomery::<Fq>(&g1.y),
+            x: crate::pfsys::field_to_string::<Fq>(&g1.x),
+            y: crate::pfsys::field_to_string::<Fq>(&g1.y),
        }
    }
 }
@@ -117,8 +115,8 @@ impl From<G1Affine> for PyG1Affine {
 impl From<PyG1Affine> for G1Affine {
    fn from(val: PyG1Affine) -> Self {
        G1Affine {
-            x: crate::pfsys::string_to_field_montgomery::<Fq>(&val.x),
-            y: crate::pfsys::string_to_field_montgomery::<Fq>(&val.y),
+            x: crate::pfsys::string_to_field::<Fq>(&val.x),
+            y: crate::pfsys::string_to_field::<Fq>(&val.y),
        }
    }
 }
@@ -219,53 +217,51 @@ impl Into<PyRunArgs> for RunArgs {
    }
 }

-/// Converts 4 u64s to a field element
+/// Converts a felt to big endian
 #[pyfunction(signature = (
-    array,
+    felt,
 ))]
-fn string_to_felt(array: PyFelt) -> PyResult<String> {
-    Ok(format!(
-        "{:?}",
-        crate::pfsys::string_to_field_montgomery::<Fr>(&array)
-    ))
+fn felt_to_big_endian(felt: PyFelt) -> PyResult<String> {
+    let felt = crate::pfsys::string_to_field::<Fr>(&felt);
+    Ok(format!("{:?}", felt))
 }

-/// Converts 4 u64s representing a field element directly to an integer
+/// Converts a field element hex string to an integer
 #[pyfunction(signature = (
    array,
 ))]
-fn string_to_int(array: PyFelt) -> PyResult<i128> {
-    let felt = crate::pfsys::string_to_field_montgomery::<Fr>(&array);
+fn felt_to_int(array: PyFelt) -> PyResult<i128> {
+    let felt = crate::pfsys::string_to_field::<Fr>(&array);
    let int_rep = felt_to_i128(felt);
    Ok(int_rep)
 }

-/// Converts 4 u64s representing a field element directly to a (rescaled from fixed point scaling) floating point
+/// Converts a field eleement hex string to a floating point number
 #[pyfunction(signature = (
    array,
    scale
 ))]
-fn string_to_float(array: PyFelt, scale: crate::Scale) -> PyResult<f64> {
-    let felt = crate::pfsys::string_to_field_montgomery::<Fr>(&array);
+fn felt_to_float(array: PyFelt, scale: crate::Scale) -> PyResult<f64> {
+    let felt = crate::pfsys::string_to_field::<Fr>(&array);
    let int_rep = felt_to_i128(felt);
    let multiplier = scale_to_multiplier(scale);
    let float_rep = int_rep as f64 / multiplier;
    Ok(float_rep)
 }

-/// Converts a floating point element to 4 u64s representing a fixed point field element
+/// Converts a floating point element to a field element hex string
 #[pyfunction(signature = (
 input,
 scale
 ))]
-fn float_to_string(input: f64, scale: crate::Scale) -> PyResult<PyFelt> {
+fn float_to_felt(input: f64, scale: crate::Scale) -> PyResult<PyFelt> {
    let int_rep = quantize_float(&input, 0.0, scale)
        .map_err(|_| PyIOError::new_err("Failed to quantize input"))?;
    let felt = i128_to_felt(int_rep);
-    Ok(crate::pfsys::field_to_string_montgomery::<Fr>(&felt))
+    Ok(crate::pfsys::field_to_string::<Fr>(&felt))
 }

-/// Converts a buffer to vector of 4 u64s representing a fixed point field element
+/// Converts a buffer to vector of field elements
 #[pyfunction(signature = (
    buffer
    ))]
@@ -318,7 +314,10 @@ fn buffer_to_felts(buffer: Vec<u8>) -> PyResult<Vec<String>> {
        .map(|x| PrimeField::from_u128(u8_array_to_u128_le(*x)))
        .collect();

-    let field_elements: Vec<String> = field_elements.iter().map(|x| format!("{:?}", x)).collect();
+    let field_elements: Vec<String> = field_elements
+        .iter()
+        .map(|x| crate::pfsys::field_to_string::<Fr>(x))
+        .collect();

    Ok(field_elements)
 }
@@ -330,7 +329,7 @@ fn buffer_to_felts(buffer: Vec<u8>) -> PyResult<Vec<String>> {
 fn poseidon_hash(message: Vec<PyFelt>) -> PyResult<Vec<PyFelt>> {
    let message: Vec<Fr> = message
        .iter()
-        .map(crate::pfsys::string_to_field_montgomery::<Fr>)
+        .map(crate::pfsys::string_to_field::<Fr>)
        .collect::<Vec<_>>();

    let output =
@@ -341,7 +340,7 @@ fn poseidon_hash(message: Vec<PyFelt>) -> PyResult<Vec<PyFelt>> {

    let hash = output[0]
        .iter()
-        .map(crate::pfsys::field_to_string_montgomery::<Fr>)
+        .map(crate::pfsys::field_to_string::<Fr>)
        .collect::<Vec<_>>();
    Ok(hash)
 }
@@ -361,7 +360,7 @@ fn kzg_commit(
 ) -> PyResult<Vec<PyG1Affine>> {
    let message: Vec<Fr> = message
        .iter()
-        .map(crate::pfsys::string_to_field_montgomery::<Fr>)
+        .map(crate::pfsys::string_to_field::<Fr>)
        .collect::<Vec<_>>();

    let settings = GraphSettings::load(&settings_path)
@@ -525,7 +524,7 @@ fn gen_settings(
    scales = None,
    scale_rebase_multiplier = DEFAULT_SCALE_REBASE_MULTIPLIERS.split(",").map(|x| x.parse().unwrap()).collect(),
    max_logrows = None,
-    div_rebasing = None,
+    only_range_check_rebase = DEFAULT_ONLY_RANGE_CHECK_REBASE.parse().unwrap(),
 ))]
 fn calibrate_settings(
    data: PathBuf,
@@ -536,7 +535,7 @@ fn calibrate_settings(
    scales: Option<Vec<crate::Scale>>,
    scale_rebase_multiplier: Vec<u32>,
    max_logrows: Option<u32>,
-    div_rebasing: Option<bool>,
+    only_range_check_rebase: bool,
 ) -> Result<bool, PyErr> {
    crate::execute::calibrate(
        model,
@@ -546,7 +545,7 @@ fn calibrate_settings(
        lookup_safety_margin,
        scales,
        scale_rebase_multiplier,
-        div_rebasing,
+        only_range_check_rebase,
        max_logrows,
    )
    .map_err(|e| {
@@ -689,14 +688,14 @@ fn prove(
    settings_path=PathBuf::from(DEFAULT_SETTINGS),
    vk_path=PathBuf::from(DEFAULT_VK),
    srs_path=None,
-    non_reduced_srs=Some(DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION.parse::<bool>().unwrap()),
+    non_reduced_srs=DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION.parse::<bool>().unwrap(),
 ))]
 fn verify(
    proof_path: PathBuf,
    settings_path: PathBuf,
    vk_path: PathBuf,
    srs_path: Option<PathBuf>,
-    non_reduced_srs: Option<bool>,
+    non_reduced_srs: bool,
 ) -> Result<bool, PyErr> {
    crate::execute::verify(
        proof_path,
@@ -1031,24 +1030,15 @@ fn verify_evm(
    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);
-        PyRuntimeError::new_err(err_str)
-    })?;
+    let addr_verifier = H160Flag::from(addr_verifier);
    let addr_da = if let Some(addr_da) = addr_da {
-        let addr_da = H160::from_str(addr_da).map_err(|e| {
-            let err_str = format!("address is invalid: {}", e);
-            PyRuntimeError::new_err(err_str)
-        })?;
+        let addr_da = H160Flag::from(addr_da);
        Some(addr_da)
    } 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)
-        })?;
+        let addr_vk = H160Flag::from(addr_vk);
        Some(addr_vk)
    } else {
        None
@@ -1114,13 +1104,13 @@ fn ezkl(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
    m.add_class::<PyG1Affine>()?;
    m.add_class::<PyG1>()?;
    m.add_class::<PyTestDataSource>()?;
-    m.add_function(wrap_pyfunction!(string_to_felt, m)?)?;
-    m.add_function(wrap_pyfunction!(string_to_int, m)?)?;
-    m.add_function(wrap_pyfunction!(string_to_float, m)?)?;
+    m.add_function(wrap_pyfunction!(felt_to_big_endian, m)?)?;
+    m.add_function(wrap_pyfunction!(felt_to_int, m)?)?;
+    m.add_function(wrap_pyfunction!(felt_to_float, m)?)?;
    m.add_function(wrap_pyfunction!(kzg_commit, m)?)?;
    m.add_function(wrap_pyfunction!(swap_proof_commitments, m)?)?;
    m.add_function(wrap_pyfunction!(poseidon_hash, m)?)?;
-    m.add_function(wrap_pyfunction!(float_to_string, m)?)?;
+    m.add_function(wrap_pyfunction!(float_to_felt, m)?)?;
    m.add_function(wrap_pyfunction!(buffer_to_felts, m)?)?;
    m.add_function(wrap_pyfunction!(gen_vk_from_pk_aggr, m)?)?;
    m.add_function(wrap_pyfunction!(gen_vk_from_pk_single, m)?)?;
--- a/src/tensor/val.rs
+++ b/src/tensor/val.rs
@@ -672,7 +672,7 @@ impl<F: PrimeField + TensorType + PartialOrd> ValTensor<F> {
                }
                Ok(indices)
            }
-            ValTensor::Instance { .. } => Err(TensorError::WrongMethod),
+            ValTensor::Instance { .. } => Ok(vec![]),
        }
    }

@@ -690,7 +690,7 @@ impl<F: PrimeField + TensorType + PartialOrd> ValTensor<F> {
                }
                Ok(indices)
            }
-            ValTensor::Instance { .. } => Err(TensorError::WrongMethod),
+            ValTensor::Instance { .. } => Ok(vec![]),
        }
    }

@@ -709,7 +709,11 @@ impl<F: PrimeField + TensorType + PartialOrd> ValTensor<F> {
                *d = v.dims().to_vec();
            }
            ValTensor::Instance { .. } => {
-                return Err(TensorError::WrongMethod);
+                if indices.is_empty() {
+                    return Ok(());
+                } else {
+                    return Err(TensorError::WrongMethod);
+                }
            }
        }
        Ok(())
--- a/src/tensor/var.rs
+++ b/src/tensor/var.rs
@@ -33,10 +33,7 @@ pub enum VarTensor {
 impl VarTensor {
    ///
    pub fn is_advice(&self) -> bool {
-        match self {
-            VarTensor::Advice { .. } => true,
-            _ => false,
-        }
+        matches!(self, VarTensor::Advice { .. })
    }

    ///
--- a/src/wasm.rs
+++ b/src/wasm.rs
@@ -69,19 +69,19 @@ pub fn encodeVerifierCalldata(
    Ok(encoded)
 }

-/// Converts 4 u64s to a field element
+/// Converts a hex string to a byte array
 #[wasm_bindgen]
 #[allow(non_snake_case)]
-pub fn stringToFelt(array: wasm_bindgen::Clamped<Vec<u8>>) -> Result<String, JsError> {
+pub fn feltToBigEndian(array: wasm_bindgen::Clamped<Vec<u8>>) -> Result<String, JsError> {
    let felt: Fr = serde_json::from_slice(&array[..])
        .map_err(|e| JsError::new(&format!("Failed to deserialize field element: {}", e)))?;
    Ok(format!("{:?}", felt))
 }

-/// Converts 4 u64s representing a field element directly to an integer
+/// Converts a hex string to a byte array
 #[wasm_bindgen]
 #[allow(non_snake_case)]
-pub fn stringToInt(
+pub fn feltToInt(
    array: wasm_bindgen::Clamped<Vec<u8>>,
 ) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
    let felt: Fr = serde_json::from_slice(&array[..])
@@ -92,10 +92,10 @@ pub fn stringToInt(
    ))
 }

-/// Converts 4 u64s representing a field element directly to a (rescaled from fixed point scaling) floating point
+/// Converts felts to a floating point element
 #[wasm_bindgen]
 #[allow(non_snake_case)]
-pub fn stringToFloat(
+pub fn feltToFloat(
    array: wasm_bindgen::Clamped<Vec<u8>>,
    scale: crate::Scale,
 ) -> Result<f64, JsError> {
@@ -106,26 +106,26 @@ pub fn stringToFloat(
    Ok(int_rep as f64 / multiplier)
 }

-/// Converts a floating point element to 4 u64s representing a fixed point field element
+/// Converts a floating point number to a hex string representing a fixed point field element
 #[wasm_bindgen]
 #[allow(non_snake_case)]
-pub fn floatTostring(
+pub fn floatToFelt(
    input: f64,
    scale: crate::Scale,
 ) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
    let int_rep =
        quantize_float(&input, 0.0, scale).map_err(|e| JsError::new(&format!("{}", e)))?;
    let felt = i128_to_felt(int_rep);
-    let vec = crate::pfsys::field_to_string_montgomery::<halo2curves::bn256::Fr>(&felt);
+    let vec = crate::pfsys::field_to_string::<halo2curves::bn256::Fr>(&felt);
    Ok(wasm_bindgen::Clamped(serde_json::to_vec(&vec).map_err(
-        |e| JsError::new(&format!("Failed to serialize string_montgomery{}", e)),
+        |e| JsError::new(&format!("Failed to serialize a float to felt{}", e)),
    )?))
 }

 /// Converts a buffer to vector of 4 u64s representing a fixed point field element
 #[wasm_bindgen]
 #[allow(non_snake_case)]
-pub fn bufferToVecOfstring(
+pub fn bufferToVecOfFelt(
    buffer: wasm_bindgen::Clamped<Vec<u8>>,
 ) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
    // Convert the buffer to a slice
--- a/tests/integration_tests.rs
+++ b/tests/integration_tests.rs
@@ -2,6 +2,7 @@
 #[cfg(test)]
 mod native_tests {

+    use ezkl::fieldutils::{felt_to_i128, i128_to_felt};
    // use ezkl::circuit::table::RESERVED_BLINDING_ROWS_PAD;
    use ezkl::graph::input::{FileSource, FileSourceInner, GraphData};
    use ezkl::graph::{DataSource, GraphSettings, GraphWitness};
@@ -477,6 +478,7 @@ mod native_tests {
            use crate::native_tests::kzg_fuzz;
            use crate::native_tests::render_circuit;
            use crate::native_tests::model_serialization_different_binaries;
+            use rand::Rng;
            use tempdir::TempDir;

            #[test]
@@ -496,7 +498,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "public", "fixed", "public", 1, "accuracy", None);
+                mock(path, test.to_string(), "public", "fixed", "public", 1, "accuracy", None, 0.0);
                test_dir.close().unwrap();
            }
        });
@@ -569,7 +571,18 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None);
+                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None, 0.0);
+                test_dir.close().unwrap();
+            }
+
+            #(#[test_case(TESTS[N])])*
+            fn mock_tolerance_public_outputs_(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);
+                // gen random number between 0.0 and 1.0
+                let tolerance = rand::thread_rng().gen_range(0.0..1.0) * 100.0;
+                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None, tolerance);
                test_dir.close().unwrap();
            }

@@ -580,7 +593,7 @@ mod native_tests {
                let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                let large_batch_dir = &format!("large_batches_{}", test);
                crate::native_tests::mk_data_batches_(path, test, &large_batch_dir, 10);
-                mock(path, large_batch_dir.to_string(), "private", "private", "public", 10, "resources", None);
+                mock(path, large_batch_dir.to_string(), "private", "private", "public", 10, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -589,7 +602,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "public", "private", "private", 1, "resources", None);
+                mock(path, test.to_string(), "public", "private", "private", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -598,7 +611,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "fixed", "private", "private", 1, "resources", None);
+                mock(path, test.to_string(), "fixed", "private", "private", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -607,7 +620,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "private", "private", "fixed", 1, "resources", None);
+                mock(path, test.to_string(), "private", "private", "fixed", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -616,7 +629,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "private", "fixed", "private", 1, "resources", None);
+                mock(path, test.to_string(), "private", "fixed", "private", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -625,7 +638,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "hashed", "private", "public", 1, "resources", None);
+                mock(path, test.to_string(), "hashed", "private", "public", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -634,7 +647,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "kzgcommit", "private", "public", 1, "resources", None);
+                mock(path, test.to_string(), "kzgcommit", "private", "public", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -644,7 +657,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "private", "hashed", "public", 1, "resources", None);
+                mock(path, test.to_string(), "private", "hashed", "public", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -654,7 +667,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "private", "kzgcommit", "public", 1, "resources", None);
+                mock(path, test.to_string(), "private", "kzgcommit", "public", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -663,7 +676,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "public", "private", "hashed", 1, "resources", None);
+                mock(path, test.to_string(), "public", "private", "hashed", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -673,7 +686,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "public", "private", "kzgcommit", 1, "resources", None);
+                mock(path, test.to_string(), "public", "private", "kzgcommit", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -682,7 +695,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "public", "fixed", "hashed", 1, "resources", None);
+                mock(path, test.to_string(), "public", "fixed", "hashed", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -692,7 +705,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "public", "kzgcommit", "hashed", 1, "resources", None);
+                mock(path, test.to_string(), "public", "kzgcommit", "hashed", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -702,7 +715,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "kzgcommit", "kzgcommit", "kzgcommit", 1, "resources", None);
+                mock(path, test.to_string(), "kzgcommit", "kzgcommit", "kzgcommit", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -712,7 +725,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "hashed", "private", "hashed", 1, "resources", None);
+                mock(path, test.to_string(), "hashed", "private", "hashed", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -722,7 +735,7 @@ mod native_tests {
                let test_dir = TempDir::new(test).unwrap();
                let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                // needs an extra row for the large model
-                mock(path, test.to_string(),"hashed", "hashed", "public", 1, "resources", None);
+                mock(path, test.to_string(),"hashed", "hashed", "public", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -732,7 +745,7 @@ mod native_tests {
                let test_dir = TempDir::new(test).unwrap();
                let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                // needs an extra row for the large model
-                mock(path, test.to_string(),"hashed", "hashed", "hashed", 1, "resources", None);
+                mock(path, test.to_string(),"hashed", "hashed", "hashed", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }

@@ -876,7 +889,7 @@ mod native_tests {
                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);
-                mock(path, test.to_string(), "private", "fixed", "public", 1, "resources", None);
+                mock(path, test.to_string(), "private", "fixed", "public", 1, "resources", None, 0.0);
                test_dir.close().unwrap();
            }
        });
@@ -1273,6 +1286,7 @@ mod native_tests {
        batch_size: usize,
        cal_target: &str,
        scales_to_use: Option<Vec<u32>>,
+        tolerance: f32,
    ) {
        gen_circuit_settings_and_witness(
            test_dir,
@@ -1285,19 +1299,137 @@ mod native_tests {
            scales_to_use,
            2,
            false,
+            tolerance,
        );

-        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
-            .args([
-                "mock",
-                "-W",
-                format!("{}/{}/witness.json", test_dir, example_name).as_str(),
-                "-M",
-                format!("{}/{}/network.compiled", test_dir, example_name).as_str(),
-            ])
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
+        let settings =
+            GraphSettings::load(&format!("{}/{}/settings.json", test_dir, example_name).into())
+                .unwrap();
+
+        let any_output_scales_smol = settings.model_output_scales.iter().any(|s| *s <= 0);
+
+        if tolerance > 0.0 && !any_output_scales_smol {
+            // load witness and shift the output by a small amount that is less than tolerance percent
+            let witness = GraphWitness::from_path(
+                format!("{}/{}/witness.json", test_dir, example_name).into(),
+            )
+            .unwrap();
+            let witness = witness.clone();
+            let outputs = witness.outputs.clone();
+
+            // get values as i128
+            let output_perturbed_safe: Vec<Vec<halo2curves::bn256::Fr>> = outputs
+                .iter()
+                .map(|sv| {
+                    sv.iter()
+                        .map(|v| {
+                            // randomly perturb by a small amount less than tolerance
+                            let perturbation = if v == &halo2curves::bn256::Fr::zero() {
+                                halo2curves::bn256::Fr::zero()
+                            } else {
+                                i128_to_felt(
+                                    (felt_to_i128(*v) as f32
+                                        * (rand::thread_rng().gen_range(-0.01..0.01) * tolerance))
+                                        as i128,
+                                )
+                            };
+                            
+                            *v + perturbation
+                        })
+                        .collect::<Vec<_>>()
+                })
+                .collect::<Vec<_>>();
+
+            // get values as i128
+            let output_perturbed_bad: Vec<Vec<halo2curves::bn256::Fr>> = outputs
+                .iter()
+                .map(|sv| {
+                    sv.iter()
+                        .map(|v| {
+                            // randomly perturb by a small amount less than tolerance
+                            let perturbation = if v == &halo2curves::bn256::Fr::zero() {
+                                halo2curves::bn256::Fr::from(2)
+                            } else {
+                                i128_to_felt(
+                                    (felt_to_i128(*v) as f32
+                                        * (rand::thread_rng().gen_range(0.02..0.1) * tolerance))
+                                        as i128,
+                                )
+                            };
+                            *v + perturbation
+                        })
+                        .collect::<Vec<_>>()
+                })
+                .collect::<Vec<_>>();
+
+            let good_witness = GraphWitness {
+                outputs: output_perturbed_safe,
+                ..witness.clone()
+            };
+
+            // save
+            good_witness
+                .save(format!("{}/{}/witness_ok.json", test_dir, example_name).into())
+                .unwrap();
+
+            let bad_witness = GraphWitness {
+                outputs: output_perturbed_bad,
+                ..witness.clone()
+            };
+
+            // save
+            bad_witness
+                .save(format!("{}/{}/witness_bad.json", test_dir, example_name).into())
+                .unwrap();
+
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                .args([
+                    "mock",
+                    "-W",
+                    format!("{}/{}/witness.json", test_dir, example_name).as_str(),
+                    "-M",
+                    format!("{}/{}/network.compiled", test_dir, example_name).as_str(),
+                ])
+                .status()
+                .expect("failed to execute process");
+            assert!(status.success());
+
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                .args([
+                    "mock",
+                    "-W",
+                    format!("{}/{}/witness_ok.json", test_dir, example_name).as_str(),
+                    "-M",
+                    format!("{}/{}/network.compiled", test_dir, example_name).as_str(),
+                ])
+                .status()
+                .expect("failed to execute process");
+            assert!(status.success());
+
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                .args([
+                    "mock",
+                    "-W",
+                    format!("{}/{}/witness_bad.json", test_dir, example_name).as_str(),
+                    "-M",
+                    format!("{}/{}/network.compiled", test_dir, example_name).as_str(),
+                ])
+                .status()
+                .expect("failed to execute process");
+            assert!(!status.success());
+        } else {
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                .args([
+                    "mock",
+                    "-W",
+                    format!("{}/{}/witness.json", test_dir, example_name).as_str(),
+                    "-M",
+                    format!("{}/{}/network.compiled", test_dir, example_name).as_str(),
+                ])
+                .status()
+                .expect("failed to execute process");
+            assert!(status.success());
+        }
    }

    #[allow(clippy::too_many_arguments)]
@@ -1312,6 +1444,7 @@ mod native_tests {
        scales_to_use: Option<Vec<u32>>,
        num_inner_columns: usize,
        div_rebasing: bool,
+        tolerance: f32,
    ) {
        let mut args = vec![
            "gen-settings".to_string(),
@@ -1321,11 +1454,12 @@ mod native_tests {
                "--settings-path={}/{}/settings.json",
                test_dir, example_name
            ),
-            format!("--variables=batch_size={}", batch_size),
+            format!("--variables=batch_size->{}", batch_size),
            format!("--input-visibility={}", input_visibility),
            format!("--param-visibility={}", param_visibility),
            format!("--output-visibility={}", output_visibility),
            format!("--num-inner-cols={}", num_inner_columns),
+            format!("--tolerance={}", tolerance),
        ];

        if div_rebasing {
@@ -1402,6 +1536,7 @@ mod native_tests {
    }

    // Mock prove (fast, but does not cover some potential issues)
+    #[allow(clippy::too_many_arguments)]
    fn accuracy_measurement(
        test_dir: &str,
        example_name: String,
@@ -1424,6 +1559,7 @@ mod native_tests {
            None,
            2,
            div_rebasing,
+            0.0,
        );

        println!(
@@ -1455,7 +1591,7 @@ mod native_tests {
                format!("{}/{}/network.onnx", test_dir, example_name).as_str(),
                "-O",
                format!("{}/{}/render.png", test_dir, example_name).as_str(),
-                "--lookup-range=(-32768,32768)",
+                "--lookup-range=-32768->32768",
                "-K=17",
            ])
            .status()
@@ -1683,6 +1819,7 @@ mod native_tests {
            scales_to_use,
            num_inner_columns,
            false,
+            0.0,
        );

        let settings_path = format!("{}/{}/settings.json", test_dir, example_name);
@@ -1754,7 +1891,7 @@ mod native_tests {
            .expect("failed to parse settings file");

        // get_srs for the graph_settings_num_instances
-        let _ = download_srs(graph_settings.log2_total_instances());
+        download_srs(graph_settings.log2_total_instances());

        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
            .args([
@@ -1764,7 +1901,7 @@ mod native_tests {
                &format!("{}/{}/proof.pf", test_dir, example_name),
                "--vk-path",
                &format!("{}/{}/key.vk", test_dir, example_name),
-                "--reduced-srs=true",
+                "--reduced-srs",
            ])
            .status()
            .expect("failed to execute process");
@@ -1784,6 +1921,7 @@ mod native_tests {
            None,
            2,
            false,
+            0.0,
        );

        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
@@ -2060,6 +2198,7 @@ mod native_tests {
            Some(vec![4]),
            1,
            false,
+            0.0,
        );

        let model_path = format!("{}/{}/network.compiled", test_dir, example_name);
--- a/tests/output_comparison.py
+++ b/tests/output_comparison.py
@@ -12,7 +12,7 @@ def get_ezkl_output(witness_file, settings_file):
    outputs = witness_output['outputs']
    with open(settings_file) as f:
        settings = json.load(f)
-    ezkl_outputs = [[ezkl.string_to_float(
+    ezkl_outputs = [[ezkl.felt_to_float(
        outputs[i][j], settings['model_output_scales'][i]) for j in range(len(outputs[i]))] for i in range(len(outputs))]
    return ezkl_outputs

--- a/tests/python/binding_tests.py
+++ b/tests/python/binding_tests.py
@@ -56,9 +56,9 @@ def test_poseidon_hash():
    Test for poseidon_hash
    """
    message = [1.0, 2.0, 3.0, 4.0]
-    message = [ezkl.float_to_string(x, 7) for x in message]
+    message = [ezkl.float_to_felt(x, 7) for x in message]
    res = ezkl.poseidon_hash(message)
-    assert ezkl.string_to_felt(
+    assert ezkl.felt_to_big_endian(
        res[0]) == "0x0da7e5e5c8877242fa699f586baf770d731defd54f952d4adeb85047a0e32f45"


@@ -70,14 +70,14 @@ def test_field_serialization():

    input = 890
    scale = 7
-    felt = ezkl.float_to_string(input, scale)
-    roundtrip_input = ezkl.string_to_float(felt, scale)
+    felt = ezkl.float_to_felt(input, scale)
+    roundtrip_input = ezkl.felt_to_float(felt, scale)
    assert input == roundtrip_input

    input = -700
    scale = 7
-    felt = ezkl.float_to_string(input, scale)
-    roundtrip_input = ezkl.string_to_float(felt, scale)
+    felt = ezkl.float_to_felt(input, scale)
+    roundtrip_input = ezkl.felt_to_float(felt, scale)
    assert input == roundtrip_input


@@ -88,12 +88,12 @@ def test_buffer_to_felts():
    buffer = bytearray("a sample string!", 'utf-8')
    felts = ezkl.buffer_to_felts(buffer)
    ref_felt_1 = "0x0000000000000000000000000000000021676e6972747320656c706d61732061"
-    assert felts == [ref_felt_1]
+    assert ezkl.felt_to_big_endian(felts[0]) == ref_felt_1

    buffer = bytearray("a sample string!"+"high", 'utf-8')
    felts = ezkl.buffer_to_felts(buffer)
    ref_felt_2 = "0x0000000000000000000000000000000000000000000000000000000068676968"
-    assert felts == [ref_felt_1, ref_felt_2]
+    assert [ezkl.felt_to_big_endian(felts[0]),  ezkl.felt_to_big_endian(felts[1])] == [ref_felt_1, ref_felt_2]


 def test_gen_srs():
--- a/tests/wasm.rs
+++ b/tests/wasm.rs
@@ -8,9 +8,9 @@ mod wasm32 {
    use ezkl::graph::GraphWitness;
    use ezkl::pfsys;
    use ezkl::wasm::{
-        bufferToVecOfstring, compiledCircuitValidation, encodeVerifierCalldata, genPk, genVk,
-        genWitness, inputValidation, pkValidation, poseidonHash, proofValidation, prove,
-        settingsValidation, srsValidation, stringToFelt, stringToFloat, stringToInt,
+        bufferToVecOfFelt, compiledCircuitValidation, encodeVerifierCalldata, feltToBigEndian,
+        feltToFloat, feltToInt, genPk, genVk, genWitness, inputValidation, pkValidation,
+        poseidonHash, proofValidation, prove, settingsValidation, srsValidation,
        u8_array_to_u128_le, verify, vkValidation, witnessValidation,
    };
    use halo2_solidity_verifier::encode_calldata;
@@ -76,21 +76,21 @@ mod wasm32 {
        for i in 0..32 {
            let field_element = Fr::from(i);
            let serialized = serde_json::to_vec(&field_element).unwrap();
+
            let clamped = wasm_bindgen::Clamped(serialized);
            let scale = 2;
-            let floating_point = stringToFloat(clamped.clone(), scale)
+            let floating_point = feltToFloat(clamped.clone(), scale)
                .map_err(|_| "failed")
                .unwrap();
            assert_eq!(floating_point, (i as f64) / 4.0);

-            let integer: i128 = serde_json::from_slice(
-                &stringToInt(clamped.clone()).map_err(|_| "failed").unwrap(),
-            )
-            .unwrap();
+            let integer: i128 =
+                serde_json::from_slice(&feltToInt(clamped.clone()).map_err(|_| "failed").unwrap())
+                    .unwrap();
            assert_eq!(integer, i as i128);

            let hex_string = format!("{:?}", field_element);
-            let returned_string = stringToFelt(clamped).map_err(|_| "failed").unwrap();
+            let returned_string: String = feltToBigEndian(clamped).map_err(|_| "failed").unwrap();
            assert_eq!(hex_string, returned_string);
        }
    }
@@ -101,7 +101,7 @@ mod wasm32 {
        let mut buffer = string_high.clone().into_bytes();
        let clamped = wasm_bindgen::Clamped(buffer.clone());

-        let field_elements_ser = bufferToVecOfstring(clamped).map_err(|_| "failed").unwrap();
+        let field_elements_ser = bufferToVecOfFelt(clamped).map_err(|_| "failed").unwrap();

        let field_elements: Vec<Fr> = serde_json::from_slice(&field_elements_ser[..]).unwrap();

@@ -118,7 +118,7 @@ mod wasm32 {
        let buffer = string_sample.clone().into_bytes();
        let clamped = wasm_bindgen::Clamped(buffer.clone());

-        let field_elements_ser = bufferToVecOfstring(clamped).map_err(|_| "failed").unwrap();
+        let field_elements_ser = bufferToVecOfFelt(clamped).map_err(|_| "failed").unwrap();

        let field_elements: Vec<Fr> = serde_json::from_slice(&field_elements_ser[..]).unwrap();

@@ -133,7 +133,7 @@ mod wasm32 {
        let buffer = string_concat.into_bytes();
        let clamped = wasm_bindgen::Clamped(buffer.clone());

-        let field_elements_ser = bufferToVecOfstring(clamped).map_err(|_| "failed").unwrap();
+        let field_elements_ser = bufferToVecOfFelt(clamped).map_err(|_| "failed").unwrap();

        let field_elements: Vec<Fr> = serde_json::from_slice(&field_elements_ser[..]).unwrap();

--- a/tests/wasm/model.compiled
+++ b/tests/wasm/model.compiled
--- a/tests/wasm/witness.json
+++ b/tests/wasm/witness.json
@@ -1 +1 @@
-{"inputs":[["0200000000000000000000000000000000000000000000000000000000000000","0100000000000000000000000000000000000000000000000000000000000000","0100000000000000000000000000000000000000000000000000000000000000"]],"pretty_elements":{"rescaled_inputs":[["2","1","1"]],"inputs":[["0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000001"]],"processed_inputs":[],"processed_params":[],"processed_outputs":[],"rescaled_outputs":[["0","0","0","0"]],"outputs":[["0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000"]]},"outputs":[["0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000"]],"processed_inputs":null,"processed_params":null,"processed_outputs":null,"max_lookup_inputs":0,"min_lookup_inputs":-1}
+{"inputs":[["0200000000000000000000000000000000000000000000000000000000000000","0100000000000000000000000000000000000000000000000000000000000000","0100000000000000000000000000000000000000000000000000000000000000"]],"pretty_elements":{"rescaled_inputs":[["2","1","1"]],"inputs":[["0x0000000000000000000000000000000000000000000000000000000000000002","0x0000000000000000000000000000000000000000000000000000000000000001","0x0000000000000000000000000000000000000000000000000000000000000001"]],"processed_inputs":[],"processed_params":[],"processed_outputs":[],"rescaled_outputs":[["0","0","0","0"]],"outputs":[["0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000","0x0000000000000000000000000000000000000000000000000000000000000000"]]},"outputs":[["0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000","0000000000000000000000000000000000000000000000000000000000000000"]],"processed_inputs":null,"processed_params":null,"processed_outputs":null,"max_lookup_inputs":0,"min_lookup_inputs":-1,"max_range_check":0,"min_range_check":0}
Author	SHA1	Message	Date
dante	1656846d1a	fix: transcript should serialize as lc flag (#726 )	2024-02-26 22:02:47 +00:00
dante	88098b8190	fix!: cleanup felt serialization language in python and wasm (#724 ) BREAKING CHANGE: python and wasm felt utilities have new names	2024-02-25 14:06:48 +00:00
dante	6c0c17c9be	fix: include tol check in fwd pass (#723 )	2024-02-23 01:28:59 +00:00
dante	bf69b16fc1	fix: rm optional bool flags (#722 )	2024-02-21 12:45:42 +00:00
dante	74feb829da	feat: parse command `ast` into flag strings (#720 )	2024-02-21 00:38:26 +00:00
dante	d429e7edab	fix: buffer data read and writes (#719 )	2024-02-19 11:49:15 +00:00
dante	f0e5b82787	refactor: selectable key ser (#718 )	2024-02-19 11:26:18 +00:00
dante	3f7261f50b	fix: set buf capacity for witness, settings, proof (#717 )	2024-02-16 21:59:20 +00:00