ci: update version string in docs

2026-01-13 16:27:59 -05:00 · 2024-04-13 12:08:29 +00:00
135 changed files with 5220 additions and 8992 deletions
--- a/.github/workflows/engine.yml
+++ b/.github/workflows/engine.yml
@@ -22,18 +22,15 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: jetli/wasm-pack-action@v0.4.0
-        with:
-          # Pin to version 0.12.1
-          version: 'v0.12.1'
      - name: Add wasm32-unknown-unknown target
        run: rustup target add wasm32-unknown-unknown

      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
      - name: Install binaryen
        run: |
          set -e
@@ -181,58 +178,3 @@ jobs:
          npm publish
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-
-  in-browser-evm-ver-publish:
-    name: publish-in-browser-evm-verifier-package
-    needs: [publish-wasm-bindings]
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    steps:
-      - uses: actions/checkout@v4
-      - name: Update version in package.json
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          sed -i "s|\"version\": \".*\"|\"version\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
-      - name: Prepare tag and fetch package integrity
-        run: |
-          CLEANED_TAG=${{ github.ref_name }} # Get the tag from ref_name
-          CLEANED_TAG="${CLEANED_TAG#v}" # Remove leading 'v'
-          echo "CLEANED_TAG=${CLEANED_TAG}" >> $GITHUB_ENV # Set it as an environment variable for later steps
-          ENGINE_INTEGRITY=$(npm view @ezkljs/engine@$CLEANED_TAG dist.integrity)
-          echo "ENGINE_INTEGRITY=$ENGINE_INTEGRITY" >> $GITHUB_ENV
-      - name: Update @ezkljs/engine version in package.json
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          sed -i "s|\"@ezkljs/engine\": \".*\"|\"@ezkljs/engine\": \"$CLEANED_TAG\"|" in-browser-evm-verifier/package.json
-      - name: Update the engine import in in-browser-evm-verifier to use @ezkljs/engine package instead of the local one;
-        run: |
-          sed -i "s|import { encodeVerifierCalldata } from '../nodejs/ezkl';|import { encodeVerifierCalldata } from '@ezkljs/engine';|" in-browser-evm-verifier/src/index.ts
-      - name: Update pnpm-lock.yaml versions and integrity
-        run: |
-          awk -v integrity="$ENGINE_INTEGRITY" -v tag="$CLEANED_TAG" '
-          NR==30{$0="    specifier: \"" tag "\""}
-          NR==31{$0="    version: \"" tag "\""}
-          NR==400{$0="  /@ezkljs/engine@" tag ":"}
-          NR==401{$0="    resolution: {integrity: \"" integrity "\"}"} 1' in-browser-evm-verifier/pnpm-lock.yaml > temp.yaml && mv temp.yaml in-browser-evm-verifier/pnpm-lock.yaml  
-      - name: Use pnpm 8
-        uses: pnpm/action-setup@v2
-        with:
-          version: 8
-      - name: Set up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: "18.12.1"
-          registry-url: "https://registry.npmjs.org"
-      - name: Publish to npm
-        run: |
-          cd in-browser-evm-verifier
-          pnpm install --frozen-lockfile
-          pnpm run build
-          pnpm publish --no-git-checks
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}  
--- a/.github/workflows/large-tests.yml
+++ b/.github/workflows/large-tests.yml
@@ -11,7 +11,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - name: nanoGPT Mock
--- a/.github/workflows/pypi.yml
+++ b/.github/workflows/pypi.yml
@@ -40,7 +40,7 @@ jobs:

      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2023-06-27
          override: true
          components: rustfmt, clippy

@@ -50,7 +50,6 @@ jobs:
          target: ${{ matrix.target }}
          args: --release --out dist --features python-bindings
      - name: Install built wheel
-        if: matrix.target == 'universal2-apple-darwin'
        run: |
          pip install ezkl --no-index --find-links dist --force-reinstall
          python -c "import ezkl"
@@ -86,7 +85,7 @@ jobs:

      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2023-06-27
          override: true
          components: rustfmt, clippy

@@ -111,7 +110,7 @@ jobs:
    if: startsWith(github.ref, 'refs/tags/')
    strategy:
      matrix:
-        target: [x86_64]
+        target: [x86_64, i686]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v4
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -45,7 +45,7 @@ jobs:
    steps:
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - name: Checkout repo
@@ -102,32 +102,28 @@ jobs:
      PCRE2_SYS_STATIC: 1
    strategy:
      matrix:
-        build: [windows-msvc, macos, macos-aarch64, linux-musl, linux-gnu, linux-aarch64]
+        build: [windows-msvc, macos, macos-aarch64, linux-musl, linux-gnu]
        include:
          - build: windows-msvc
            os: windows-latest
-            rust: nightly-2024-07-18
+            rust: nightly-2023-06-27
            target: x86_64-pc-windows-msvc
          - build: macos
            os: macos-13
-            rust: nightly-2024-07-18
+            rust: nightly-2023-06-27
            target: x86_64-apple-darwin
          - build: macos-aarch64
            os: macos-13
-            rust: nightly-2024-07-18
+            rust: nightly-2023-06-27
            target: aarch64-apple-darwin
          - build: linux-musl
            os: ubuntu-22.04
-            rust: nightly-2024-07-18
+            rust: nightly-2023-06-27
            target: x86_64-unknown-linux-musl
          - build: linux-gnu
            os: ubuntu-22.04
-            rust: nightly-2024-07-18
+            rust: nightly-2023-06-27
            target: x86_64-unknown-linux-gnu
-          - build: linux-aarch64
-            os: ubuntu-22.04
-            rust: nightly-2024-07-18
-            target: aarch64-unknown-linux-gnu

    steps:
      - name: Checkout repo
@@ -181,16 +177,11 @@ jobs:
          echo "target flag is: ${{ env.TARGET_FLAGS }}"
          echo "target dir is: ${{ env.TARGET_DIR }}"

-      - name: Build release binary (no asm)
-        if: matrix.build != 'linux-gnu'
+      - name: Build release binary
        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry

-      - name: Build release binary (asm)
-        if: matrix.build == 'linux-gnu'
-        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry --features asm
-
      - name: Strip release binary
-        if: matrix.build != 'windows-msvc' && matrix.build != 'linux-aarch64'
+        if: matrix.build != 'windows-msvc'
        run: strip "target/${{ matrix.target }}/release/ezkl"

      - name: Strip release binary (Windows)
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -26,7 +26,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - name: Build
@@ -38,7 +38,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - name: Docs
@@ -50,7 +50,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -73,7 +73,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -92,13 +92,13 @@ jobs:
      # - name: Conv overflow (wasi)
      #   run: cargo wasi test conv_col_ultra_overflow -- --include-ignored --nocapture
      - name: lookup overflow
-        run: cargo nextest run lookup_ultra_overflow --no-capture --features icicle -- --include-ignored
+        run: cargo nextest run  --release lookup_ultra_overflow --no-capture --features icicle -- --include-ignored
      - name: Matmul overflow
        run: RUST_LOG=debug cargo nextest run matmul_col_ultra_overflow --no-capture --features icicle -- --include-ignored
      - name: Conv overflow
        run: RUST_LOG=debug cargo nextest run conv_col_ultra_overflow --no-capture --features icicle -- --include-ignored
      - name: Conv + relu overflow
-        run: cargo nextest run conv_relu_col_ultra_overflow --no-capture --features icicle -- --include-ignored
+        run: cargo nextest run  --release conv_relu_col_ultra_overflow --no-capture --features icicle -- --include-ignored

  ultra-overflow-tests_og-lookup:
    runs-on: non-gpu
@@ -106,7 +106,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -139,7 +139,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -172,7 +172,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -189,20 +189,17 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: jetli/wasm-pack-action@v0.4.0
-        with:
-          # Pin to version 0.12.1
-          version: 'v0.12.1'
      - uses: nanasess/setup-chromedriver@v2
        # with:
        #   chromedriver-version: "115.0.5790.102"
      - name: Install wasm32-unknown-unknown
        run: rustup target add wasm32-unknown-unknown
      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
      - name: Run wasm verifier tests
        # on mac:
        #   AR=/opt/homebrew/opt/llvm/bin/llvm-ar CC=/opt/homebrew/opt/llvm/bin/clang wasm-pack test --firefox --headless -- -Z build-std="panic_abort,std" --features web
@@ -215,7 +212,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -232,15 +229,13 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
        with:
          crate: cargo-nextest
          locked: true
-      # - name: The Worm Mock
-      #   run: cargo nextest run --release --verbose tests::large_mock_::large_tests_5_expects -- --include-ignored
      - 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
@@ -263,8 +258,6 @@ jobs:
        run: cargo nextest run --release --verbose tests::mock_hashed_input_::t  --test-threads 32
      - name: hashed params
        run: cargo nextest run --release --verbose tests::mock_hashed_params_::t  --test-threads 32
-      - name: hashed params public inputs
-        run: cargo nextest run --release --verbose tests::mock_hashed_params_public_inputs_::t  --test-threads 32
      - name: hashed outputs
        run: cargo nextest run --release --verbose tests::mock_hashed_output_::t  --test-threads 32
      - name: hashed inputs + params + outputs
@@ -293,7 +286,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -311,7 +304,7 @@ jobs:
          node-version: "18.12.1"
          cache: "pnpm"
      - name: "Add rust-src"
-        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
      - name: Install dependencies for js tests and in-browser-evm-verifier package
        run: |
          pnpm install --frozen-lockfile
@@ -330,10 +323,10 @@ jobs:
          cd in-browser-evm-verifier
          pnpm build:commonjs
          cd ..
-      # - name: Install solc
-      #   run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
+      - name: Install solc
+        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
      - name: KZG prove and verify tests (EVM + VK rendered seperately)
        run: cargo nextest run --release --verbose tests_evm::kzg_evm_prove_and_verify_render_seperately_ --test-threads 1
      - name: KZG prove and verify tests (EVM + kzg all)
@@ -348,12 +341,6 @@ jobs:
        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_output_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + on chain inputs & outputs)
        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_output_prove_and_verify --test-threads 1
-      - name: KZG prove and verify tests (EVM + on chain inputs & kzg outputs + params)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_kzg_output_kzg_params_prove_and_verify --test-threads 1
-      - name: KZG prove and verify tests (EVM + on chain outputs & kzg inputs + params)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_output_kzg_input_kzg_params_prove_and_verify --test-threads 1
-      - name: KZG prove and verify tests (EVM + on chain all kzg)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_all_kzg_params_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + on chain inputs & outputs hashes)
        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_output_hashed_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM)
@@ -367,23 +354,20 @@ jobs:

  prove-and-verify-tests:
    runs-on: non-gpu
-    needs: [build, library-tests, docs]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: jetli/wasm-pack-action@v0.4.0
-        with:
-          # Pin to version 0.12.1
-          version: 'v0.12.1'
      - name: Add wasm32-unknown-unknown target
        run: rustup target add wasm32-unknown-unknown

      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
      - uses: actions/checkout@v3
      - name: Use pnpm 8
        uses: pnpm/action-setup@v2
@@ -410,18 +394,14 @@ jobs:
      - name: Replace memory definition in nodejs
        run: |
          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" tests/wasm/nodejs/ezkl.js
-      - name: KZG prove and verify tests (public outputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w
-      - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_
-      - name: KZG prove and verify tests (hashed inputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_hashed_inputs_
      - name: KZG prove and verify tests (public outputs)
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_tight_lookup_::t
      - name: IPA prove and verify tests
        run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_::t --test-threads 1
      - name: IPA prove and verify tests (ipa outputs)
        run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_ipa_output
+      - name: KZG prove and verify tests (public outputs + column overflow)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w
      - name: KZG prove and verify tests single inner col
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_single_col
      - name: KZG prove and verify tests triple inner col
@@ -432,6 +412,8 @@ jobs:
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_octuple_col --test-threads 8
      - name: KZG prove and verify tests (kzg outputs)
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output
+      - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_
      - name: KZG prove and verify tests (public outputs)
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t
      - name: KZG prove and verify tests (public inputs)
@@ -441,40 +423,40 @@ jobs:
      - name: KZG prove and verify tests (hashed outputs)
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed

-  # prove-and-verify-tests-gpu:
-  #   runs-on: GPU
-  #   env:
-  #     ENABLE_ICICLE_GPU: true
-  #   steps:
-  #     - uses: actions/checkout@v4
-  #     - uses: actions-rs/toolchain@v1
-  #       with:
-  #         toolchain: nightly-2024-07-18
-  #         override: true
-  #         components: rustfmt, clippy
-  #     - name: Add rust-src
-  #       run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
-  #     - uses: actions/checkout@v3
-  #     - uses: baptiste0928/cargo-install@v1
-  #       with:
-  #         crate: cargo-nextest
-  #         locked: true
-  #     - name: KZG prove and verify tests (kzg outputs)
-  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output --features icicle --test-threads 1
-  #     - name: KZG prove and verify tests (public outputs + column overflow)
-  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w --features icicle  --test-threads 1
-  #     - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
-  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_ --features icicle  --test-threads 1
-  #     - name: KZG prove and verify tests (public outputs)
-  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
-  #     - name: KZG prove and verify tests (public outputs + column overflow)
-  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
-  #     - name: KZG prove and verify tests (public inputs)
-  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input --features icicle  --test-threads 1
-  #     - name: KZG prove and verify tests (fixed params)
-  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params --features icicle  --test-threads 1
-  #     - name: KZG prove and verify tests (hashed outputs)
-  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1
+  prove-and-verify-tests-gpu:
+    runs-on: GPU
+    env:
+      ENABLE_ICICLE_GPU: true
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly-2024-02-06
+          override: true
+          components: rustfmt, clippy
+      - name: Add rust-src
+        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
+      - uses: actions/checkout@v3
+      - uses: baptiste0928/cargo-install@v1
+        with:
+          crate: cargo-nextest
+          locked: true
+      - name: KZG prove and verify tests (kzg outputs)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output --features icicle --test-threads 1
+      - name: KZG prove and verify tests (public outputs + column overflow)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w --features icicle  --test-threads 1
+      - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_ --features icicle  --test-threads 1
+      - name: KZG prove and verify tests (public outputs)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
+      - name: KZG prove and verify tests (public outputs + column overflow)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
+      - name: KZG prove and verify tests (public inputs)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input --features icicle  --test-threads 1
+      - name: KZG prove and verify tests (fixed params)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params --features icicle  --test-threads 1
+      - name: KZG prove and verify tests (hashed outputs)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1

  prove-and-verify-mock-aggr-tests:
    runs-on: self-hosted
@@ -483,7 +465,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -501,7 +483,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -509,7 +491,7 @@ jobs:
          crate: cargo-nextest
          locked: true
      - name: KZG )tests
-        run: cargo nextest run --verbose tests_aggr::kzg_aggr_prove_and_verify_  --features icicle --test-threads 1 -- --include-ignored
+        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --features icicle --test-threads 1 -- --include-ignored

  prove-and-verify-aggr-tests:
    runs-on: large-self-hosted
@@ -518,7 +500,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -535,17 +517,17 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
        with:
          crate: cargo-nextest
          locked: true
-      # - name: Install solc
-      #   run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
+      - name: Install solc
+        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
      - name: KZG prove and verify aggr tests
        run: cargo nextest run  --release --verbose tests_evm::kzg_evm_aggr_prove_and_verify_::t --test-threads 4 -- --include-ignored

@@ -556,13 +538,15 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
        with:
          crate: cargo-nextest
          locked: true
+      - name: Download MNIST
+        run: sh data.sh
      - name: Examples
        run: cargo nextest run --release tests_examples

@@ -576,21 +560,21 @@ jobs:
          python-version: "3.12"
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - name: Install cmake
        run: sudo apt-get install -y cmake
-      # - name: Install solc
-      #   run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
+      - name: Install solc
+        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
      - name: Setup Virtual Env and Install python dependencies
        run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt;
      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
      - name: Build python ezkl
        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
      - name: Run pytest
-        run: source .env/bin/activate; pip install pytest-asyncio; pytest -vv
+        run: source .env/bin/activate; pytest -vv

  accuracy-measurement-tests:
    runs-on: ubuntu-latest-32-cores
@@ -602,7 +586,7 @@ jobs:
          python-version: "3.12"
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -651,17 +635,17 @@ jobs:
          python-version: "3.11"
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
        with:
          crate: cargo-nextest
          locked: true
-      # - name: Install solc
-      #   run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
+      - name: Install solc
+        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
      - name: Install pip
        run: python -m ensurepip --upgrade
      - name: Setup Virtual Env and Install python dependencies
--- a/.github/workflows/verify.yml
+++ b/.github/workflows/verify.yml
@@ -0,0 +1,54 @@
+name: Build and Publish EZKL npm packages (wasm bindings and in-browser evm verifier)
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "The tag to release"
+        required: true
+  push:
+    tags:
+      - "*"
+
+defaults:
+  run:
+    working-directory: .
+jobs:
+  in-browser-evm-ver-publish:
+    name: publish-in-browser-evm-verifier-package
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - uses: actions/checkout@v4
+      - name: Update version in package.json
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          sed -i "s|\"version\": \".*\"|\"version\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
+      - name: Update @ezkljs/engine version in package.json
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          sed -i "s|\"@ezkljs/engine\": \".*\"|\"@ezkljs/engine\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
+      - name: Update the engine import in in-browser-evm-verifier to use @ezkljs/engine package instead of the local one;
+        run: |
+          sed -i "s|import { encodeVerifierCalldata } from '../nodejs/ezkl';|import { encodeVerifierCalldata } from '@ezkljs/engine';|" in-browser-evm-verifier/src/index.ts
+      - name: Use pnpm 8
+        uses: pnpm/action-setup@v2
+        with:
+          version: 8
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "18.12.1"
+          registry-url: "https://registry.npmjs.org"
+      - name: Publish to npm
+        run: |
+          cd in-browser-evm-verifier
+          pnpm install --frozen-lockfile
+          pnpm run build
+          pnpm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 target
 pkg
+data
 *.csv
 !examples/notebooks/eth_price.csv
 *.ipynb_checkpoints
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,10 +16,10 @@ crate-type = ["cdylib", "rlib"]

 [dependencies]
 halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch = "ac/optional-selector-poly" }
-halo2curves = { git = "https://github.com/privacy-scaling-explorations/halo2curves", rev = "b753a832e92d5c86c5c997327a9cf9de86a18851", features = [
-    "derive_serde"
+halo2_proofs = { git = "https://github.com/zkonduit/halo2", branch = "ac/optional-selector-poly" }
+halo2curves = { git = "https://github.com/privacy-scaling-explorations/halo2curves", rev = "9fff22c", features = [
+    "derive_serde",
 ] }
-halo2_proofs = { git = "https://github.com/zkonduit/halo2?branch=ac/cache-lookup-commitments#8b13a0d2a7a34d8daab010dadb2c47dfa47d37d0", package = "halo2_proofs", branch = "ac/cache-lookup-commitments" }
 rand = { version = "0.8", default_features = false }
 itertools = { version = "0.10.3", default_features = false }
 clap = { version = "4.5.3", features = ["derive"] }
@@ -28,62 +28,61 @@ serde_json = { version = "1.0.97", default_features = false, features = [
    "float_roundtrip",
    "raw_value",
 ], optional = true }
-clap_complete = "4.5.2"
 log = { version = "0.4.17", default_features = false, optional = true }
 thiserror = { version = "1.0.38", default_features = false }
 hex = { version = "0.4.3", default_features = false }
 halo2_wrong_ecc = { git = "https://github.com/zkonduit/halo2wrong", branch = "ac/chunked-mv-lookup", package = "ecc" }
-snark-verifier = { git = "https://github.com/zkonduit/snark-verifier", branch = "ac/chunked-mv-lookup",  features = [
+snark-verifier = { git = "https://github.com/zkonduit/snark-verifier", branch = "ac/chunked-mv-lookup", features = [
    "derive_serde",
 ] }
-halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier", branch = "ac/update-h2-curves" }
+halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier", branch = "main" }
 maybe-rayon = { version = "0.1.1", default_features = false }
 bincode = { version = "1.3.3", default_features = false }
+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" }
-semver = "1.0.22"
+

 # evm related deps
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-alloy = { git = "https://github.com/alloy-rs/alloy", version = "0.1.0", rev="5fbf57bac99edef9d8475190109a7ea9fb7e5e83", features = ["provider-http", "signers", "contract", "rpc-types-eth", "signer-wallet", "node-bindings"] }
-foundry-compilers = {version = "0.4.1", features = ["svm-solc"]}
-ethabi = "18"
+ethers = { version = "2.0.11", default_features = false, features = [
+    "ethers-solc",
+] }
 indicatif = { version = "0.17.5", features = ["rayon"] }
 gag = { version = "1.0.0", default_features = false }
 instant = { version = "0.1" }
-reqwest = { version = "0.12.4", default-features = false, features = [
+reqwest = { version = "0.11.14", default-features = false, features = [
    "default-tls",
    "multipart",
    "stream",
 ] }
 openssl = { version = "0.10.55", features = ["vendored"] }
-tokio-postgres = "0.7.10"
+postgres = "0.19.5"
 pg_bigdecimal = "0.1.5"
 lazy_static = "1.4.0"
 colored_json = { version = "3.0.1", default_features = false, optional = true }
+plotters = { version = "0.3.0", default_features = false, optional = true }
 regex = { version = "1", default_features = false }
-tokio = { version = "1.35.0", default_features = false, features = [
+tokio = { version = "1.26.0", default_features = false, features = [
    "macros",
-    "rt-multi-thread",
+    "rt",
 ] }
-pyo3 = { version = "0.21.2", features = [
+tokio-util = { version = "0.7.9", features = ["codec"] }
+pyo3 = { version = "0.20.2", features = [
    "extension-module",
    "abi3-py37",
    "macros",
 ], default_features = false, optional = true }
-pyo3-asyncio = { git = "https://github.com/jopemachine/pyo3-asyncio/", branch="migration-pyo3-0.21", features = [
-  "attributes",
+pyo3-asyncio = { version = "0.20.0", features = [
+    "attributes",
    "tokio-runtime",
 ], default_features = false, optional = true }
-
-pyo3-log = { version = "0.10.0", default_features = false, optional = true }
-tract-onnx = { git = "https://github.com/sonos/tract/", rev = "40c64319291184814d9fea5fdf4fa16f5a4f7116", default_features = false, optional = true }
+pyo3-log = { version = "0.9.0", default_features = false, optional = true }
+tract-onnx = { git = "https://github.com/sonos/tract/", rev = "681a096f02c9d7d363102d9fb0e446d1710ac2c8", default_features = false, optional = true }
 tabled = { version = "0.12.0", optional = true }
-metal = { git = "https://github.com/gfx-rs/metal-rs", optional = true }
-objc = { version = "0.2.4", optional = true }
-mimalloc = "0.1"
+

 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
 colored = { version = "2.0.0", default_features = false, optional = true }
@@ -91,7 +90,6 @@ env_logger = { version = "0.10.0", default_features = false, optional = true }
 chrono = "0.4.31"
 sha256 = "1.4.0"

-
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.2.8", features = ["js"] }
 instant = { version = "0.1", features = ["wasm-bindgen", "inaccurate"] }
@@ -105,10 +103,8 @@ console_error_panic_hook = "0.1.7"
 wasm-bindgen-console-logger = "0.1.1"


-[target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dev-dependencies]
-criterion = { version = "0.5.1", features = ["html_reports"] }
-
 [dev-dependencies]
+criterion = { version = "0.3", features = ["html_reports"] }
 tempfile = "3.3.0"
 lazy_static = "1.4.0"
 mnist = "0.5"
@@ -179,7 +175,7 @@ required-features = ["ezkl"]

 [features]
 web = ["wasm-bindgen-rayon"]
-default = ["ezkl", "mv-lookup", "precompute-coset", "no-banner", "parallel-poly-read"]
+default = ["ezkl", "mv-lookup"]
 onnx = ["dep:tract-onnx"]
 python-bindings = ["pyo3", "pyo3-log", "pyo3-asyncio"]
 ezkl = [
@@ -193,31 +189,23 @@ ezkl = [
    "colored_json",
    "halo2_proofs/circuit-params",
 ]
-parallel-poly-read = ["halo2_proofs/parallel-poly-read"]
 mv-lookup = [
    "halo2_proofs/mv-lookup",
    "snark-verifier/mv-lookup",
    "halo2_solidity_verifier/mv-lookup",
 ]
-asm = ["halo2curves/asm", "halo2_proofs/asm"]
-precompute-coset = ["halo2_proofs/precompute-coset"]
 det-prove = []
 icicle = ["halo2_proofs/icicle_gpu"]
 empty-cmd = []
 no-banner = []
-no-update = []
-

 # icicle patch to 0.1.0 if feature icicle is enabled
 [patch.'https://github.com/ingonyama-zk/icicle']
 icicle = { git = "https://github.com/ingonyama-zk/icicle?rev=45b00fb", package = "icicle", branch = "fix/vhnat/ezkl-build-fix" }

 [patch.'https://github.com/zkonduit/halo2']
-halo2_proofs = { git = "https://github.com/zkonduit/halo2?branch=ac/cache-lookup-commitments#8b13a0d2a7a34d8daab010dadb2c47dfa47d37d0", package = "halo2_proofs", branch = "ac/cache-lookup-commitments" }
+halo2_proofs = { git = "https://github.com/zkonduit/halo2?branch=ac/optional-selector-poly#54f54453cf186aa5d89579c4e7663f9a27cfb89a", package = "halo2_proofs", branch = "ac/optional-selector-poly" }
+

 [profile.release]
 rustflags = ["-C", "relocation-model=pic"]
-lto = "fat"
-codegen-units = 1
-# panic = "abort"
-
--- a/README.md
+++ b/README.md
@@ -91,9 +91,9 @@ You can install the library from source
 cargo install --locked --path .
 ```

-`ezkl` now auto-manages solc installation for you.
-
-
+You will need a functioning installation of `solc` in order to run `ezkl` properly.
+[solc-select](https://github.com/crytic/solc-select) is recommended.
+Follow the instructions on [solc-select](https://github.com/crytic/solc-select) to activate `solc` in your environment.


 #### building python bindings
--- a/abis/QuantizeData.json
+++ b/abis/QuantizeData.json
@@ -20,9 +20,9 @@
 		"name": "quantize_data",
 		"outputs": [
 			{
-				"internalType": "int64[]",
+				"internalType": "int128[]",
 				"name": "quantized_data",
-				"type": "int64[]"
+				"type": "int128[]"
 			}
 		],
 		"stateMutability": "pure",
@@ -31,9 +31,9 @@
 	{
 		"inputs": [
 			{
-				"internalType": "int64[]",
+				"internalType": "int128[]",
 				"name": "quantized_data",
-				"type": "int64[]"
+				"type": "int128[]"
 			}
 		],
 		"name": "to_field_element",
--- a/benches/accum_conv.rs
+++ b/benches/accum_conv.rs
@@ -72,7 +72,6 @@ impl Circuit<Fr> for MyCircuit {
                        Box::new(PolyOp::Conv {
                            padding: vec![(0, 0)],
                            stride: vec![1; 2],
-                            group: 1,
                        }),
                    )
                    .unwrap();
--- a/benches/relu.rs
+++ b/benches/relu.rs
@@ -2,7 +2,6 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::table::Range;
 use ezkl::circuit::{ops::lookup::LookupOp, BaseConfig as Config, CheckMode};
-use ezkl::fieldutils::IntegerRep;
 use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
@@ -85,7 +84,7 @@ fn runrelu(c: &mut Criterion) {
        };

        let input: Tensor<Value<Fr>> =
-            Tensor::<IntegerRep>::from((0..len).map(|_| rng.gen_range(0..10))).into();
+            Tensor::<i32>::from((0..len).map(|_| rng.gen_range(0..10))).into();

        let circuit = NLCircuit {
            input: ValTensor::from(input.clone()),
--- a/contracts/AttestData.sol
+++ b/contracts/AttestData.sol
@@ -1,167 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.20;
-contract LoadInstances {
-    /**
-     * @dev Parse the instances array from the Halo2Verifier encoded calldata.
-     * @notice must pass encoded bytes from memory
-     * @param encoded - verifier calldata
-     */
-    function getInstancesMemory(
-        bytes memory encoded
-    ) internal pure returns (uint256[] memory instances) {
-        bytes4 funcSig;
-        uint256 instances_offset;
-        uint256 instances_length;
-        assembly {
-            // fetch function sig. Either `verifyProof(bytes,uint256[])` or `verifyProof(address,bytes,uint256[])`
-            funcSig := mload(add(encoded, 0x20))
-
-            // Fetch instances offset which is 4 + 32 + 32 bytes away from
-            // start of encoded for `verifyProof(bytes,uint256[])`,
-            // and 4 + 32 + 32 +32 away for `verifyProof(address,bytes,uint256[])`
-
-            instances_offset := mload(
-                add(encoded, add(0x44, mul(0x20, eq(funcSig, 0xaf83a18d))))
-            )
-
-            instances_length := mload(add(add(encoded, 0x24), instances_offset))
-        }
-        instances = new uint256[](instances_length); // Allocate memory for the instances array.
-        assembly {
-            // Now instances points to the start of the array data
-            // (right after the length field).
-            for {
-                let i := 0x20
-            } lt(i, add(mul(instances_length, 0x20), 0x20)) {
-                i := add(i, 0x20)
-            } {
-                mstore(
-                    add(instances, i),
-                    mload(add(add(encoded, add(i, 0x24)), instances_offset))
-                )
-            }
-        }
-    }
-    /**
-     * @dev Parse the instances array from the Halo2Verifier encoded calldata.
-     * @notice must pass encoded bytes from calldata
-     * @param encoded - verifier calldata
-     */
-    function getInstancesCalldata(
-        bytes calldata encoded
-    ) internal pure returns (uint256[] memory instances) {
-        bytes4 funcSig;
-        uint256 instances_offset;
-        uint256 instances_length;
-        assembly {
-            // fetch function sig. Either `verifyProof(bytes,uint256[])` or `verifyProof(address,bytes,uint256[])`
-            funcSig := calldataload(encoded.offset)
-
-            // Fetch instances offset which is 4 + 32 + 32 bytes away from
-            // start of encoded for `verifyProof(bytes,uint256[])`,
-            // and 4 + 32 + 32 +32 away for `verifyProof(address,bytes,uint256[])`
-
-            instances_offset := calldataload(
-                add(
-                    encoded.offset,
-                    add(0x24, mul(0x20, eq(funcSig, 0xaf83a18d)))
-                )
-            )
-
-            instances_length := calldataload(
-                add(add(encoded.offset, 0x04), instances_offset)
-            )
-        }
-        instances = new uint256[](instances_length); // Allocate memory for the instances array.
-        assembly {
-            // Now instances points to the start of the array data
-            // (right after the length field).
-
-            for {
-                let i := 0x20
-            } lt(i, add(mul(instances_length, 0x20), 0x20)) {
-                i := add(i, 0x20)
-            } {
-                mstore(
-                    add(instances, i),
-                    calldataload(
-                        add(add(encoded.offset, add(i, 0x04)), instances_offset)
-                    )
-                )
-            }
-        }
-    }
-}
-
-// The kzg commitments of a given model, all aggregated into a single bytes array.
-// At solidity generation time, the commitments are hardcoded into the contract via the COMMITMENT_KZG constant.
-// It will be used to check that the proof commitments match the expected commitments.
-bytes constant COMMITMENT_KZG = hex"";
-
-contract SwapProofCommitments {
-    /**
-     * @dev Swap the proof commitments
-     * @notice must pass encoded bytes from memory
-     * @param encoded - verifier calldata
-     */
-    function checkKzgCommits(
-        bytes calldata encoded
-    ) internal pure returns (bool equal) {
-        bytes4 funcSig;
-        uint256 proof_offset;
-        uint256 proof_length;
-        assembly {
-            // fetch function sig. Either `verifyProof(bytes,uint256[])` or `verifyProof(address,bytes,uint256[])`
-            funcSig := calldataload(encoded.offset)
-
-            // Fetch proof offset which is 4 + 32 bytes away from
-            // start of encoded for `verifyProof(bytes,uint256[])`,
-            // and 4 + 32 + 32 away for `verifyProof(address,bytes,uint256[])`
-
-            proof_offset := calldataload(
-                add(
-                    encoded.offset,
-                    add(0x04, mul(0x20, eq(funcSig, 0xaf83a18d)))
-                )
-            )
-
-            proof_length := calldataload(
-                add(add(encoded.offset, 0x04), proof_offset)
-            )
-        }
-        // Check the length of the commitment against the proof bytes
-        if (proof_length < COMMITMENT_KZG.length) {
-            return false;
-        }
-
-        // Load COMMITMENT_KZG into memory
-        bytes memory commitment = COMMITMENT_KZG;
-
-        // Compare the first N bytes of the proof with COMMITMENT_KZG
-        uint words = (commitment.length + 31) / 32; // Calculate the number of 32-byte words
-
-        assembly {
-            // Now we compare the commitment with the proof,
-            // ensuring that the commitments divided up into 32 byte words are all equal.
-            for {
-                let i := 0x20
-            } lt(i, add(mul(words, 0x20), 0x20)) {
-                i := add(i, 0x20)
-            } {
-                let wordProof := calldataload(
-                    add(add(encoded.offset, add(i, 0x04)), proof_offset)
-                )
-                let wordCommitment := mload(add(commitment, i))
-                equal := eq(wordProof, wordCommitment)
-                if eq(equal, 0) {
-                    return(0, 0)
-                }
-            }
-        }
-
-        return equal; // Return true if the commitment comparison passed
-    } /// end checkKzgCommits
-}
+import './LoadInstances.sol';

 // This contract serves as a Data Attestation Verifier for the EZKL model.
 // It is designed to read and attest to instances of proofs generated from a specified circuit.
@@ -174,10 +13,9 @@ contract SwapProofCommitments {
 // 4. Field Element Conversion: The fixed-point representation is then converted into a field element modulo P using the `toFieldElement` method.
 // 5. Data Attestation: The `attestData` method validates that the public instances match the data fetched and processed by the contract.
 // 6. Proof Verification: The `verifyWithDataAttestation` method parses the instances out of the encoded calldata and calls the `attestData` method to validate the public instances,
-// 6b. Optional KZG Commitment Verification: It also checks the KZG commitments in the proof against the expected commitments using the `checkKzgCommits` method.
 //  then calls the `verifyProof` method to verify the proof on the verifier.

-contract DataAttestation is LoadInstances, SwapProofCommitments {
+contract DataAttestation is LoadInstances {
    /**
     * @notice Struct used to make view only calls to accounts to fetch the data that EZKL reads from.
     * @param the address of the account to make calls to
@@ -196,14 +34,11 @@ contract DataAttestation is LoadInstances, SwapProofCommitments {
    address public admin;

    /**
-     * @notice EZKL P value
+     * @notice EZKL P value 
     * @dev In order to prevent the verifier from accepting two version of the same pubInput, n and the quantity (n + P),  where n + P <= 2^256, we require that all instances are stricly less than P. a
     * @dev The reason for this is that the assmebly code of the verifier performs all arithmetic operations modulo P and as a consequence can't distinguish between n and n + P.
     */
-    uint256 constant ORDER =
-        uint256(
-            0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
-        );
+    uint256 constant ORDER = uint256(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001); 

    uint256 constant INPUT_CALLS = 0;

@@ -234,7 +69,7 @@ contract DataAttestation is LoadInstances, SwapProofCommitments {

    function updateAdmin(address _admin) external {
        require(msg.sender == admin, "Only admin can update admin");
-        if (_admin == address(0)) {
+        if(_admin == address(0)) {
            revert();
        }
        admin = _admin;
@@ -245,7 +80,7 @@ contract DataAttestation is LoadInstances, SwapProofCommitments {
        bytes[][] memory _callData,
        uint256[][] memory _decimals
    ) external {
-        require(msg.sender == admin, "Only admin can update account calls");
+        require(msg.sender == admin, "Only admin can update instanceOffset");
        populateAccountCalls(_contractAddresses, _callData, _decimals);
    }

@@ -276,10 +111,7 @@ contract DataAttestation is LoadInstances, SwapProofCommitments {
            // count the total number of storage reads across all of the accounts
            counter += _callData[i].length;
        }
-        require(
-            counter == INPUT_CALLS + OUTPUT_CALLS,
-            "Invalid number of calls"
-        );
+        require(counter == INPUT_CALLS + OUTPUT_CALLS, "Invalid number of calls");
    }

    function mulDiv(
@@ -335,7 +167,7 @@ contract DataAttestation is LoadInstances, SwapProofCommitments {
     * @dev Quantize the data returned from the account calls to the scale used by the EZKL model.
     * @param data - The data returned from the account calls.
     * @param decimals - The number of decimals the data returned from the account calls has (for floating point representation).
-     * @param scale - The scale used to convert the floating point value into a fixed point value.
+     * @param scale - The scale used to convert the floating point value into a fixed point value. 
     */
    function quantizeData(
        bytes memory data,
@@ -349,7 +181,7 @@ contract DataAttestation is LoadInstances, SwapProofCommitments {
        if (mulmod(uint256(x), scale, decimals) * 2 >= decimals) {
            output += 1;
        }
-        quantized_data = neg ? -int256(output) : int256(output);
+        quantized_data = neg ? -int256(output): int256(output);
    }
    /**
     * @dev Make a static call to the account to fetch the data that EZKL reads from.
@@ -379,9 +211,7 @@ contract DataAttestation is LoadInstances, SwapProofCommitments {
     * @param x - The quantized data.
     * @return field_element - The field element.
     */
-    function toFieldElement(
-        int256 x
-    ) internal pure returns (uint256 field_element) {
+    function toFieldElement(int256 x) internal pure returns (uint256 field_element) {
        // The casting down to uint256 is safe because the order is about 2^254, and the value
        // of x ranges of -2^127 to 2^127, so x + int(ORDER) is always positive.
        return uint256(x + int(ORDER)) % ORDER;
@@ -421,18 +251,13 @@ contract DataAttestation is LoadInstances, SwapProofCommitments {
        }
    }

-    /**
-     * @dev Verify the proof with the data attestation.
-     * @param verifier - The address of the verifier contract.
-     * @param encoded - The verifier calldata.
-     */
+
    function verifyWithDataAttestation(
        address verifier,
        bytes calldata encoded
    ) public view returns (bool) {
-        require(verifier.code.length > 0, "Address: call to non-contract");
+        require(verifier.code.length > 0,"Address: call to non-contract");
        attestData(getInstancesCalldata(encoded));
-        require(checkKzgCommits(encoded), "Invalid KZG commitments");
        // static call the verifier contract to verify the proof
        (bool success, bytes memory returndata) = verifier.staticcall(encoded);

--- a/contracts/LoadInstances.sol
+++ b/contracts/LoadInstances.sol
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+contract LoadInstances {
+    /**
+     * @dev Parse the instances array from the Halo2Verifier encoded calldata. 
+     * @notice must pass encoded bytes from memory
+     * @param encoded - verifier calldata
+     */
+    function getInstancesMemory(
+        bytes memory encoded
+    ) internal pure returns (uint256[] memory instances) {
+        bytes4 funcSig;
+        uint256 instances_offset;
+        uint256 instances_length;
+        assembly {
+            // fetch function sig. Either `verifyProof(bytes,uint256[])` or `verifyProof(address,bytes,uint256[])`
+            funcSig := mload(add(encoded, 0x20))
+
+            // Fetch instances offset which is 4 + 32 + 32 bytes away from
+            // start of encoded for `verifyProof(bytes,uint256[])`,
+            // and 4 + 32 + 32 +32 away for `verifyProof(address,bytes,uint256[])`
+
+            instances_offset := mload(
+                add(encoded, add(0x44, mul(0x20, eq(funcSig, 0xaf83a18d))))
+            )
+
+            instances_length := mload(add(add(encoded, 0x24), instances_offset))
+        }
+        instances = new uint256[](instances_length); // Allocate memory for the instances array.
+        assembly {
+            // Now instances points to the start of the array data
+            // (right after the length field).
+            for {
+                let i := 0x20
+            } lt(i, add(mul(instances_length, 0x20), 0x20)) {
+                i := add(i, 0x20)
+            } {
+                mstore(
+                    add(instances, i),
+                    mload(add(add(encoded, add(i, 0x24)), instances_offset))
+                )
+            }
+        }
+    }
+    /**
+     * @dev Parse the instances array from the Halo2Verifier encoded calldata. 
+     * @notice must pass encoded bytes from calldata
+     * @param encoded - verifier calldata
+     */
+    function getInstancesCalldata(
+        bytes calldata encoded
+    ) internal pure returns (uint256[] memory instances) {
+        bytes4 funcSig;
+        uint256 instances_offset;
+        uint256 instances_length;
+        assembly {
+            // fetch function sig. Either `verifyProof(bytes,uint256[])` or `verifyProof(address,bytes,uint256[])`
+            funcSig := calldataload(encoded.offset)
+
+            // Fetch instances offset which is 4 + 32 + 32 bytes away from
+            // start of encoded for `verifyProof(bytes,uint256[])`,
+            // and 4 + 32 + 32 +32 away for `verifyProof(address,bytes,uint256[])`
+
+            instances_offset := calldataload(
+                add(
+                    encoded.offset,
+                    add(0x24, mul(0x20, eq(funcSig, 0xaf83a18d)))
+                )
+            )
+
+            instances_length := calldataload(add(add(encoded.offset, 0x04), instances_offset))
+        }
+        instances = new uint256[](instances_length); // Allocate memory for the instances array.
+        assembly{
+            // Now instances points to the start of the array data
+            // (right after the length field).
+
+            for {
+                let i := 0x20
+            } lt(i, add(mul(instances_length, 0x20), 0x20)) {
+                i := add(i, 0x20)
+            } {
+                mstore(
+                    add(instances, i),
+                    calldataload(
+                        add(add(encoded.offset, add(i, 0x04)), instances_offset)
+                    )
+                )
+            }
+        }
+    }
+}
--- a/contracts/QuantizeData.sol
+++ b/contracts/QuantizeData.sol
@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity ^0.8.17;
+
+contract QuantizeData {
+    /**
+     * @notice EZKL P value
+     * @dev In order to prevent the verifier from accepting two version of the same instance, n and the quantity (n + P),  where n + P <= 2^256, we require that all instances are stricly less than P. a
+     * @dev The reason for this is that the assmebly code of the verifier performs all arithmetic operations modulo P and as a consequence can't distinguish between n and n + P.
+     */
+    uint256 constant ORDER =
+        uint256(
+            0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
+        );
+
+    /**
+     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
+     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
+     * with further edits by Uniswap Labs also under MIT license.
+     */
+    function mulDiv(
+        uint256 x,
+        uint256 y,
+        uint256 denominator
+    ) internal pure returns (uint256 result) {
+        unchecked {
+            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
+            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
+            // variables such that product = prod1 * 2^256 + prod0.
+            uint256 prod0; // Least significant 256 bits of the product
+            uint256 prod1; // Most significant 256 bits of the product
+            assembly {
+                let mm := mulmod(x, y, not(0))
+                prod0 := mul(x, y)
+                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
+            }
+
+            // Handle non-overflow cases, 256 by 256 division.
+            if (prod1 == 0) {
+                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
+                // The surrounding unchecked block does not change this fact.
+                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
+                return prod0 / denominator;
+            }
+
+            // Make sure the result is less than 2^256. Also prevents denominator == 0.
+            require(denominator > prod1, "Math: mulDiv overflow");
+
+            ///////////////////////////////////////////////
+            // 512 by 256 division.
+            ///////////////////////////////////////////////
+
+            // Make division exact by subtracting the remainder from [prod1 prod0].
+            uint256 remainder;
+            assembly {
+                // Compute remainder using mulmod.
+                remainder := mulmod(x, y, denominator)
+
+                // Subtract 256 bit number from 512 bit number.
+                prod1 := sub(prod1, gt(remainder, prod0))
+                prod0 := sub(prod0, remainder)
+            }
+
+            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
+            // See https://cs.stackexchange.com/q/138556/92363.
+
+            // Does not overflow because the denominator cannot be zero at this stage in the function.
+            uint256 twos = denominator & (~denominator + 1);
+            assembly {
+                // Divide denominator by twos.
+                denominator := div(denominator, twos)
+
+                // Divide [prod1 prod0] by twos.
+                prod0 := div(prod0, twos)
+
+                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
+                twos := add(div(sub(0, twos), twos), 1)
+            }
+
+            // Shift in bits from prod1 into prod0.
+            prod0 |= prod1 * twos;
+
+            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
+            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
+            // four bits. That is, denominator * inv = 1 mod 2^4.
+            uint256 inverse = (3 * denominator) ^ 2;
+
+            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
+            // in modular arithmetic, doubling the correct bits in each step.
+            inverse *= 2 - denominator * inverse; // inverse mod 2^8
+            inverse *= 2 - denominator * inverse; // inverse mod 2^16
+            inverse *= 2 - denominator * inverse; // inverse mod 2^32
+            inverse *= 2 - denominator * inverse; // inverse mod 2^64
+            inverse *= 2 - denominator * inverse; // inverse mod 2^128
+            inverse *= 2 - denominator * inverse; // inverse mod 2^256
+
+            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
+            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
+            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
+            // is no longer required.
+            result = prod0 * inverse;
+            return result;
+        }
+    }
+
+    function quantize_data(
+        bytes[] memory data,
+        uint256[] memory decimals,
+        uint256[] memory scales
+    ) external pure returns (int256[] memory quantized_data) {
+        quantized_data = new int256[](data.length);
+        for (uint i; i < data.length; i++) {
+            int x = abi.decode(data[i], (int256));
+            bool neg = x < 0;
+            if (neg) x = -x;
+            uint denom = 10 ** decimals[i];
+            uint scale = 1 << scales[i];
+            uint output = mulDiv(uint256(x), scale, denom);
+            if (mulmod(uint256(x), scale, denom) * 2 >= denom) {
+                output += 1;
+            }
+
+            quantized_data[i] = neg ? -int256(output) : int256(output);
+        }
+    }
+
+    function to_field_element(
+        int128[] memory quantized_data
+    ) public pure returns (uint256[] memory output) {
+        output = new uint256[](quantized_data.length);
+        for (uint i; i < quantized_data.length; i++) {
+            output[i] = uint256(quantized_data[i] + int(ORDER)) % ORDER;
+        }
+    }
+}
--- a/contracts/TestReads.sol
+++ b/contracts/TestReads.sol
@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.17;
+
+contract TestReads {
+    int[] public arr;
+
+    constructor(int256[] memory _numbers) {
+        for (uint256 i = 0; i < _numbers.length; i++) {
+            arr.push(_numbers[i]);
+        }
+    }
+}
--- a/data.sh
+++ b/data.sh
@@ -0,0 +1,11 @@
+#! /bin/bash
+
+mkdir data
+cd data
+
+wget http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
+wget http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
+wget http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
+wget http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
+
+gzip -d *.gz
--- a/docs/python/requirements-docs.txt
+++ b/docs/python/requirements-docs.txt
@@ -1,4 +1,4 @@
-ezkl==13.0.2
+ezkl==10.3.3
 sphinx
 sphinx-rtd-theme
 sphinxcontrib-napoleon
--- a/docs/python/src/conf.py
+++ b/docs/python/src/conf.py
@@ -1,7 +1,7 @@
 import ezkl

 project = 'ezkl'
-release = '13.0.2'
+release = '10.3.3'
 version = release


--- a/examples/conv2d_mnist/main.rs
+++ b/examples/conv2d_mnist/main.rs
@@ -2,7 +2,8 @@ use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::{
    ops::lookup::LookupOp, ops::poly::PolyOp, BaseConfig as PolyConfig, CheckMode,
 };
-use ezkl::fieldutils::{self, integer_rep_to_felt, IntegerRep};
+use ezkl::fieldutils;
+use ezkl::fieldutils::i32_to_felt;
 use ezkl::tensor::*;
 use halo2_proofs::dev::MockProver;
 use halo2_proofs::poly::commitment::Params;
@@ -41,8 +42,8 @@ const NUM_INNER_COLS: usize = 1;
 struct Config<
    const LEN: usize, //LEN = CHOUT x OH x OW flattened //not supported yet in rust stable
    const CLASSES: usize,
-    const LOOKUP_MIN: IntegerRep,
-    const LOOKUP_MAX: IntegerRep,
+    const LOOKUP_MIN: i128,
+    const LOOKUP_MAX: i128,
    // Convolution
    const KERNEL_HEIGHT: usize,
    const KERNEL_WIDTH: usize,
@@ -65,8 +66,8 @@ struct Config<
 struct MyCircuit<
    const LEN: usize, //LEN = CHOUT x OH x OW flattened
    const CLASSES: usize,
-    const LOOKUP_MIN: IntegerRep,
-    const LOOKUP_MAX: IntegerRep,
+    const LOOKUP_MIN: i128,
+    const LOOKUP_MAX: i128,
    // Convolution
    const KERNEL_HEIGHT: usize,
    const KERNEL_WIDTH: usize,
@@ -89,8 +90,8 @@ struct MyCircuit<
 impl<
        const LEN: usize,
        const CLASSES: usize,
-        const LOOKUP_MIN: IntegerRep,
-        const LOOKUP_MAX: IntegerRep,
+        const LOOKUP_MIN: i128,
+        const LOOKUP_MAX: i128,
        // Convolution
        const KERNEL_HEIGHT: usize,
        const KERNEL_WIDTH: usize,
@@ -204,7 +205,6 @@ where
                    let op = PolyOp::Conv {
                        padding: vec![(PADDING, PADDING); 2],
                        stride: vec![STRIDE; 2],
-                        group: 1,
                    };
                    let x = config
                        .layer_config
@@ -308,18 +308,13 @@ pub fn runconv() {
        tst_lbl: _,
        ..
    } = MnistBuilder::new()
-        .base_path("examples/data")
        .label_format_digit()
        .training_set_length(50_000)
        .validation_set_length(10_000)
        .test_set_length(10_000)
        .finalize();

-    let mut train_data = Tensor::from(
-        trn_img
-            .iter()
-            .map(|x| integer_rep_to_felt::<F>(*x as IntegerRep / 16)),
-    );
+    let mut train_data = Tensor::from(trn_img.iter().map(|x| i32_to_felt::<F>(*x as i32 / 16)));
    train_data.reshape(&[50_000, 28, 28]).unwrap();

    let mut train_labels = Tensor::from(trn_lbl.iter().map(|x| *x as f32));
@@ -347,8 +342,8 @@ pub fn runconv() {
            .map(|fl| {
                let dx = fl * 32_f32;
                let rounded = dx.round();
-                let integral: IntegerRep = unsafe { rounded.to_int_unchecked() };
-                fieldutils::integer_rep_to_felt(integral)
+                let integral: i32 = unsafe { rounded.to_int_unchecked() };
+                fieldutils::i32_to_felt(integral)
            }),
    );

@@ -359,8 +354,7 @@ pub fn runconv() {

    let l0_kernels = l0_kernels.try_into().unwrap();

-    let mut l0_bias =
-        Tensor::<F>::from((0..OUT_CHANNELS).map(|_| fieldutils::integer_rep_to_felt(0)));
+    let mut l0_bias = Tensor::<F>::from((0..OUT_CHANNELS).map(|_| fieldutils::i32_to_felt(0)));
    l0_bias.set_visibility(&ezkl::graph::Visibility::Private);

    let l0_bias = l0_bias.try_into().unwrap();
@@ -368,8 +362,8 @@ pub fn runconv() {
    let mut l2_biases = Tensor::<F>::from(myparams.biases.into_iter().map(|fl| {
        let dx = fl * 32_f32;
        let rounded = dx.round();
-        let integral: IntegerRep = unsafe { rounded.to_int_unchecked() };
-        fieldutils::integer_rep_to_felt(integral)
+        let integral: i32 = unsafe { rounded.to_int_unchecked() };
+        fieldutils::i32_to_felt(integral)
    }));
    l2_biases.set_visibility(&ezkl::graph::Visibility::Private);
    l2_biases.reshape(&[l2_biases.len(), 1]).unwrap();
@@ -379,8 +373,8 @@ pub fn runconv() {
    let mut l2_weights = Tensor::<F>::from(myparams.weights.into_iter().flatten().map(|fl| {
        let dx = fl * 32_f32;
        let rounded = dx.round();
-        let integral: IntegerRep = unsafe { rounded.to_int_unchecked() };
-        fieldutils::integer_rep_to_felt(integral)
+        let integral: i32 = unsafe { rounded.to_int_unchecked() };
+        fieldutils::i32_to_felt(integral)
    }));
    l2_weights.set_visibility(&ezkl::graph::Visibility::Private);
    l2_weights.reshape(&[CLASSES, LEN]).unwrap();
@@ -406,13 +400,13 @@ pub fn runconv() {
        l2_params: [l2_weights, l2_biases],
    };

-    let public_input: Tensor<IntegerRep> = vec![
-        -25124, -19304, -16668, -4399, -6209, -4548, -2317, -8349, -6117, -23461,
+    let public_input: Tensor<i32> = vec![
+        -25124i32, -19304, -16668, -4399, -6209, -4548, -2317, -8349, -6117, -23461,
    ]
    .into_iter()
    .into();

-    let pi_inner: Tensor<F> = public_input.map(integer_rep_to_felt::<F>);
+    let pi_inner: Tensor<F> = public_input.map(i32_to_felt::<F>);

    println!("MOCK PROVING");
    let now = Instant::now();
--- a/examples/data/t10k-images-idx3-ubyte
+++ b/examples/data/t10k-images-idx3-ubyte
--- a/examples/data/t10k-labels-idx1-ubyte
+++ b/examples/data/t10k-labels-idx1-ubyte
--- a/examples/data/train-images-idx3-ubyte
+++ b/examples/data/train-images-idx3-ubyte
--- a/examples/data/train-labels-idx1-ubyte
+++ b/examples/data/train-labels-idx1-ubyte
--- a/examples/mlp_4d_einsum.rs
+++ b/examples/mlp_4d_einsum.rs
@@ -2,7 +2,7 @@ use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::{
    ops::lookup::LookupOp, ops::poly::PolyOp, BaseConfig as PolyConfig, CheckMode,
 };
-use ezkl::fieldutils::{integer_rep_to_felt, IntegerRep};
+use ezkl::fieldutils::i32_to_felt;
 use ezkl::tensor::*;
 use halo2_proofs::dev::MockProver;
 use halo2_proofs::{
@@ -23,8 +23,8 @@ struct MyConfig {
 #[derive(Clone)]
 struct MyCircuit<
    const LEN: usize, //LEN = CHOUT x OH x OW flattened
-    const LOOKUP_MIN: IntegerRep,
-    const LOOKUP_MAX: IntegerRep,
+    const LOOKUP_MIN: i128,
+    const LOOKUP_MAX: i128,
 > {
    // Given the stateless MyConfig type information, a DNN trace is determined by its input and the parameters of its layers.
    // Computing the trace still requires a forward pass. The intermediate activations are stored only by the layouter.
@@ -34,7 +34,7 @@ struct MyCircuit<
    _marker: PhantomData<F>,
 }

-impl<const LEN: usize, const LOOKUP_MIN: IntegerRep, const LOOKUP_MAX: IntegerRep> Circuit<F>
+impl<const LEN: usize, const LOOKUP_MIN: i128, const LOOKUP_MAX: i128> Circuit<F>
    for MyCircuit<LEN, LOOKUP_MIN, LOOKUP_MAX>
 {
    type Config = MyConfig;
@@ -215,33 +215,33 @@ pub fn runmlp() {
    #[cfg(not(target_arch = "wasm32"))]
    env_logger::init();
    // parameters
-    let mut l0_kernel: Tensor<F> = Tensor::<IntegerRep>::new(
+    let mut l0_kernel: Tensor<F> = Tensor::<i32>::new(
        Some(&[10, 0, 0, -1, 0, 10, 1, 0, 0, 1, 10, 0, 1, 0, 0, 10]),
        &[4, 4],
    )
    .unwrap()
-    .map(integer_rep_to_felt);
+    .map(i32_to_felt);
    l0_kernel.set_visibility(&ezkl::graph::Visibility::Private);

-    let mut l0_bias: Tensor<F> = Tensor::<IntegerRep>::new(Some(&[0, 0, 0, 1]), &[4, 1])
+    let mut l0_bias: Tensor<F> = Tensor::<i32>::new(Some(&[0, 0, 0, 1]), &[4, 1])
        .unwrap()
-        .map(integer_rep_to_felt);
+        .map(i32_to_felt);
    l0_bias.set_visibility(&ezkl::graph::Visibility::Private);

-    let mut l2_kernel: Tensor<F> = Tensor::<IntegerRep>::new(
+    let mut l2_kernel: Tensor<F> = Tensor::<i32>::new(
        Some(&[0, 3, 10, -1, 0, 10, 1, 0, 0, 1, 0, 12, 1, -2, 32, 0]),
        &[4, 4],
    )
    .unwrap()
-    .map(integer_rep_to_felt);
+    .map(i32_to_felt);
    l2_kernel.set_visibility(&ezkl::graph::Visibility::Private);
    // input data, with 1 padding to allow for bias
-    let input: Tensor<Value<F>> = Tensor::<IntegerRep>::new(Some(&[-30, -21, 11, 40]), &[4, 1])
+    let input: Tensor<Value<F>> = Tensor::<i32>::new(Some(&[-30, -21, 11, 40]), &[4, 1])
        .unwrap()
        .into();
-    let mut l2_bias: Tensor<F> = Tensor::<IntegerRep>::new(Some(&[0, 0, 0, 1]), &[4, 1])
+    let mut l2_bias: Tensor<F> = Tensor::<i32>::new(Some(&[0, 0, 0, 1]), &[4, 1])
        .unwrap()
-        .map(integer_rep_to_felt);
+        .map(i32_to_felt);
    l2_bias.set_visibility(&ezkl::graph::Visibility::Private);

    let circuit = MyCircuit::<4, -8192, 8192> {
@@ -251,12 +251,12 @@ pub fn runmlp() {
        _marker: PhantomData,
    };

-    let public_input: Vec<IntegerRep> = unsafe {
+    let public_input: Vec<i32> = unsafe {
        vec![
-            (531f32 / 128f32).round().to_int_unchecked::<IntegerRep>(),
-            (103f32 / 128f32).round().to_int_unchecked::<IntegerRep>(),
-            (4469f32 / 128f32).round().to_int_unchecked::<IntegerRep>(),
-            (2849f32 / 128f32).to_int_unchecked::<IntegerRep>(),
+            (531f32 / 128f32).round().to_int_unchecked::<i32>(),
+            (103f32 / 128f32).round().to_int_unchecked::<i32>(),
+            (4469f32 / 128f32).round().to_int_unchecked::<i32>(),
+            (2849f32 / 128f32).to_int_unchecked::<i32>(),
        ]
    };

@@ -265,10 +265,7 @@ pub fn runmlp() {
    let prover = MockProver::run(
        K as u32,
        &circuit,
-        vec![public_input
-            .iter()
-            .map(|x| integer_rep_to_felt::<F>(*x))
-            .collect()],
+        vec![public_input.iter().map(|x| i32_to_felt::<F>(*x)).collect()],
    )
    .unwrap();
    prover.assert_satisfied();
--- a/examples/notebooks/data_attest.ipynb
+++ b/examples/notebooks/data_attest.ipynb
@@ -251,7 +251,7 @@
                "with open(cal_path, \"w\") as f:\n",
                "    json.dump(cal_data, f)\n",
                "\n",
-                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -307,7 +307,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "await ezkl.setup_test_evm_witness(\n",
+                "ezkl.setup_test_evm_witness(\n",
                "    data_path,\n",
                "    compiled_model_path,\n",
                "    # we write the call data to the same file as the input data\n",
@@ -333,7 +333,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "res = await ezkl.get_srs( settings_path)\n"
+                "res = ezkl.get_srs( settings_path)\n"
            ]
        },
        {
@@ -354,7 +354,7 @@
                "\n",
                "witness_path = \"witness.json\"\n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
            ]
        },
        {
@@ -462,7 +462,7 @@
                "abi_path = 'test.abi'\n",
                "sol_code_path = 'test.sol'\n",
                "\n",
-                "res = await ezkl.create_evm_verifier(\n",
+                "res = ezkl.create_evm_verifier(\n",
                "        vk_path,\n",
                "        \n",
                "        settings_path,\n",
@@ -482,7 +482,7 @@
                "\n",
                "addr_path_verifier = \"addr_verifier.txt\"\n",
                "\n",
-                "res = await ezkl.deploy_evm(\n",
+                "res = ezkl.deploy_evm(\n",
                "    addr_path_verifier,\n",
                "    sol_code_path,\n",
                "    'http://127.0.0.1:3030'\n",
@@ -510,7 +510,7 @@
                "sol_code_path = 'test.sol'\n",
                "input_path = 'input.json'\n",
                "\n",
-                "res = await ezkl.create_evm_data_attestation(\n",
+                "res = ezkl.create_evm_data_attestation(\n",
                "        input_path,\n",
                "        settings_path,\n",
                "        sol_code_path,\n",
@@ -535,7 +535,7 @@
            "source": [
                "addr_path_da = \"addr_da.txt\"\n",
                "\n",
-                "res = await ezkl.deploy_da_evm(\n",
+                "res = ezkl.deploy_da_evm(\n",
                "        addr_path_da,\n",
                "        input_path,\n",
                "        settings_path,\n",
@@ -567,7 +567,7 @@
                "with open(addr_path_da, 'r') as f:\n",
                "    addr_da = f.read()\n",
                "\n",
-                "res = await ezkl.verify_evm(\n",
+                "res = ezkl.verify_evm(\n",
                "    addr,\n",
                "    proof_path,\n",
                "    RPC_URL,\n",
@@ -592,7 +592,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.12.2"
+            "version": "3.9.15"
        },
        "orig_nbformat": 4
    },
--- a/examples/notebooks/data_attest_hashed.ipynb
+++ b/examples/notebooks/data_attest_hashed.ipynb
@@ -249,7 +249,7 @@
                "with open(cal_path, \"w\") as f:\n",
                "    json.dump(cal_data, f)\n",
                "\n",
-                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -278,7 +278,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "res = await ezkl.get_srs( settings_path)\n"
+                "res = ezkl.get_srs( settings_path)\n"
            ]
        },
        {
@@ -299,7 +299,7 @@
                "\n",
                "witness_path = \"witness.json\"\n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "\n"
            ]
        },
@@ -518,7 +518,7 @@
                "abi_path = 'test.abi'\n",
                "sol_code_path = 'test.sol'\n",
                "\n",
-                "res = await ezkl.create_evm_verifier(\n",
+                "res = ezkl.create_evm_verifier(\n",
                "        vk_path,\n",
                "        \n",
                "        settings_path,\n",
@@ -538,7 +538,7 @@
                "\n",
                "addr_path_verifier = \"addr_verifier.txt\"\n",
                "\n",
-                "res = await ezkl.deploy_evm(\n",
+                "res = ezkl.deploy_evm(\n",
                "    addr_path_verifier,\n",
                "    sol_code_path,\n",
                "    'http://127.0.0.1:3030'\n",
@@ -566,7 +566,7 @@
                "sol_code_path = 'test.sol'\n",
                "input_path = 'input.json'\n",
                "\n",
-                "res = await ezkl.create_evm_data_attestation(\n",
+                "res = ezkl.create_evm_data_attestation(\n",
                "        input_path,\n",
                "        settings_path,\n",
                "        sol_code_path,\n",
@@ -591,7 +591,7 @@
            "source": [
                "addr_path_da = \"addr_da.txt\"\n",
                "\n",
-                "res = await ezkl.deploy_da_evm(\n",
+                "res = ezkl.deploy_da_evm(\n",
                "        addr_path_da,\n",
                "        input_path,\n",
                "        settings_path,\n",
@@ -623,7 +623,7 @@
                "with open(addr_path_da, 'r') as f:\n",
                "    addr_da = f.read()\n",
                "\n",
-                "res = await ezkl.verify_evm(\n",
+                "res = ezkl.verify_evm(\n",
                "    addr,\n",
                "    proof_path,\n",
                "    RPC_URL,\n",
@@ -654,4 +654,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 2
-}
+}
--- a/examples/notebooks/data_attest_kzg_vis.ipynb
+++ b/examples/notebooks/data_attest_kzg_vis.ipynb
@@ -1,604 +0,0 @@
-{
-    "cells": [
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "# data-attest-kzg-vis\n",
-                "\n",
-                "Here's an example leveraging EZKL whereby the inputs to the model are read and attested to from an on-chain source and the params and outputs are committed to using kzg-commitments. \n",
-                "\n",
-                "In this setup:\n",
-                "- the inputs and outputs are publicly known to the prover and verifier\n",
-                "- the on chain inputs will be fetched and then fed directly into the circuit\n",
-                "- the quantization of the on-chain inputs happens within the evm and is replicated at proving time \n",
-                "- The kzg commitment to the params and inputs will be read from the proof and checked to make sure it matches the expected commitment stored on-chain.\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "First we import the necessary dependencies and set up logging to be as informative as possible. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# check if notebook is in colab\n",
-                "try:\n",
-                "    # install ezkl\n",
-                "    import google.colab\n",
-                "    import subprocess\n",
-                "    import sys\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
-                "\n",
-                "# rely on local installation of ezkl if the notebook is not in colab\n",
-                "except:\n",
-                "    pass\n",
-                "\n",
-                "\n",
-                "from torch import nn\n",
-                "import ezkl\n",
-                "import os\n",
-                "import json\n",
-                "import logging\n",
-                "\n",
-                "# uncomment for more descriptive logging \n",
-                "FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
-                "logging.basicConfig(format=FORMAT)\n",
-                "logging.getLogger().setLevel(logging.DEBUG)\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we define our model. It is a very simple PyTorch model that has just one layer, an average pooling 2D layer. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import torch\n",
-                "# Defines the model\n",
-                "\n",
-                "class MyModel(nn.Module):\n",
-                "    def __init__(self):\n",
-                "        super(MyModel, self).__init__()\n",
-                "        self.layer = nn.AvgPool2d(2, 1, (1, 1))\n",
-                "\n",
-                "    def forward(self, x):\n",
-                "        return self.layer(x)[0]\n",
-                "\n",
-                "\n",
-                "circuit = MyModel()\n",
-                "\n",
-                "# this is where you'd train your model"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We omit training for purposes of this demonstration. We've marked where training would happen in the cell above. \n",
-                "Now we export the model to onnx and create a corresponding (randomly generated) input. This input data will eventually be stored on chain and read from according to the call_data field in the graph input.\n",
-                "\n",
-                "You can replace the random `x` with real data if you so wish. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "x = 0.1*torch.rand(1,*[3, 2, 2], requires_grad=True)\n",
-                "\n",
-                "# Flips the neural net into inference mode\n",
-                "circuit.eval()\n",
-                "\n",
-                "    # Export the model\n",
-                "torch.onnx.export(circuit,               # model being run\n",
-                "                      x,                   # model input (or a tuple for multiple inputs)\n",
-                "                      \"network.onnx\",            # where to save the model (can be a file or file-like object)\n",
-                "                      export_params=True,        # store the trained parameter weights inside the model file\n",
-                "                      opset_version=10,          # the ONNX version to export the model to\n",
-                "                      do_constant_folding=True,  # whether to execute constant folding for optimization\n",
-                "                      input_names = ['input'],   # the model's input names\n",
-                "                      output_names = ['output'], # the model's output names\n",
-                "                      dynamic_axes={'input' : {0 : 'batch_size'},    # variable length axes\n",
-                "                                    'output' : {0 : 'batch_size'}})\n",
-                "\n",
-                "data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
-                "\n",
-                "data = dict(input_data = [data_array])\n",
-                "\n",
-                "    # Serialize data into file:\n",
-                "json.dump(data, open(\"input.json\", 'w' ))\n",
-                "\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now define a function that will create a new anvil instance which we will deploy our test contract too. This contract will contain in its storage the data that we will read from and attest to. In production you would not need to set up a local anvil instance. Instead you would replace RPC_URL with the actual RPC endpoint of the chain you are deploying your verifiers too, reading from the data on said chain."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import subprocess\n",
-                "import time\n",
-                "import threading\n",
-                "\n",
-                "# make sure anvil is running locally\n",
-                "# $ anvil -p 3030\n",
-                "\n",
-                "RPC_URL = \"http://localhost:3030\"\n",
-                "\n",
-                "# Save process globally\n",
-                "anvil_process = None\n",
-                "\n",
-                "def start_anvil():\n",
-                "    global anvil_process\n",
-                "    if anvil_process is None:\n",
-                "        anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--code-size-limit=41943040\"])\n",
-                "        if anvil_process.returncode is not None:\n",
-                "            raise Exception(\"failed to start anvil process\")\n",
-                "        time.sleep(3)\n",
-                "\n",
-                "def stop_anvil():\n",
-                "    global anvil_process\n",
-                "    if anvil_process is not None:\n",
-                "        anvil_process.terminate()\n",
-                "        anvil_process = None\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
-                "- `input_visibility` defines the visibility of the model inputs\n",
-                "- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
-                "- `output_visibility` defines the visibility of the model outputs\n",
-                "\n",
-                "Here we create the following setup:\n",
-                "- `input_visibility`: \"public\"\n",
-                "- `param_visibility`: \"polycommitment\" \n",
-                "- `output_visibility`: \"polycommitment\"\n",
-                "\n",
-                "**Note**:\n",
-                "When we set this to polycommitment, we are saying that the model parameters are committed to using a polynomial commitment scheme. This commitment will be stored on chain as a constant stored in the DA contract, and the proof will contain the commitment to the parameters. The DA verification will then check that the commitment in the proof matches the commitment stored on chain. \n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import ezkl\n",
-                "\n",
-                "model_path = os.path.join('network.onnx')\n",
-                "compiled_model_path = os.path.join('network.compiled')\n",
-                "pk_path = os.path.join('test.pk')\n",
-                "vk_path = os.path.join('test.vk')\n",
-                "settings_path = os.path.join('settings.json')\n",
-                "srs_path = os.path.join('kzg.srs')\n",
-                "data_path = os.path.join('input.json')\n",
-                "\n",
-                "run_args = ezkl.PyRunArgs()\n",
-                "run_args.input_visibility = \"public\"\n",
-                "run_args.param_visibility = \"polycommit\"\n",
-                "run_args.output_visibility = \"polycommit\"\n",
-                "run_args.num_inner_cols = 1\n",
-                "run_args.variables = [(\"batch_size\", 1)]\n",
-                "\n",
-                "\n",
-                "\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
-                "\n",
-                "You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "!RUST_LOG=trace\n",
-                "# TODO: Dictionary outputs\n",
-                "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# generate a bunch of dummy calibration data\n",
-                "cal_data = {\n",
-                "    \"input_data\": [(0.1*torch.rand(2, *[3, 2, 2])).flatten().tolist()],\n",
-                "}\n",
-                "\n",
-                "cal_path = os.path.join('val_data.json')\n",
-                "# save as json file\n",
-                "with open(cal_path, \"w\") as f:\n",
-                "    json.dump(cal_data, f)\n",
-                "\n",
-                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "The graph input for on chain data sources is formatted completely differently compared to file based data sources.\n",
-                "\n",
-                "- For file data sources, the raw floating point values that eventually get quantized, converted into field elements and stored in `witness.json` to be consumed by the circuit are stored. The output data contains the expected floating point values returned as outputs from running your vanilla pytorch model on the given inputs.\n",
-                "- For on chain data sources, the input_data field contains all the data necessary to read and format the on chain data into something digestable by EZKL (aka field elements :-D). \n",
-                "Here is what the schema for an on-chain data source graph input file should look like:\n",
-                "    \n",
-                "```json\n",
-                "{\n",
-                "  \"input_data\": {\n",
-                "    \"rpc\": \"http://localhost:3030\", // The rpc endpoint of the chain you are deploying your verifier to\n",
-                "    \"calls\": [\n",
-                "      {\n",
-                "        \"call_data\": [\n",
-                "          [\n",
-                "            \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000000\", // The abi encoded call data to a view function that returns a single on-chain data point (we only support uint256 returns for now)\n",
-                "            7 // The number of decimal places of the large uint256 value. This is our way of representing large wei values as floating points on chain, since the evm only natively supports integer values.\n",
-                "          ],\n",
-                "          [\n",
-                "            \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000001\",\n",
-                "            5\n",
-                "          ],\n",
-                "          [\n",
-                "            \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000002\",\n",
-                "            5\n",
-                "          ]\n",
-                "        ],\n",
-                "        \"address\": \"5fbdb2315678afecb367f032d93f642f64180aa3\" // The address of the contract that we are calling to get the data. \n",
-                "      }\n",
-                "    ]\n",
-                "  }\n",
-                "}"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "await ezkl.setup_test_evm_witness(\n",
-                "    data_path,\n",
-                "    compiled_model_path,\n",
-                "    # we write the call data to the same file as the input data\n",
-                "    data_path,\n",
-                "    input_source=ezkl.PyTestDataSource.OnChain,\n",
-                "    output_source=ezkl.PyTestDataSource.File,\n",
-                "    rpc_url=RPC_URL)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
-                "\n",
-                "These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = await ezkl.get_srs( settings_path)\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now need to generate the circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "!export RUST_BACKTRACE=1\n",
-                "\n",
-                "witness_path = \"witness.json\"\n",
-                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# HERE WE SETUP THE CIRCUIT PARAMS\n",
-                "# WE GOT KEYS\n",
-                "# WE GOT CIRCUIT PARAMETERS\n",
-                "# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
-                "res = ezkl.setup(\n",
-                "        compiled_model_path,\n",
-                "        vk_path,\n",
-                "        pk_path,\n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "assert os.path.isfile(vk_path)\n",
-                "assert os.path.isfile(pk_path)\n",
-                "assert os.path.isfile(settings_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we generate a full proof. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# GENERATE A PROOF\n",
-                "\n",
-                "proof_path = os.path.join('test.pf')\n",
-                "\n",
-                "res = ezkl.prove(\n",
-                "        witness_path,\n",
-                "        compiled_model_path,\n",
-                "        pk_path,\n",
-                "        proof_path,\n",
-                "        \n",
-                "        \"single\",\n",
-                "    )\n",
-                "\n",
-                "print(res)\n",
-                "assert os.path.isfile(proof_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "And verify it as a sanity check. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# VERIFY IT\n",
-                "\n",
-                "res = ezkl.verify(\n",
-                "        proof_path,\n",
-                "        settings_path,\n",
-                "        vk_path,\n",
-                "        \n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "print(\"verified\")"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We can now create and then deploy a vanilla evm verifier."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "\n",
-                "res = await ezkl.create_evm_verifier(\n",
-                "        vk_path,\n",
-                "        \n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "    )\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "addr_path_verifier = \"addr_verifier.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_evm(\n",
-                "    addr_path_verifier,\n",
-                "    sol_code_path,\n",
-                "    'http://127.0.0.1:3030'\n",
-                ")\n",
-                "\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "When deploying a DA with kzg commitments, we need to make sure to also pass a witness file that contains the commitments to the parameters and inputs. This is because the verifier will need to check that the commitments in the proof match the commitments stored on chain."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "input_path = 'input.json'\n",
-                "\n",
-                "res = await ezkl.create_evm_data_attestation(\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "        witness_path = witness_path,\n",
-                "    )"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we can deploy the data attest verifier contract. For security reasons, this binding will only deploy to a local anvil instance, using accounts generated by anvil. \n",
-                "So should only be used for testing purposes."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "addr_path_da = \"addr_da.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_da_evm(\n",
-                "        addr_path_da,\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        RPC_URL,\n",
-                "    )\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# read the verifier address\n",
-                "addr_verifier = None\n",
-                "with open(addr_path_verifier, 'r') as f:\n",
-                "    addr = f.read()\n",
-                "#read the data attestation address\n",
-                "addr_da = None\n",
-                "with open(addr_path_da, 'r') as f:\n",
-                "    addr_da = f.read()\n",
-                "\n",
-                "res = await ezkl.verify_evm(\n",
-                "    addr,\n",
-                "    proof_path,\n",
-                "    RPC_URL,\n",
-                "    addr_da,\n",
-                ")"
-            ]
-        }
-    ],
-    "metadata": {
-        "kernelspec": {
-            "display_name": "ezkl",
-            "language": "python",
-            "name": "python3"
-        },
-        "language_info": {
-            "codemirror_mode": {
-                "name": "ipython",
-                "version": 3
-            },
-            "file_extension": ".py",
-            "mimetype": "text/x-python",
-            "name": "python",
-            "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3",
-            "version": "3.9.13"
-        },
-        "orig_nbformat": 4
-    },
-    "nbformat": 4,
-    "nbformat_minor": 2
-}
--- a/examples/notebooks/decision_tree.ipynb
+++ b/examples/notebooks/decision_tree.ipynb
@@ -150,7 +150,7 @@
                "res = ezkl.gen_settings(model_path, settings_path)\n",
                "assert res == True\n",
                "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True"
            ]
        },
@@ -170,7 +170,7 @@
                "with open(cal_path, \"w\") as f:\n",
                "    json.dump(cal_data, f)\n",
                "\n",
-                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -192,7 +192,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -204,7 +204,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -303,4 +303,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/ezkl_demo.ipynb
+++ b/examples/notebooks/ezkl_demo.ipynb
@@ -352,8 +352,14 @@
        "# Specify all the files we need\n",
        "\n",
        "model_path = os.path.join('network.onnx')\n",
+        "compiled_model_path = os.path.join('network.ezkl')\n",
+        "pk_path = os.path.join('test.pk')\n",
+        "vk_path = os.path.join('test.vk')\n",
+        "settings_path = os.path.join('settings.json')\n",
+        "\n",
+        "witness_path = os.path.join('witness.json')\n",
        "data_path = os.path.join('input.json')\n",
-        "cal_data_path = os.path.join('calibration.json')"
+        "cal_data_path = os.path.join('cal_data.json')"
      ]
    },
    {
@@ -418,7 +424,7 @@
      "source": [
        "!RUST_LOG=trace\n",
        "# TODO: Dictionary outputs\n",
-        "res = ezkl.gen_settings()\n",
+        "res = ezkl.gen_settings(model_path, settings_path)\n",
        "assert res == True\n",
        "\n"
      ]
@@ -437,7 +443,7 @@
        "\n",
        "# Optimize for resources, we cap logrows at 12 to reduce setup and proving time, at the expense of accuracy\n",
        "# You may want to increase the max logrows if accuracy is a concern\n",
-        "res = await ezkl.calibrate_settings(target = \"resources\", max_logrows = 12, scales = [2])"
+        "res = ezkl.calibrate_settings(cal_data_path, model_path, settings_path, \"resources\", max_logrows = 12, scales = [2])"
      ]
    },
    {
@@ -457,7 +463,7 @@
      },
      "outputs": [],
      "source": [
-        "res = ezkl.compile_circuit()\n",
+        "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
        "assert res == True"
      ]
    },
@@ -478,7 +484,7 @@
      },
      "outputs": [],
      "source": [
-        "res = await ezkl.get_srs()"
+        "res = ezkl.get_srs( settings_path)"
      ]
    },
    {
@@ -498,10 +504,17 @@
      },
      "outputs": [],
      "source": [
-        "res = ezkl.setup()\n",
+        "res = ezkl.setup(\n",
+        "        compiled_model_path,\n",
+        "        vk_path,\n",
+        "        pk_path,\n",
+        "    )\n",
        "\n",
        "\n",
-        "assert res == True"
+        "assert res == True\n",
+        "assert os.path.isfile(vk_path)\n",
+        "assert os.path.isfile(pk_path)\n",
+        "assert os.path.isfile(settings_path)"
      ]
    },
    {
@@ -526,7 +539,7 @@
        "# now generate the witness file\n",
        "witness_path = os.path.join('witness.json')\n",
        "\n",
-        "res = await ezkl.gen_witness()\n",
+        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
@@ -546,7 +559,13 @@
        "\n",
        "proof_path = os.path.join('proof.json')\n",
        "\n",
-        "proof = ezkl.prove(proof_type=\"single\", proof_path=proof_path)\n",
+        "proof = ezkl.prove(\n",
+        "        witness_path,\n",
+        "        compiled_model_path,\n",
+        "        pk_path,\n",
+        "        proof_path,\n",
+        "        \"single\",\n",
+        "    )\n",
        "\n",
        "print(proof)\n",
        "assert os.path.isfile(proof_path)"
@@ -566,7 +585,11 @@
      "source": [
        "# verify our proof\n",
        "\n",
-        "res = ezkl.verify()\n",
+        "res = ezkl.verify(\n",
+        "        proof_path,\n",
+        "        settings_path,\n",
+        "        vk_path,\n",
+        "    )\n",
        "\n",
        "assert res == True\n",
        "print(\"verified\")"
@@ -641,9 +664,12 @@
        "sol_code_path = os.path.join('Verifier.sol')\n",
        "abi_path = os.path.join('Verifier.abi')\n",
        "\n",
-        "res = await ezkl.create_evm_verifier(\n",
-        "        sol_code_path=sol_code_path,\n",
-        "        abi_path=abi_path, \n",
+        "res = ezkl.create_evm_verifier(\n",
+        "        vk_path,\n",
+        "        \n",
+        "        settings_path,\n",
+        "        sol_code_path,\n",
+        "        abi_path\n",
        "    )\n",
        "\n",
        "assert res == True\n",
@@ -731,7 +757,7 @@
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
-      "version": "3.12.2"
+      "version": "3.9.15"
    }
  },
  "nbformat": 4,
--- a/examples/notebooks/gcn.ipynb
+++ b/examples/notebooks/gcn.ipynb
@@ -467,7 +467,7 @@
      "outputs": [],
      "source": [
        "\n",
-        "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+        "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
        "assert res == True"
      ]
    },
@@ -494,7 +494,7 @@
      "outputs": [],
      "source": [
        "# srs path\n",
-        "res = await ezkl.get_srs( settings_path)"
+        "res = ezkl.get_srs( settings_path)"
      ]
    },
    {
@@ -508,7 +508,7 @@
      "source": [
        "# now generate the witness file\n",
        "\n",
-        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
@@ -625,4 +625,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/generalized_inverse.ipynb
+++ b/examples/notebooks/generalized_inverse.ipynb
@@ -195,7 +195,7 @@
        "json.dump(data, open(cal_path, 'w'))\n",
        "\n",
        "\n",
-        "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+        "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
        "assert res == True\n"
      ]
    },
@@ -222,7 +222,7 @@
      "outputs": [],
      "source": [
        "# srs path\n",
-        "res = await ezkl.get_srs( settings_path)"
+        "res = ezkl.get_srs( settings_path)"
      ]
    },
    {
@@ -236,7 +236,7 @@
      "source": [
        "# now generate the witness file\n",
        "\n",
-        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
--- a/examples/notebooks/gradient_boosted_trees.ipynb
+++ b/examples/notebooks/gradient_boosted_trees.ipynb
@@ -179,7 +179,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -202,7 +202,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -214,7 +214,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -313,4 +313,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/hashed_vis.ipynb
+++ b/examples/notebooks/hashed_vis.ipynb
@@ -241,7 +241,7 @@
                "with open(cal_path, \"w\") as f:\n",
                "    json.dump(cal_data, f)\n",
                "\n",
-                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -270,7 +270,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "res = await ezkl.get_srs( settings_path)\n"
+                "res = ezkl.get_srs( settings_path)\n"
            ]
        },
        {
@@ -291,7 +291,7 @@
                "\n",
                "witness_path = \"witness.json\"\n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
            ]
        },
        {
@@ -420,7 +420,7 @@
                "abi_path = 'test.abi'\n",
                "sol_code_path = 'test.sol'\n",
                "\n",
-                "res = await ezkl.create_evm_verifier(\n",
+                "res = ezkl.create_evm_verifier(\n",
                "        vk_path,\n",
                "        \n",
                "        settings_path,\n",
@@ -451,7 +451,7 @@
                "\n",
                "address_path = os.path.join(\"address.json\")\n",
                "\n",
-                "res = await ezkl.deploy_evm(\n",
+                "res = ezkl.deploy_evm(\n",
                "    address_path,\n",
                "    sol_code_path,\n",
                "    'http://127.0.0.1:3030'\n",
@@ -472,7 +472,7 @@
                "# make sure anvil is running locally\n",
                "# $ anvil -p 3030\n",
                "\n",
-                "res = await ezkl.verify_evm(\n",
+                "res = ezkl.verify_evm(\n",
                "    addr,\n",
                "    proof_path,\n",
                "    \"http://127.0.0.1:3030\"\n",
--- a/examples/notebooks/keras_simple_demo.ipynb
+++ b/examples/notebooks/keras_simple_demo.ipynb
@@ -152,7 +152,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -175,7 +175,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs(settings_path = settings_path)"
+                "res = ezkl.get_srs(settings_path = settings_path)"
            ]
        },
        {
@@ -188,7 +188,7 @@
                "# now generate the witness file \n",
                "witness_path = \"witness.json\"\n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -284,4 +284,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/kmeans.ipynb
+++ b/examples/notebooks/kmeans.ipynb
@@ -155,7 +155,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -178,7 +178,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -190,7 +190,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -289,4 +289,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/kzg_vis.ipynb
+++ b/examples/notebooks/kzg_vis.ipynb
@@ -233,7 +233,7 @@
                "with open(cal_path, \"w\") as f:\n",
                "    json.dump(cal_data, f)\n",
                "\n",
-                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -262,7 +262,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "res = await ezkl.get_srs( settings_path)\n"
+                "res = ezkl.get_srs( settings_path)\n"
            ]
        },
        {
@@ -315,7 +315,7 @@
                "\n",
                "witness_path = \"witness.json\"\n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n"
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n"
            ]
        },
        {
@@ -429,7 +429,7 @@
                "abi_path = 'test.abi'\n",
                "sol_code_path = 'test.sol'\n",
                "\n",
-                "res = await ezkl.create_evm_verifier(\n",
+                "res = ezkl.create_evm_verifier(\n",
                "        vk_path,\n",
                "        \n",
                "        settings_path,\n",
@@ -460,7 +460,7 @@
                "\n",
                "address_path = os.path.join(\"address.json\")\n",
                "\n",
-                "res = await ezkl.deploy_evm(\n",
+                "res = ezkl.deploy_evm(\n",
                "    address_path,\n",
                "    sol_code_path,\n",
                "    'http://127.0.0.1:3030'\n",
@@ -481,7 +481,7 @@
                "# make sure anvil is running locally\n",
                "# $ anvil -p 3030\n",
                "\n",
-                "res = await ezkl.verify_evm(\n",
+                "res = ezkl.verify_evm(\n",
                "    addr,\n",
                "    proof_path,\n",
                "    \"http://127.0.0.1:3030\"\n",
--- a/examples/notebooks/lightgbm.ipynb
+++ b/examples/notebooks/lightgbm.ipynb
@@ -193,7 +193,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -216,7 +216,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -228,7 +228,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -347,4 +347,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/linear_regression.ipynb
+++ b/examples/notebooks/linear_regression.ipynb
@@ -142,7 +142,7 @@
                "# Serialize data into file:\n",
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -165,7 +165,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -177,7 +177,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -276,4 +276,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/little_transformer.ipynb
+++ b/examples/notebooks/little_transformer.ipynb
@@ -347,7 +347,7 @@
                "# Serialize data into file:\n",
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -370,7 +370,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -383,7 +383,7 @@
                "# now generate the witness file \n",
                "witness_path = \"gan_witness.json\"\n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -490,4 +490,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/logistic_regression.ipynb
+++ b/examples/notebooks/logistic_regression.ipynb
@@ -1,279 +0,0 @@
-{
-    "cells": [
-        {
-            "cell_type": "markdown",
-            "id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
-            "metadata": {},
-            "source": [
-                "## Logistic Regression\n",
-                "\n",
-                "\n",
-                "Sklearn based models are slightly finicky to get into a suitable onnx format. \n",
-                "This notebook showcases how to do so using the `hummingbird-ml` python package for a Logistic Regression model. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "95613ee9",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# check if notebook is in colab\n",
-                "try:\n",
-                "    # install ezkl\n",
-                "    import google.colab\n",
-                "    import subprocess\n",
-                "    import sys\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"hummingbird-ml\"])\n",
-                "\n",
-                "# rely on local installation of ezkl if the notebook is not in colab\n",
-                "except:\n",
-                "    pass\n",
-                "\n",
-                "import os\n",
-                "import torch\n",
-                "import ezkl\n",
-                "import json\n",
-                "from hummingbird.ml import convert\n",
-                "\n",
-                "\n",
-                "# here we create and (potentially train a model)\n",
-                "\n",
-                "# make sure you have the dependencies required here already installed\n",
-                "import numpy as np\n",
-                "from sklearn.linear_model import LogisticRegression\n",
-                "X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])\n",
-                "# y = 1 * x_0 + 2 * x_1 + 3\n",
-                "y = np.dot(X, np.array([1, 2])) + 3\n",
-                "reg = LogisticRegression().fit(X, y)\n",
-                "reg.score(X, y)\n",
-                "\n",
-                "circuit = convert(reg, \"torch\", X[:1]).model\n",
-                "\n",
-                "\n",
-                "\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "b37637c4",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "model_path = os.path.join('network.onnx')\n",
-                "compiled_model_path = os.path.join('network.compiled')\n",
-                "pk_path = os.path.join('test.pk')\n",
-                "vk_path = os.path.join('test.vk')\n",
-                "settings_path = os.path.join('settings.json')\n",
-                "\n",
-                "witness_path = os.path.join('witness.json')\n",
-                "data_path = os.path.join('input.json')"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "82db373a",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "\n",
-                "# export to onnx format\n",
-                "# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
-                "\n",
-                "# Input to the model\n",
-                "shape = X.shape[1:]\n",
-                "x = torch.rand(1, *shape, requires_grad=True)\n",
-                "torch_out = circuit(x)\n",
-                "# Export the model\n",
-                "torch.onnx.export(circuit,               # model being run\n",
-                "                  # model input (or a tuple for multiple inputs)\n",
-                "                  x,\n",
-                "                  # where to save the model (can be a file or file-like object)\n",
-                "                  \"network.onnx\",\n",
-                "                  export_params=True,        # store the trained parameter weights inside the model file\n",
-                "                  opset_version=10,          # the ONNX version to export the model to\n",
-                "                  do_constant_folding=True,  # whether to execute constant folding for optimization\n",
-                "                  input_names=['input'],   # the model's input names\n",
-                "                  output_names=['output'],  # the model's output names\n",
-                "                  dynamic_axes={'input': {0: 'batch_size'},    # variable length axes\n",
-                "                                'output': {0: 'batch_size'}})\n",
-                "\n",
-                "d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
-                "\n",
-                "data = dict(input_shapes=[shape],\n",
-                "            input_data=[d],\n",
-                "            output_data=[((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])\n",
-                "\n",
-                "# Serialize data into file:\n",
-                "json.dump(data, open(\"input.json\", 'w'))\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "d5e374a2",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "!RUST_LOG=trace\n",
-                "# TODO: Dictionary outputs\n",
-                "res = ezkl.gen_settings(model_path, settings_path)\n",
-                "assert res == True\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "cal_path = os.path.join(\"calibration.json\")\n",
-                "\n",
-                "data_array = (torch.randn(20, *shape).detach().numpy()).reshape([-1]).tolist()\n",
-                "\n",
-                "data = dict(input_data = [data_array])\n",
-                "\n",
-                "# Serialize data into file:\n",
-                "json.dump(data, open(cal_path, 'w'))\n",
-                "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
-                "assert res == True\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "3aa4f090",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "8b74dcee",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "18c8b7c7",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# now generate the witness file \n",
-                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
-                "assert os.path.isfile(witness_path)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "b1c561a8",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "# HERE WE SETUP THE CIRCUIT PARAMS\n",
-                "# WE GOT KEYS\n",
-                "# WE GOT CIRCUIT PARAMETERS\n",
-                "# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
-                "\n",
-                "\n",
-                "\n",
-                "res = ezkl.setup(\n",
-                "        compiled_model_path,\n",
-                "        vk_path,\n",
-                "        pk_path,\n",
-                "        \n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "assert os.path.isfile(vk_path)\n",
-                "assert os.path.isfile(pk_path)\n",
-                "assert os.path.isfile(settings_path)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "c384cbc8",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# GENERATE A PROOF\n",
-                "\n",
-                "\n",
-                "proof_path = os.path.join('test.pf')\n",
-                "\n",
-                "res = ezkl.prove(\n",
-                "        witness_path,\n",
-                "        compiled_model_path,\n",
-                "        pk_path,\n",
-                "        proof_path,\n",
-                "        \n",
-                "        \"single\",\n",
-                "    )\n",
-                "\n",
-                "print(res)\n",
-                "assert os.path.isfile(proof_path)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "76f00d41",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# VERIFY IT\n",
-                "\n",
-                "res = ezkl.verify(\n",
-                "        proof_path,\n",
-                "        settings_path,\n",
-                "        vk_path,\n",
-                "        \n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "print(\"verified\")"
-            ]
-        }
-    ],
-    "metadata": {
-        "kernelspec": {
-            "display_name": "Python 3 (ipykernel)",
-            "language": "python",
-            "name": "python3"
-        },
-        "language_info": {
-            "codemirror_mode": {
-                "name": "ipython",
-                "version": 3
-            },
-            "file_extension": ".py",
-            "mimetype": "text/x-python",
-            "name": "python",
-            "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3",
-            "version": "3.12.2"
-        }
-    },
-    "nbformat": 4,
-    "nbformat_minor": 5
-}
--- a/examples/notebooks/lstm.ipynb
+++ b/examples/notebooks/lstm.ipynb
@@ -139,7 +139,7 @@
                "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
                "assert res == True\n",
                "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -180,7 +180,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -193,7 +193,7 @@
                "# now generate the witness file \n",
                "witness_path = \"lstmwitness.json\"\n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -300,4 +300,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/mean_postgres.ipynb
+++ b/examples/notebooks/mean_postgres.ipynb
@@ -91,14 +91,11 @@
        "os.system(\"echo shovel is now installed. starting:\")\n",
        "\n",
        "command = [\"./shovel\", \"-config\", \"config.json\"]\n",
-        "proc = subprocess.Popen(command)\n",
+        "subprocess.Popen(command)\n",
        "\n",
        "os.system(\"echo shovel started.\")\n",
        "\n",
-        "time.sleep(10)\n",
-        "\n",
-        "# after we've fetched some data -- kill the process\n",
-        "proc.terminate()\n",
+        "time.sleep(5)\n",
        "\n"
      ]
    },
@@ -313,7 +310,7 @@
        "\n",
        "assert res == True\n",
        "\n",
-        "res = await ezkl.calibrate_settings(input_filename, onnx_filename, settings_filename, \"resources\")\n",
+        "res = ezkl.calibrate_settings(input_filename, onnx_filename, settings_filename, \"resources\")\n",
        "\n",
        "assert res == True"
      ]
@@ -390,7 +387,7 @@
        "witness_path = \"witness.json\"\n",
        "\n",
        "# generate the witness\n",
-        "res = await ezkl.gen_witness(\n",
+        "res = ezkl.gen_witness(\n",
        "        input_filename,\n",
        "        compiled_filename,\n",
        "        witness_path\n",
@@ -428,6 +425,16 @@
        "assert os.path.isfile(proof_path)\n",
        "\n"
      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# kill all shovel process \n",
+        "os.system(\"pkill -f shovel\")"
+      ]
    }
  ],
  "metadata": {
--- a/examples/notebooks/mnist_classifier.ipynb
+++ b/examples/notebooks/mnist_classifier.ipynb
@@ -323,7 +323,7 @@
        "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
        "assert res == True\n",
        "\n",
-        "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[2,7])\n",
+        "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[2,7])\n",
        "assert res == True"
      ]
    },
@@ -348,7 +348,7 @@
      "outputs": [],
      "source": [
        "# srs path\n",
-        "res = await ezkl.get_srs(settings_path)"
+        "res = ezkl.get_srs(settings_path)"
      ]
    },
    {
@@ -362,7 +362,7 @@
        "# now generate the witness file\n",
        "witness_path = \"witness.json\"\n",
        "\n",
-        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
@@ -469,7 +469,7 @@
        "abi_path = 'test.abi'\n",
        "sol_code_path = 'test_1.sol'\n",
        "\n",
-        "res = await ezkl.create_evm_verifier(\n",
+        "res = ezkl.create_evm_verifier(\n",
        "        vk_path,\n",
        "        settings_path,\n",
        "        sol_code_path,\n",
@@ -502,7 +502,7 @@
        "\n",
        "address_path = os.path.join(\"address.json\")\n",
        "\n",
-        "res = await ezkl.deploy_evm(\n",
+        "res = ezkl.deploy_evm(\n",
        "    address_path,\n",
        "    sol_code_path,\n",
        "    'http://127.0.0.1:3030'\n",
@@ -525,7 +525,7 @@
        "# make sure anvil is running locally\n",
        "# $ anvil -p 3030\n",
        "\n",
-        "res = await ezkl.verify_evm(\n",
+        "res = ezkl.verify_evm(\n",
        "    addr,\n",
        "    proof_path,\n",
        "    \"http://127.0.0.1:3030\"\n",
@@ -558,4 +558,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 0
-}
+}
--- a/examples/notebooks/mnist_gan.ipynb
+++ b/examples/notebooks/mnist_gan.ipynb
@@ -289,7 +289,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[0,6])"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[0,6])"
            ]
        },
        {
@@ -309,7 +309,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -321,7 +321,7 @@
                "# now generate the witness file \n",
                "witness_path = \"gan_witness.json\"\n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
--- a/examples/notebooks/mnist_gan_proof_splitting.ipynb
+++ b/examples/notebooks/mnist_gan_proof_splitting.ipynb
--- a/examples/notebooks/mnist_vae.ipynb
+++ b/examples/notebooks/mnist_vae.ipynb
@@ -215,7 +215,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -235,7 +235,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -247,7 +247,7 @@
                "# now generate the witness file\n",
                "witness_path = \"ae_witness.json\"\n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -451,7 +451,7 @@
                "res = ezkl.gen_settings(model_path, settings_path)\n",
                "assert res == True\n",
                "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n",
                "print(\"verified\")"
            ]
@@ -473,7 +473,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -485,7 +485,7 @@
                "# now generate the witness file \n",
                "witness_path = \"vae_witness.json\"\n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
--- a/examples/notebooks/nbeats_timeseries_forecasting.ipynb
+++ b/examples/notebooks/nbeats_timeseries_forecasting.ipynb
@@ -845,7 +845,7 @@
        "res = ezkl.gen_settings(model_path, settings_path)\n",
        "assert res == True\n",
        "\n",
-        "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", max_logrows = 20, scales = [3])\n",
+        "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", max_logrows = 20, scales = [3])\n",
        "assert res == True"
      ]
    },
@@ -870,7 +870,7 @@
      "outputs": [],
      "source": [
        "# srs path\n",
-        "res = await ezkl.get_srs( settings_path)"
+        "res = ezkl.get_srs( settings_path)"
      ]
    },
    {
@@ -881,7 +881,7 @@
      },
      "outputs": [],
      "source": [
-        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
@@ -993,4 +993,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 0
-}
+}
--- a/examples/notebooks/proof_splitting.ipynb
+++ b/examples/notebooks/proof_splitting.ipynb
@@ -261,7 +261,7 @@
            "source": [
                "# iterate over each submodel gen-settings, compile circuit and setup zkSNARK\n",
                "\n",
-                "async def setup(i):\n",
+                "def setup(i):\n",
                "    # file names\n",
                "    model_path = os.path.join('network_split_'+str(i)+'.onnx')\n",
                "    settings_path = os.path.join('settings_split_'+str(i)+'.json')\n",
@@ -282,7 +282,7 @@
                "\n",
                "    # generate settings for the current model\n",
                "    res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
-                "    res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", scales=[run_args.input_scale], max_logrows=run_args.logrows)\n",
+                "    res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", scales=[run_args.input_scale], max_logrows=run_args.logrows)\n",
                "    assert res == True\n",
                "\n",
                "    # load settings and print them to the console\n",
@@ -303,11 +303,11 @@
                "    assert os.path.isfile(vk_path)\n",
                "    assert os.path.isfile(pk_path)\n",
                "\n",
-                "    res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
+                "    res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
                "    run_args.input_scale = settings[\"model_output_scales\"][0]\n",
                "\n",
                "for i in range(2):\n",
-                "    await setup(i)\n"
+                "    setup(i)\n"
            ]
        },
        {
@@ -414,7 +414,7 @@
            "outputs": [],
            "source": [
                "for i in range(2):\n",
-                "    await setup(i)"
+                "    setup(i)"
            ]
        },
        {
@@ -466,7 +466,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.12.2"
+            "version": "3.9.15"
        },
        "orig_nbformat": 4
    },
--- a/examples/notebooks/random_forest.ipynb
+++ b/examples/notebooks/random_forest.ipynb
@@ -174,7 +174,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -196,7 +196,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -208,7 +208,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
--- a/examples/notebooks/set_membership.ipynb
+++ b/examples/notebooks/set_membership.ipynb
@@ -215,7 +215,7 @@
      "outputs": [],
      "source": [
        "# srs path\n",
-        "res = await ezkl.get_srs( settings_path)"
+        "res = ezkl.get_srs( settings_path)"
      ]
    },
    {
@@ -229,7 +229,7 @@
      "source": [
        "# now generate the witness file\n",
        "\n",
-        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
@@ -265,7 +265,7 @@
        "    # Serialize data into file:\n",
        "json.dump( data, open(data_path_faulty, 'w' ))\n",
        "\n",
-        "res = await ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path_faulty)\n",
+        "res = ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path_faulty)\n",
        "assert os.path.isfile(witness_path_faulty)"
      ]
    },
@@ -310,7 +310,7 @@
        "# Serialize data into file:\n",
        "json.dump( data, open(data_path_truthy, 'w' ))\n",
        "\n",
-        "res = await ezkl.gen_witness(data_path_truthy, compiled_model_path, witness_path_truthy)\n",
+        "res = ezkl.gen_witness(data_path_truthy, compiled_model_path, witness_path_truthy)\n",
        "assert os.path.isfile(witness_path_truthy)"
      ]
    },
@@ -482,7 +482,7 @@
      "source": [
        "import pytest\n",
        "def test_verification():\n",
-        "    with pytest.raises(RuntimeError, match='Failed to run verify: \\\\[halo2\\\\] The constraint system is not satisfied'):\n",
+        "    with pytest.raises(RuntimeError, match='Failed to run verify: The constraint system is not satisfied'):\n",
        "        ezkl.verify(\n",
        "            proof_path_faulty,\n",
        "            settings_path,\n",
@@ -514,7 +514,7 @@
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
-      "version": "3.12.3"
+      "version": "3.9.15"
    }
  },
  "nbformat": 4,
--- a/examples/notebooks/simple_demo_aggregated_proofs.ipynb
+++ b/examples/notebooks/simple_demo_aggregated_proofs.ipynb
@@ -193,7 +193,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -205,7 +205,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -290,7 +290,7 @@
            "source": [
                "# Generate a larger SRS. This is needed for the aggregated proof\n",
                "\n",
-                "res = await ezkl.get_srs(settings_path=None, logrows=21, commitment=ezkl.PyCommitments.KZG)"
+                "res = ezkl.get_srs(settings_path=None, logrows=21, commitment=ezkl.PyCommitments.KZG)"
            ]
        },
        {
@@ -374,7 +374,7 @@
                "sol_code_path = os.path.join(\"Verifier.sol\")\n",
                "abi_path = os.path.join(\"Verifier_ABI.json\")\n",
                "\n",
-                "res = await ezkl.create_evm_verifier_aggr(\n",
+                "res = ezkl.create_evm_verifier_aggr(\n",
                "    [settings_path],\n",
                "    aggregate_vk_path,\n",
                "    sol_code_path,\n",
@@ -404,4 +404,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/simple_demo_all_public.ipynb
+++ b/examples/notebooks/simple_demo_all_public.ipynb
@@ -157,7 +157,6 @@
        {
            "cell_type": "code",
            "execution_count": null,
-            "id": "b78d3cbf",
            "metadata": {},
            "outputs": [],
            "source": [
@@ -171,7 +170,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -205,7 +204,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -299,7 +298,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.12.3"
+            "version": "3.9.15"
        }
    },
    "nbformat": 4,
--- a/examples/notebooks/simple_demo_public_input_output.ipynb
+++ b/examples/notebooks/simple_demo_public_input_output.ipynb
@@ -169,7 +169,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -191,7 +191,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -203,7 +203,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
--- a/examples/notebooks/simple_demo_public_network_output.ipynb
+++ b/examples/notebooks/simple_demo_public_network_output.ipynb
@@ -170,7 +170,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -192,7 +192,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -204,7 +204,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
--- a/examples/notebooks/sklearn_mlp.ipynb
+++ b/examples/notebooks/sklearn_mlp.ipynb
@@ -149,7 +149,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -171,7 +171,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -183,7 +183,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -282,4 +282,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/solvency.ipynb
+++ b/examples/notebooks/solvency.ipynb
@@ -250,7 +250,7 @@
      "outputs": [],
      "source": [
        "# srs path\n",
-        "res = await ezkl.get_srs( settings_path)"
+        "res = ezkl.get_srs( settings_path)"
      ]
    },
    {
@@ -297,7 +297,7 @@
        "\n",
        "witness_path = \"witness.json\"\n",
        "\n",
-        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
+        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
        "assert os.path.isfile(witness_path)\n",
        "\n",
        "# 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",
@@ -411,7 +411,7 @@
      "source": [
        "# now generate the witness file\n",
        "\n",
-        "res = await ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path, vk_path)\n",
+        "res = ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path, vk_path)\n",
        "assert os.path.isfile(witness_path)\n",
        "\n",
        "# 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",
@@ -478,11 +478,12 @@
        "import pytest\n",
        "\n",
        "def test_verification():\n",
-        "    with pytest.raises(RuntimeError, match='Failed to run verify: \\\\[halo2\\\\] The constraint system is not satisfied'):\n",
+        "    with pytest.raises(RuntimeError, match='Failed to run verify: The constraint system is not satisfied'):\n",
        "        ezkl.verify(\n",
        "            proof_path,\n",
        "            settings_path,\n",
        "            vk_path,\n",
+        "            \n",
        "        )\n",
        "\n",
        "# Run the test function\n",
@@ -509,9 +510,9 @@
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
-      "version": "3.12.3"
+      "version": "3.9.15"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/stacked_regression.ipynb
+++ b/examples/notebooks/stacked_regression.ipynb
@@ -167,7 +167,7 @@
                "res = ezkl.gen_settings(model_path, settings_path)\n",
                "assert res == True\n",
                "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True"
            ]
        },
@@ -187,7 +187,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -209,7 +209,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -221,7 +221,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -320,4 +320,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/svm.ipynb
+++ b/examples/notebooks/svm.ipynb
@@ -39,7 +39,7 @@
                "import json\n",
                "import numpy as np\n",
                "from sklearn.svm import SVC\n",
-                "from hummingbird.ml import convert\n",
+                "import sk2torch\n",
                "import torch\n",
                "import ezkl\n",
                "import os\n",
@@ -59,11 +59,11 @@
                "# Train an SVM on the data and wrap it in PyTorch.\n",
                "sk_model = SVC(probability=True)\n",
                "sk_model.fit(xs, ys)\n",
-                "model = convert(sk_model, \"torch\").model\n",
+                "model = sk2torch.wrap(sk_model)\n",
+                "\n",
                "\n",
                "\n",
                "\n",
-                "model\n",
                "\n"
            ]
        },
@@ -84,6 +84,33 @@
                "data_path = os.path.join('input.json')"
            ]
        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "7f0ca328",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import matplotlib.pyplot as plt\n",
+                "# Create a coordinate grid to compute a vector field on.\n",
+                "spaced = np.linspace(-2, 2, num=25)\n",
+                "grid_xs = torch.tensor([[x, y] for x in spaced for y in spaced], requires_grad=True)\n",
+                "\n",
+                "\n",
+                "# Compute the gradients of the SVM output.\n",
+                "outputs = model.predict_proba(grid_xs)[:, 1]\n",
+                "(input_grads,) = torch.autograd.grad(outputs.sum(), (grid_xs,))\n",
+                "\n",
+                "\n",
+                "# Create a quiver plot of the vector field.\n",
+                "plt.quiver(\n",
+                "    grid_xs[:, 0].detach().numpy(),\n",
+                "    grid_xs[:, 1].detach().numpy(),\n",
+                "    input_grads[:, 0].detach().numpy(),\n",
+                "    input_grads[:, 1].detach().numpy(),\n",
+                ")\n"
+            ]
+        },
        {
            "cell_type": "code",
            "execution_count": null,
@@ -92,14 +119,14 @@
            "outputs": [],
            "source": [
                "\n",
-                "spaced = np.linspace(-2, 2, num=25)\n",
-                "grid_xs = torch.tensor([[x, y] for x in spaced for y in spaced], requires_grad=True)\n",
+                "\n",
                "# export to onnx format\n",
                "# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
                "\n",
                "# Input to the model\n",
                "shape = xs.shape[1:]\n",
                "x = grid_xs[0:1]\n",
+                "torch_out = model.predict(x)\n",
                "# Export the model\n",
                "torch.onnx.export(model,               # model being run\n",
                "                  # model input (or a tuple for multiple inputs)\n",
@@ -116,7 +143,9 @@
                "\n",
                "d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
                "\n",
-                "data = dict(input_data=[d])\n",
+                "data = dict(input_shapes=[shape],\n",
+                "            input_data=[d],\n",
+                "            output_data=[o.reshape([-1]).tolist() for o in torch_out])\n",
                "\n",
                "# Serialize data into file:\n",
                "json.dump(data, open(\"input.json\", 'w'))\n"
@@ -138,7 +167,6 @@
        {
            "cell_type": "code",
            "execution_count": null,
-            "id": "0bee4d7f",
            "metadata": {},
            "outputs": [],
            "source": [
@@ -152,7 +180,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -174,7 +202,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -186,13 +214,13 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
        {
            "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 10,
            "id": "b1c561a8",
            "metadata": {},
            "outputs": [],
@@ -392,7 +420,7 @@
                "res = ezkl.gen_settings(model_path, settings_path)\n",
                "assert res == True\n",
                "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True"
            ]
        }
@@ -413,7 +441,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.12.3"
+            "version": "3.9.15"
        }
    },
    "nbformat": 4,
--- a/examples/notebooks/tictactoe_autoencoder.ipynb
+++ b/examples/notebooks/tictactoe_autoencoder.ipynb
@@ -13,7 +13,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -57,7 +57,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 2,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -119,7 +119,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 3,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -163,7 +163,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 4,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -217,7 +217,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 6,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -637,7 +637,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [11])"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [11])"
            ]
        },
        {
@@ -646,7 +646,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "await ezkl.get_srs( settings_path)"
+                "ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -683,7 +683,7 @@
                "    data = json.load(f)\n",
                "    print(len(data['input_data'][0]))\n",
                "\n",
-                "await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
+                "ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
            ]
        },
        {
--- a/examples/notebooks/tictactoe_binary_classification.ipynb
+++ b/examples/notebooks/tictactoe_binary_classification.ipynb
@@ -525,7 +525,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [4])"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [4])"
            ]
        },
        {
@@ -572,7 +572,7 @@
                "    data = json.load(f)\n",
                "    print(len(data['input_data'][0]))\n",
                "\n",
-                "await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
+                "ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
            ]
        },
        {
--- a/examples/notebooks/variance.ipynb
+++ b/examples/notebooks/variance.ipynb
@@ -24,7 +24,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": 1,
+      "execution_count": null,
      "metadata": {
        "id": "9Byiv2Nc2MsK"
      },
@@ -49,11 +49,7 @@
        "import pandas as pd\n",
        "import requests\n",
        "import json\n",
-        "import os\n",
-        "\n",
-        "import logging\n",
-        "\n",
-        "logging.basicConfig(level=logging.INFO)"
+        "import os"
      ]
    },
    {
@@ -67,7 +63,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": 2,
+      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
@@ -75,15 +71,7 @@
        "id": "x1vl9ZXF3EEW",
        "outputId": "bda21d02-fe5f-4fb2-8106-f51a8e2e67aa"
      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "cpu\n"
-          ]
-        }
-      ],
+      "outputs": [],
      "source": [
        "from torch import nn\n",
        "import torch\n",
@@ -145,7 +133,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": 3,
+      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
@@ -153,18 +141,7 @@
        "id": "6RAMplxk5xPk",
        "outputId": "bd2158fe-0c00-44fd-e632-6a3f70cdb7c9"
      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "1715422870\n",
-            "1714818070\n",
-            "https://api.coingecko.com/api/v3/coins/ethereum/market_chart/range?vs_currency=usd&from=1714818070&to=1715422870\n",
-            "<Response [200]>\n"
-          ]
-        }
-      ],
+      "outputs": [],
      "source": [
        "\n",
        "def get_url(coin, currency, start, end):\n",
@@ -197,7 +174,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": 4,
+      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
@@ -206,115 +183,7 @@
        "id": "WSj1Uxln65vf",
        "outputId": "51422d71-9680-4b51-c4df-e400d20f988b"
      },
-      "outputs": [
-        {
-          "data": {
-            "text/html": [
-              "<div>\n",
-              "<style scoped>\n",
-              "    .dataframe tbody tr th:only-of-type {\n",
-              "        vertical-align: middle;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe tbody tr th {\n",
-              "        vertical-align: top;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe thead th {\n",
-              "        text-align: right;\n",
-              "    }\n",
-              "</style>\n",
-              "<table border=\"1\" class=\"dataframe\">\n",
-              "  <thead>\n",
-              "    <tr style=\"text-align: right;\">\n",
-              "      <th></th>\n",
-              "      <th>time</th>\n",
-              "      <th>prices</th>\n",
-              "    </tr>\n",
-              "  </thead>\n",
-              "  <tbody>\n",
-              "    <tr>\n",
-              "      <th>0</th>\n",
-              "      <td>1714820485367</td>\n",
-              "      <td>3146.785806</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>1</th>\n",
-              "      <td>1714824033868</td>\n",
-              "      <td>3127.968728</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2</th>\n",
-              "      <td>1714828058243</td>\n",
-              "      <td>3156.141681</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>3</th>\n",
-              "      <td>1714831650751</td>\n",
-              "      <td>3124.834064</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>4</th>\n",
-              "      <td>1714834972229</td>\n",
-              "      <td>3133.115333</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>...</th>\n",
-              "      <td>...</td>\n",
-              "      <td>...</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>163</th>\n",
-              "      <td>1715407579346</td>\n",
-              "      <td>2918.049749</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>164</th>\n",
-              "      <td>1715411090715</td>\n",
-              "      <td>2920.330834</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>165</th>\n",
-              "      <td>1715414554830</td>\n",
-              "      <td>2923.986611</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>166</th>\n",
-              "      <td>1715418419843</td>\n",
-              "      <td>2910.537671</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>167</th>\n",
-              "      <td>1715421675338</td>\n",
-              "      <td>2907.702307</td>\n",
-              "    </tr>\n",
-              "  </tbody>\n",
-              "</table>\n",
-              "<p>168 rows × 2 columns</p>\n",
-              "</div>"
-            ],
-            "text/plain": [
-              "              time       prices\n",
-              "0    1714820485367  3146.785806\n",
-              "1    1714824033868  3127.968728\n",
-              "2    1714828058243  3156.141681\n",
-              "3    1714831650751  3124.834064\n",
-              "4    1714834972229  3133.115333\n",
-              "..             ...          ...\n",
-              "163  1715407579346  2918.049749\n",
-              "164  1715411090715  2920.330834\n",
-              "165  1715414554830  2923.986611\n",
-              "166  1715418419843  2910.537671\n",
-              "167  1715421675338  2907.702307\n",
-              "\n",
-              "[168 rows x 2 columns]"
-            ]
-          },
-          "execution_count": 4,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
+      "outputs": [],
      "source": [
        "df = pd.DataFrame(new_data)\n",
        "df\n"
@@ -331,7 +200,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": 5,
+      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
@@ -348,7 +217,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": 6,
+      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
@@ -356,98 +225,7 @@
        "id": "4MmE9SX66_Il",
        "outputId": "16403639-66a4-4280-ac7f-6966b75de5a3"
      },
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "INFO:ezkl.execute:SRS already exists at that path\n",
-            "INFO:ezkl.execute:num calibration batches: 1\n",
-            "INFO:ezkl.execute:read 16777476 bytes from file (vector of len = 16777476)\n",
-            "WARNING:ezkl.execute:\n",
-            "\n",
-            " <------------- Numerical Fidelity Report (input_scale: 4, param_scale: 4, scale_input_multiplier: 10) ------------->\n",
-            "\n",
-            "+------------+--------------+-----------+-----------+----------------+------------------+---------------+---------------+--------------------+--------------------+------------------------+\n",
-            "| mean_error | median_error | max_error | min_error | mean_abs_error | median_abs_error | max_abs_error | min_abs_error | mean_squared_error | mean_percent_error | mean_abs_percent_error |\n",
-            "+------------+--------------+-----------+-----------+----------------+------------------+---------------+---------------+--------------------+--------------------+------------------------+\n",
-            "| -727.9929  | -727.9929    | -727.9929 | -727.9929 | 727.9929       | 727.9929         | 727.9929      | 727.9929      | 529973.7           | -0.24999964        | 0.24999964             |\n",
-            "+------------+--------------+-----------+-----------+----------------+------------------+---------------+---------------+--------------------+--------------------+------------------------+\n",
-            "\n",
-            "\n",
-            "INFO:ezkl.execute:file hash: 41509f380362a8d14401c5ae92073154922fe23e45459ce6f696f58607655db7\n"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "{\n",
-            "  \"run_args\": {\n",
-            "    \"tolerance\": {\n",
-            "      \"val\": 0.0,\n",
-            "      \"scale\": 1.0\n",
-            "    },\n",
-            "    \"input_scale\": 4,\n",
-            "    \"param_scale\": 4,\n",
-            "    \"scale_rebase_multiplier\": 10,\n",
-            "    \"lookup_range\": [\n",
-            "      0,\n",
-            "      0\n",
-            "    ],\n",
-            "    \"logrows\": 6,\n",
-            "    \"num_inner_cols\": 2,\n",
-            "    \"variables\": [\n",
-            "      [\n",
-            "        \"batch_size\",\n",
-            "        1\n",
-            "      ]\n",
-            "    ],\n",
-            "    \"input_visibility\": \"Private\",\n",
-            "    \"output_visibility\": \"Public\",\n",
-            "    \"param_visibility\": \"Private\",\n",
-            "    \"div_rebasing\": false,\n",
-            "    \"rebase_frac_zero_constants\": false,\n",
-            "    \"check_mode\": \"UNSAFE\",\n",
-            "    \"commitment\": \"KZG\"\n",
-            "  },\n",
-            "  \"num_rows\": 21,\n",
-            "  \"total_assignments\": 42,\n",
-            "  \"total_const_size\": 0,\n",
-            "  \"total_dynamic_col_size\": 0,\n",
-            "  \"num_dynamic_lookups\": 0,\n",
-            "  \"num_shuffles\": 0,\n",
-            "  \"total_shuffle_col_size\": 0,\n",
-            "  \"model_instance_shapes\": [\n",
-            "    [\n",
-            "      1\n",
-            "    ]\n",
-            "  ],\n",
-            "  \"model_output_scales\": [\n",
-            "    8\n",
-            "  ],\n",
-            "  \"model_input_scales\": [\n",
-            "    4\n",
-            "  ],\n",
-            "  \"module_sizes\": {\n",
-            "    \"polycommit\": [],\n",
-            "    \"poseidon\": [\n",
-            "      0,\n",
-            "      [\n",
-            "        0\n",
-            "      ]\n",
-            "    ]\n",
-            "  },\n",
-            "  \"required_lookups\": [],\n",
-            "  \"required_range_checks\": [],\n",
-            "  \"check_mode\": \"UNSAFE\",\n",
-            "  \"version\": \"0.0.0\",\n",
-            "  \"num_blinding_factors\": null,\n",
-            "  \"timestamp\": 1715422871248\n",
-            "}\n"
-          ]
-        }
-      ],
+      "outputs": [],
      "source": [
        "# generate settings\n",
        "onnx_filename = os.path.join('lol.onnx')\n",
@@ -458,9 +236,9 @@
        "\n",
        "\n",
        "ezkl.gen_settings(onnx_filename, settings_filename)\n",
-        "await ezkl.calibrate_settings(\n",
+        "ezkl.calibrate_settings(\n",
        "    input_filename, onnx_filename, settings_filename, \"resources\", scales = [4])\n",
-        "res = await ezkl.get_srs(settings_filename)\n",
+        "res = ezkl.get_srs(settings_filename)\n",
        "ezkl.compile_circuit(onnx_filename, compiled_filename, settings_filename)\n",
        "\n",
        "# show the settings.json\n",
@@ -481,24 +259,7 @@
      "metadata": {
        "id": "fULvvnK7_CMb"
      },
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "INFO:ezkl.pfsys.srs:loading srs from \"/Users/dante/.ezkl/srs/kzg6.srs\"\n",
-            "INFO:ezkl.execute:downsizing params to 6 logrows\n",
-            "INFO:ezkl.graph.model:model layout...\n",
-            "INFO:ezkl.pfsys:VK took 0.8\n",
-            "INFO:ezkl.graph.model:model layout...\n",
-            "INFO:ezkl.pfsys:PK took 0.2\n",
-            "INFO:ezkl.pfsys:saving verification key 💾\n",
-            "INFO:ezkl.pfsys:done saving verification key ✅\n",
-            "INFO:ezkl.pfsys:saving proving key 💾\n",
-            "INFO:ezkl.pfsys:done saving proving key ✅\n"
-          ]
-        }
-      ],
+      "outputs": [],
      "source": [
        "pk_path = os.path.join('test.pk')\n",
        "vk_path = os.path.join('test.vk')\n",
@@ -520,20 +281,20 @@
    },
    {
      "cell_type": "code",
-      "execution_count": 8,
+      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "\n",
        "witness_path = \"witness.json\"\n",
        "\n",
-        "res = await ezkl.gen_witness(input_filename, compiled_filename, witness_path)\n",
+        "res = ezkl.gen_witness(input_filename, compiled_filename, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
    {
      "cell_type": "code",
-      "execution_count": 9,
+      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
@@ -541,34 +302,7 @@
        "id": "Oog3j6Kd-Wed",
        "outputId": "5839d0c1-5b43-476e-c2f8-6707de562260"
      },
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "INFO:ezkl.pfsys:loading proving key from \"test.pk\"\n",
-            "INFO:ezkl.pfsys:done loading proving key ✅\n",
-            "INFO:ezkl.pfsys.srs:loading srs from \"/Users/dante/.ezkl/srs/kzg6.srs\"\n",
-            "INFO:ezkl.execute:downsizing params to 6 logrows\n",
-            "INFO:ezkl.pfsys:proof started...\n",
-            "INFO:ezkl.graph.model:model layout...\n",
-            "INFO:ezkl.pfsys:proof took 0.15\n",
-            "INFO:ezkl.pfsys.srs:loading srs from \"/Users/dante/.ezkl/srs/kzg6.srs\"\n",
-            "INFO:ezkl.execute:downsizing params to 6 logrows\n",
-            "INFO:ezkl.pfsys:loading verification key from \"test.vk\"\n",
-            "INFO:ezkl.pfsys:done loading verification key ✅\n",
-            "INFO:ezkl.execute:verify took 0.2\n",
-            "INFO:ezkl.execute:verified: true\n"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "verified\n"
-          ]
-        }
-      ],
+      "outputs": [],
      "source": [
        "# prove the zk circuit\n",
        "# GENERATE A PROOF\n",
@@ -617,7 +351,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": 10,
+      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
@@ -626,26 +360,7 @@
        "id": "fodkNgwS70FM",
        "outputId": "827b5efd-f74f-44de-c114-861b3a86daf2"
      },
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "INFO:ezkl.pfsys.srs:loading srs from \"/Users/dante/.ezkl/srs/kzg6.srs\"\n",
-            "INFO:ezkl.execute:downsizing params to 6 logrows\n",
-            "INFO:ezkl.pfsys:loading verification key from \"test.vk\"\n",
-            "INFO:ezkl.pfsys:done loading verification key ✅\n"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "test.vk\n",
-            "settings.json\n"
-          ]
-        }
-      ],
+      "outputs": [],
      "source": [
        "# first we need to create evm verifier\n",
        "print(vk_path)\n",
@@ -655,7 +370,7 @@
        "abi_path = 'test.abi'\n",
        "sol_code_path = 'test.sol'\n",
        "\n",
-        "res = await ezkl.create_evm_verifier(\n",
+        "res = ezkl.create_evm_verifier(\n",
        "        vk_path,\n",
        "        settings_filename,\n",
        "        sol_code_path,\n",
@@ -666,18 +381,9 @@
    },
    {
      "cell_type": "code",
-      "execution_count": 11,
+      "execution_count": null,
      "metadata": {},
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "INFO:ezkl.eth:using chain 31337\n",
-            "INFO:ezkl.execute:Contract deployed at: 0x998abeb3e57409262ae5b751f60747921b33613e\n"
-          ]
-        }
-      ],
+      "outputs": [],
      "source": [
        "# Make sure anvil is running locally first\n",
        "# run with $ anvil -p 3030\n",
@@ -685,9 +391,8 @@
        "import json\n",
        "\n",
        "address_path = os.path.join(\"address.json\")\n",
-        "sol_code_path = 'test.sol'\n",
-        "# await\n",
-        "res = await ezkl.deploy_evm(\n",
+        "\n",
+        "res = ezkl.deploy_evm(\n",
        "    address_path,\n",
        "    sol_code_path,\n",
        "    'http://127.0.0.1:3030'\n",
@@ -701,26 +406,16 @@
    },
    {
      "cell_type": "code",
-      "execution_count": 12,
+      "execution_count": null,
      "metadata": {},
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "INFO:ezkl.eth:using chain 31337\n",
-            "INFO:ezkl.eth:estimated verify gas cost: 399775\n",
-            "INFO:ezkl.execute:Solidity verification result: true\n"
-          ]
-        }
-      ],
+      "outputs": [],
      "source": [
        "# read the address from addr_path\n",
        "addr = None\n",
        "with open(address_path, 'r') as f:\n",
        "    addr = f.read()\n",
        "\n",
-        "res = await ezkl.verify_evm(\n",
+        "res = ezkl.verify_evm(\n",
        "    addr,\n",
        "    proof_path,\n",
        "    \"http://127.0.0.1:3030\"\n",
@@ -756,7 +451,7 @@
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
-      "version": "3.12.2"
+      "version": "3.9.15"
    }
  },
  "nbformat": 4,
--- a/examples/notebooks/verifier_abi.json
+++ b/examples/notebooks/verifier_abi.json
@@ -1 +0,0 @@
-[{"type":"function","name":"verifyProof","inputs":[{"name":"proof","type":"bytes","internalType":"bytes"},{"name":"instances","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"}]
--- a/examples/notebooks/voice_judge.ipynb
+++ b/examples/notebooks/voice_judge.ipynb
@@ -629,7 +629,7 @@
            "source": [
                "\n",
                "\n",
-                "res = await ezkl.calibrate_settings(val_data, model_path, settings_path, \"resources\", scales = [4])\n",
+                "res = ezkl.calibrate_settings(val_data, model_path, settings_path, \"resources\", scales = [4])\n",
                "assert res == True\n",
                "print(\"verified\")\n"
            ]
@@ -660,7 +660,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "res = await ezkl.get_srs(settings_path)"
+                "res = ezkl.get_srs(settings_path)"
            ]
        },
        {
@@ -680,7 +680,7 @@
                "\n",
                "witness_path = \"witness.json\"\n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -807,7 +807,7 @@
                "settings_path = os.path.join('settings.json')\n",
                "\n",
                "\n",
-                "res = await ezkl.create_evm_verifier(\n",
+                "res = ezkl.create_evm_verifier(\n",
                "        vk_path,\n",
                "        \n",
                "        settings_path,\n",
@@ -847,7 +847,7 @@
                "\n",
                "address_path = os.path.join(\"address.json\")\n",
                "\n",
-                "res = await ezkl.deploy_evm(\n",
+                "res = ezkl.deploy_evm(\n",
                "    address_path,\n",
                "    sol_code_path,\n",
                "    'http://127.0.0.1:3030'\n",
@@ -868,7 +868,7 @@
                "# make sure anvil is running locally\n",
                "# $ anvil -p 3030\n",
                "\n",
-                "res = await ezkl.verify_evm(\n",
+                "res = ezkl.verify_evm(\n",
                "    addr,\n",
                "    proof_path,\n",
                "    \"http://127.0.0.1:3030\"\n",
@@ -905,4 +905,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 2
-}
+}
--- a/examples/notebooks/world_rotation.ipynb
+++ b/examples/notebooks/world_rotation.ipynb
@@ -242,7 +242,6 @@
  {
   "cell_type": "code",
   "execution_count": null,
-   "id": "2007dc77",
   "metadata": {},
   "outputs": [],
   "source": [
@@ -258,7 +257,6 @@
  },
  {
   "cell_type": "markdown",
-   "id": "ab993958",
   "metadata": {},
   "source": [
    "As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
@@ -274,7 +272,7 @@
   "outputs": [],
   "source": [
    "# srs path\n",
-    "res = await ezkl.get_srs( settings_path)"
+    "res = ezkl.get_srs( settings_path)"
   ]
  },
  {
@@ -286,13 +284,12 @@
   "source": [
    "# now generate the witness file \n",
    "\n",
-    "witness = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+    "witness = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
    "assert os.path.isfile(witness_path)"
   ]
  },
  {
   "cell_type": "markdown",
-   "id": "ad58432e",
   "metadata": {},
   "source": [
    "Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
@@ -320,7 +317,6 @@
  },
  {
   "cell_type": "markdown",
-   "id": "1746c8d1",
   "metadata": {},
   "source": [
    "We can now create an EVM verifier contract from our circuit. This contract will be deployed to the chain we are using. In this case we are using a local anvil instance."
@@ -329,15 +325,15 @@
  {
   "cell_type": "code",
   "execution_count": null,
-   "id": "d1920c0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "abi_path = 'test.abi'\n",
    "sol_code_path = 'test.sol'\n",
    "\n",
-    "res = await ezkl.create_evm_verifier(\n",
+    "res = ezkl.create_evm_verifier(\n",
    "        vk_path,\n",
+    "        \n",
    "        settings_path,\n",
    "        sol_code_path,\n",
    "        abi_path,\n",
@@ -348,7 +344,6 @@
  {
   "cell_type": "code",
   "execution_count": null,
-   "id": "0fd7f22b",
   "metadata": {},
   "outputs": [],
   "source": [
@@ -356,7 +351,7 @@
    "\n",
    "addr_path_verifier = \"addr_verifier.txt\"\n",
    "\n",
-    "res = await ezkl.deploy_evm(\n",
+    "res = ezkl.deploy_evm(\n",
    "    addr_path_verifier,\n",
    "    sol_code_path,\n",
    "    'http://127.0.0.1:3030'\n",
@@ -367,7 +362,6 @@
  },
  {
   "cell_type": "markdown",
-   "id": "9c0dffab",
   "metadata": {},
   "source": [
    "With the vanilla verifier deployed, we can now create the data attestation contract, which will read in the instances from the calldata to the verifier, attest to them, call the verifier and then return the result. \n",
@@ -377,7 +371,6 @@
  {
   "cell_type": "code",
   "execution_count": null,
-   "id": "cc888848",
   "metadata": {},
   "outputs": [],
   "source": []
@@ -385,7 +378,6 @@
  {
   "cell_type": "code",
   "execution_count": null,
-   "id": "c2db14d7",
   "metadata": {},
   "outputs": [],
   "source": [
@@ -393,7 +385,7 @@
    "sol_code_path = 'test.sol'\n",
    "input_path = 'input.json'\n",
    "\n",
-    "res = await ezkl.create_evm_data_attestation(\n",
+    "res = ezkl.create_evm_data_attestation(\n",
    "        input_path,\n",
    "        settings_path,\n",
    "        sol_code_path,\n",
@@ -404,13 +396,12 @@
  {
   "cell_type": "code",
   "execution_count": null,
-   "id": "5a018ba6",
   "metadata": {},
   "outputs": [],
   "source": [
    "addr_path_da = \"addr_da.txt\"\n",
    "\n",
-    "res = await ezkl.deploy_da_evm(\n",
+    "res = ezkl.deploy_da_evm(\n",
    "        addr_path_da,\n",
    "        input_path,\n",
    "        settings_path,\n",
@@ -421,7 +412,6 @@
  },
  {
   "cell_type": "markdown",
-   "id": "2adad845",
   "metadata": {},
   "source": [
    "Now we can pull in the data from the contract and calculate a new set of coordinates. We then rotate the world by 1 transform and submit the proof to the contract. The contract could then update the world rotation (logic not inserted here). For demo purposes we do this repeatedly, rotating the world by 1 transform. "
@@ -454,7 +444,6 @@
  },
  {
   "cell_type": "markdown",
-   "id": "90eda56e",
   "metadata": {},
   "source": [
    "Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
@@ -539,7 +528,7 @@
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
+   "version": "3.9.15"
  }
 },
 "nbformat": 4,
--- a/examples/notebooks/xgboost.ipynb
+++ b/examples/notebooks/xgboost.ipynb
@@ -193,7 +193,7 @@
                "with open(cal_path, \"w\") as f:\n",
                "    json.dump(cal_data, f)\n",
                "\n",
-                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -215,7 +215,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = await ezkl.get_srs( settings_path)"
+                "res = ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -227,7 +227,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -346,4 +346,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/onnx/1l_conv_transpose/network.compiled
+++ b/examples/onnx/1l_conv_transpose/network.compiled
--- a/examples/onnx/1l_conv_transpose/settings.json
+++ b/examples/onnx/1l_conv_transpose/settings.json
@@ -1 +0,0 @@
-{"run_args":{"tolerance":{"val":0.0,"scale":1.0},"input_scale":7,"param_scale":7,"scale_rebase_multiplier":10,"lookup_range":[0,0],"logrows":13,"variables":[["batch_size",1]],"input_visibility":"Private","output_visibility":"Public","param_visibility":"Private"},"num_constraints":5619,"total_const_size":513,"model_instance_shapes":[[1,3,10,10]],"model_output_scales":[14],"model_input_scales":[7],"module_sizes":{"kzg":[],"poseidon":[0,[0]],"elgamal":[0,[0]]},"required_lookups":[],"check_mode":"UNSAFE","version":"0.0.0","num_blinding_factors":null}
--- a/examples/onnx/lenet_5/input.json
+++ b/examples/onnx/lenet_5/input.json
--- a/examples/onnx/lenet_5/network.onnx
+++ b/examples/onnx/lenet_5/network.onnx
--- a/examples/onnx/lstm_medium/input.json
+++ b/examples/onnx/lstm_medium/input.json
@@ -1,9 +0,0 @@
-{
-  "input_data": [
-    [
-      1.514470100402832, 1.519423007965088, 1.5182757377624512,
-      1.5262789726257324, 1.5298409461975098
-    ]
-  ],
-  "output_data": [[-0.1862019]]
-}
--- a/examples/onnx/lstm_medium/network.onnx
+++ b/examples/onnx/lstm_medium/network.onnx
--- a/examples/onnx/multihead_attention/gen.py
+++ b/examples/onnx/multihead_attention/gen.py
@@ -104,5 +104,5 @@ json.dump(data, open("input.json", 'w'))
 # ezkl.gen_settings("network.onnx", "settings.json")

 # !RUST_LOG = full
-# res = await ezkl.calibrate_settings(
+# res = ezkl.calibrate_settings(
 #     "input.json", "network.onnx", "settings.json", "resources")
--- a/examples/onnx/smallworm/.gitattributes
+++ b/examples/onnx/smallworm/.gitattributes
@@ -1 +0,0 @@
-network.onnx filter=lfs diff=lfs merge=lfs -text
--- a/examples/onnx/smallworm/Readme.md
+++ b/examples/onnx/smallworm/Readme.md
@@ -1,47 +0,0 @@
-## The worm 
-
-This is an onnx file for a [WormVAE](https://github.com/TuragaLab/wormvae?tab=readme-ov-file) model, which is a VAE / latent-space representation of the C. elegans connectome.
-
-The model "is a large-scale latent variable model with a very high-dimensional latent space
-consisting of voltage dynamics of 300 neurons over 5 minutes of time at the simulation frequency
-of 160 Hz. The generative model for these latent variables is described by stochastic differential
-equations modeling the nonlinear dynamics of the network activity." (see [here](https://openreview.net/pdf?id=CJzi3dRlJE-)). 
-
-In effect this is a generative model for a worm's voltage dynamics, which can be used to generate new worm-like voltage dynamics given previous connectome state.
-
-Using ezkl you can create a zk circuit equivalent to the wormvae model, allowing you to "prove" execution of the worm model. If you're feeling particularly adventurous, you can also use the zk circuit to generate new worm-state that can be verified on chain. 
-
-To do so you'll first want to fetch the files using git-lfs (as the onnx file is too large to be stored in git). 
-
-```bash
-git lfs fetch --all
-```
-
-You'll then want to use the usual ezkl loop to generate the zk circuit. We recommend using fixed visibility for the model parameters, as the model is quite large and this will prune the circuit significantly. 
-
-```bash
-ezkl gen-settings --param-visibility=fixed
-cp input.json calibration.json
-ezkl calibrate-settings
-ezkl compile-circuit
-ezkl gen-witness
-ezkl prove
-```
-
-You might also need to aggregate the proof to get it to fit on chain.
-
-```bash
-ezkl aggregate
-```
-
-You can then create a smart contract that verifies this aggregate proof
-
-```bash
-ezkl create-evm-verifier-aggr
-```
-
-This can then be deployed on the chain of your choice.
-
-
-> Note: the model is large and thus we recommend a machine with at least 512GB of RAM to run the above commands. If you're ever compute constrained you can always use the lilith service to generate the zk circuit. Message us on discord or telegram for more details :)
-
--- a/examples/onnx/smallworm/input.json
+++ b/examples/onnx/smallworm/input.json
--- a/examples/onnx/smallworm/network.onnx
+++ b/examples/onnx/smallworm/network.onnx
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2f88c5901d3768ec21e3cf2f2840d255e84fa13c364df86b24d960cca3333769
-size 82095882
--- a/examples/onnx/smallworm/settings.json
+++ b/examples/onnx/smallworm/settings.json
@@ -1 +0,0 @@
-{"run_args":{"tolerance":{"val":0.0,"scale":1.0},"input_scale":0,"param_scale":6,"scale_rebase_multiplier":1,"lookup_range":[-32768,32768],"logrows":17,"variables":[["batch_size",1]],"input_visibility":"Private","output_visibility":"Public","param_visibility":"Fixed"},"num_constraints":367422820,"total_const_size":365577160,"model_instance_shapes":[[1,300,1200]],"model_output_scales":[6],"model_input_scales":[0,0,0],"module_sizes":{"kzg":[],"poseidon":[0,[0]],"elgamal":[0,[0]]},"required_lookups":[{"Div":{"denom":64.0}},"ReLU",{"Ln":{"scale":64.0}},{"Exp":{"scale":64.0}}],"check_mode":"UNSAFE","version":"0.0.0","num_blinding_factors":null}
--- a/in-browser-evm-verifier/package.json
+++ b/in-browser-evm-verifier/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@ezkljs/verify",
-  "version": "v10.4.2",
+  "version": "0.0.0",
  "publishConfig": {
    "access": "public"
  },
@@ -27,7 +27,7 @@
    "@ethereumjs/util": "9.0.0",
    "@ethereumjs/vm": "7.0.0",
    "@ethersproject/abi": "5.7.0",
-    "@ezkljs/engine": "10.4.2",
+    "@ezkljs/engine": "^9.4.4",
    "ethers": "6.7.1",
    "json-bigint": "1.0.0"
  },
--- a/in-browser-evm-verifier/pnpm-lock.yaml
+++ b/in-browser-evm-verifier/pnpm-lock.yaml
@@ -27,8 +27,8 @@ dependencies:
    specifier: 5.7.0
    version: 5.7.0
  '@ezkljs/engine':
-    specifier: "10.4.2"
-    version: "10.4.2"
+    specifier: ^9.4.4
+    version: 9.4.4
  ethers:
    specifier: 6.7.1
    version: 6.7.1
@@ -397,8 +397,8 @@ packages:
      '@ethersproject/strings': 5.7.0
    dev: false

-  /@ezkljs/engine@10.4.2:
-    resolution: {integrity: "sha512-1GNB4vChbaQ1ALcYbEbM/AFoh4QWtswpzGCO/g9wL8Ep6NegM2gQP/uWICU7Utl0Lj1DncXomD7PUhFSXhtx8A=="}
+  /@ezkljs/engine@9.4.4:
+    resolution: {integrity: sha512-kNsTmDQa8mIiQ6yjJmBMwVgAAxh4nfs4NCtnewJifonyA8Mfhs+teXwwW8WhERRDoQPUofKO2pT8BPvV/XGIDA==}
    dependencies:
      '@types/json-bigint': 1.0.2
      json-bigint: 1.0.0
--- a/in-browser-evm-verifier/src/index.ts
+++ b/in-browser-evm-verifier/src/index.ts
@@ -9,6 +9,7 @@ import { EVM } from '@ethereumjs/evm'
 import { buildTransaction, encodeDeployment } from './utils/tx-builder'
 import { getAccountNonce, insertAccount } from './utils/account-utils'
 import { encodeVerifierCalldata } from '../nodejs/ezkl';
+import { error } from 'console'

 async function deployContract(
  vm: VM,
@@ -65,7 +66,7 @@ async function verify(
    vkAddress = new Uint8Array(uint8Array.buffer);

    // convert uitn8array of length
-    console.error('vkAddress', vkAddress)
+    error('vkAddress', vkAddress)
  }
  const data = encodeVerifierCalldata(proof, vkAddress)

--- a/install_ezkl_cli.sh
+++ b/install_ezkl_cli.sh
@@ -99,10 +99,6 @@ fi
 echo "Removing old ezkl binary if it exists"
 [ -e file ] && rm file

-# echo platform and architecture
-echo "Platform: $PLATFORM"
-echo "Architecture: $ARCHITECTURE"
-
 # download the release and unpack the right tarball
 if [ "$PLATFORM" == "windows-msvc" ]; then
    JSON_RESPONSE=$(curl -s "$RELEASE_URL")
@@ -130,6 +126,7 @@ elif [ "$PLATFORM" == "macos" ]; then

        echo "Cleaning up"
        rm "$EZKL_DIR/build-artifacts.ezkl-macos-aarch64.tar.gz"
+
    else
        JSON_RESPONSE=$(curl -s "$RELEASE_URL")
        FILE_URL=$(echo "$JSON_RESPONSE" | grep -o 'https://github.com[^"]*' | grep "build-artifacts.ezkl-macos.tar.gz")
@@ -146,7 +143,7 @@ elif [ "$PLATFORM" == "macos" ]; then
    fi

 elif [ "$PLATFORM" == "linux" ]; then
-    if [ "$ARCHITECTURE" == "amd64" ]; then
+    if [ "${ARCHITECTURE}" = "amd64" ]; then
        JSON_RESPONSE=$(curl -s "$RELEASE_URL")
        FILE_URL=$(echo "$JSON_RESPONSE" | grep -o 'https://github.com[^"]*' | grep "build-artifacts.ezkl-linux-gnu.tar.gz")

@@ -158,20 +155,9 @@ elif [ "$PLATFORM" == "linux" ]; then

        echo "Cleaning up"
        rm "$EZKL_DIR/build-artifacts.ezkl-linux-gnu.tar.gz"
-    elif [ "$ARCHITECTURE" == "aarch64" ]; then
-        JSON_RESPONSE=$(curl -s "$RELEASE_URL")
-        FILE_URL=$(echo "$JSON_RESPONSE" | grep -o 'https://github.com[^"]*' | grep "build-artifacts.ezkl-linux-aarch64.tar.gz")

-        echo "Downloading package"
-        curl -L "$FILE_URL" -o "$EZKL_DIR/build-artifacts.ezkl-linux-aarch64.tar.gz"
-
-        echo "Unpacking package"
-        tar -xzf "$EZKL_DIR/build-artifacts.ezkl-linux-aarch64.tar.gz" -C "$EZKL_DIR"
-
-        echo "Cleaning up"
-        rm "$EZKL_DIR/build-artifacts.ezkl-linux-aarch64.tar.gz"
    else
-        echo "Non aarch ARM architectures are not supported for Linux at the moment. If you would need support for the ARM architectures on linux please submit an issue https://github.com/zkonduit/ezkl/issues/new/choose"
+        echo "ARM architectures are not supported for Linux at the moment. If you would need support for the ARM architectures on linux please submit an issue https://github.com/zkonduit/ezkl/issues/new/choose"
        exit 1
    fi
 else
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -8,7 +8,6 @@ addopts = "-rfEX -p pytester --strict-markers"
 testpaths = [
    "tests/python/*_tests.py",
 ]
-asyncio_mode = "auto"

 [project]
 name = "ezkl"
--- a/2
+++ b/2
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2024-07-18"
+channel = "nightly-2024-02-06"
 components = ["rustfmt", "clippy"]
--- a/src/bin/ezkl.rs
+++ b/src/bin/ezkl.rs
@@ -1,10 +1,7 @@
 // ignore file if compiling for wasm
-#[global_allocator]
-#[cfg(not(target_arch = "wasm32"))]
-static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;

 #[cfg(not(target_arch = "wasm32"))]
-use clap::{CommandFactory, Parser};
+use clap::Parser;
 #[cfg(not(target_arch = "wasm32"))]
 use colored_json::ToColoredJson;
 #[cfg(not(target_arch = "wasm32"))]
@@ -14,49 +11,35 @@ use ezkl::execute::run;
 #[cfg(not(target_arch = "wasm32"))]
 use ezkl::logger::init_logger;
 #[cfg(not(target_arch = "wasm32"))]
-use log::{error, info};
+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")]
 use std::env;
+#[cfg(not(target_arch = "wasm32"))]
+use std::error::Error;

 #[tokio::main(flavor = "current_thread")]
 #[cfg(not(target_arch = "wasm32"))]
-pub async fn main() {
+pub async fn main() -> Result<(), Box<dyn Error>> {
    let args = Cli::parse();
-
-    if let Some(generator) = args.generator {
-        ezkl::commands::print_completions(generator, &mut Cli::command());
-    } else if let Some(command) = args.command {
-        init_logger();
-        #[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
-        banner();
-        #[cfg(feature = "icicle")]
-        if env::var("ENABLE_ICICLE_GPU").is_ok() {
-            info!("Running with ICICLE GPU");
-        } else {
-            info!("Running with CPU");
-        }
-        info!(
-            "command: \n {}",
-            &command.as_json().to_colored_json_auto().unwrap()
-        );
-        let res = run(command).await;
-        match &res {
-            Ok(_) => {
-                info!("succeeded");
-            }
-            Err(e) => {
-                error!("{}", e);
-                std::process::exit(1)
-            }
-        }
+    init_logger();
+    #[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
+    banner();
+    #[cfg(feature = "icicle")]
+    if env::var("ENABLE_ICICLE_GPU").is_ok() {
+        info!("Running with ICICLE GPU");
    } else {
-        init_logger();
-        error!("No command provided");
-        std::process::exit(1)
+        info!("Running with CPU");
    }
+    debug!("command: \n {}", &args.as_json()?.to_colored_json_auto()?);
+    let res = run(args.command).await;
+    match &res {
+        Ok(_) => info!("succeeded"),
+        Err(e) => error!("failed: {}", e),
+    };
+    res.map(|_| ())
 }

 #[cfg(target_arch = "wasm32")]
--- a/src/circuit/modules/errors.rs
+++ b/src/circuit/modules/errors.rs
@@ -1,25 +0,0 @@
-use halo2_proofs::plonk::Error as PlonkError;
-use thiserror::Error;
-
-/// Error type for the circuit module
-#[derive(Error, Debug)]
-pub enum ModuleError {
-    /// Halo 2 error
-    #[error("[halo2] {0}")]
-    Halo2Error(#[from] PlonkError),
-    /// Wrong input type for a module
-    #[error("wrong input type {0} must be {1}")]
-    WrongInputType(String, String),
-    /// A constant was not previously assigned
-    #[error("constant was not previously assigned")]
-    ConstantNotAssigned,
-    /// Input length is wrong
-    #[error("input length is wrong {0}")]
-    InputWrongLength(usize),
-}
-
-impl From<ModuleError> for PlonkError {
-    fn from(_e: ModuleError) -> PlonkError {
-        PlonkError::Synthesis
-    }
-}
--- a/src/circuit/modules/mod.rs
+++ b/src/circuit/modules/mod.rs
@@ -6,11 +6,10 @@ pub mod polycommit;

 ///
 pub mod planner;
-
-///
-pub mod errors;
-
-use halo2_proofs::{circuit::Layouter, plonk::ConstraintSystem};
+use halo2_proofs::{
+    circuit::Layouter,
+    plonk::{ConstraintSystem, Error},
+};
 use halo2curves::ff::PrimeField;
 pub use planner::*;

@@ -36,14 +35,14 @@ pub trait Module<F: PrimeField + TensorType + PartialOrd> {
    /// Name
    fn name(&self) -> &'static str;
    /// Run the operation the module represents
-    fn run(input: Self::RunInputs) -> Result<Vec<Vec<F>>, errors::ModuleError>;
+    fn run(input: Self::RunInputs) -> Result<Vec<Vec<F>>, Box<dyn std::error::Error>>;
    /// Layout inputs
    fn layout_inputs(
        &self,
        layouter: &mut impl Layouter<F>,
        input: &[ValTensor<F>],
        constants: &mut ConstantsMap<F>,
-    ) -> Result<Self::InputAssignments, errors::ModuleError>;
+    ) -> Result<Self::InputAssignments, Error>;
    /// Layout
    fn layout(
        &self,
@@ -51,7 +50,7 @@ pub trait Module<F: PrimeField + TensorType + PartialOrd> {
        input: &[ValTensor<F>],
        row_offset: usize,
        constants: &mut ConstantsMap<F>,
-    ) -> Result<ValTensor<F>, errors::ModuleError>;
+    ) -> Result<ValTensor<F>, Error>;
    /// Number of instance values the module uses every time it is applied
    fn instance_increment_input(&self) -> Vec<usize>;
    /// Number of rows used by the module
--- a/src/circuit/modules/polycommit.rs
+++ b/src/circuit/modules/polycommit.rs
@@ -18,7 +18,6 @@ use halo2curves::CurveAffine;
 use crate::circuit::region::ConstantsMap;
 use crate::tensor::{Tensor, ValTensor, ValType, VarTensor};

-use super::errors::ModuleError;
 use super::Module;

 /// The number of instance columns used by the PolyCommit hash function
@@ -45,11 +44,12 @@ impl PolyCommitChip {
    /// Commit to the message using the KZG commitment scheme
    pub fn commit<Scheme: CommitmentScheme<Scalar = Fp, Curve = G1Affine>>(
        message: Vec<Scheme::Scalar>,
+        degree: u32,
        num_unusable_rows: u32,
        params: &Scheme::ParamsProver,
    ) -> Vec<G1Affine> {
        let k = params.k();
-        let domain = halo2_proofs::poly::EvaluationDomain::new(2, k);
+        let domain = halo2_proofs::poly::EvaluationDomain::new(degree, k);
        let n = 2_u64.pow(k) - num_unusable_rows as u64;
        let num_poly = (message.len() / n as usize) + 1;
        let mut poly = vec![domain.empty_lagrange(); num_poly];
@@ -111,7 +111,7 @@ impl Module<Fp> for PolyCommitChip {
        _: &mut impl Layouter<Fp>,
        _: &[ValTensor<Fp>],
        _: &mut ConstantsMap<Fp>,
-    ) -> Result<Self::InputAssignments, ModuleError> {
+    ) -> Result<Self::InputAssignments, Error> {
        Ok(())
    }

@@ -124,30 +124,28 @@ impl Module<Fp> for PolyCommitChip {
        input: &[ValTensor<Fp>],
        _: usize,
        constants: &mut ConstantsMap<Fp>,
-    ) -> Result<ValTensor<Fp>, ModuleError> {
+    ) -> Result<ValTensor<Fp>, Error> {
        assert_eq!(input.len(), 1);

        let local_constants = constants.clone();
-        layouter
-            .assign_region(
-                || "PolyCommit",
-                |mut region| {
-                    let mut local_inner_constants = local_constants.clone();
-                    let res = self.config.inputs.assign(
-                        &mut region,
-                        0,
-                        &input[0],
-                        &mut local_inner_constants,
-                    )?;
-                    *constants = local_inner_constants;
-                    Ok(res)
-                },
-            )
-            .map_err(|e| e.into())
+        layouter.assign_region(
+            || "PolyCommit",
+            |mut region| {
+                let mut local_inner_constants = local_constants.clone();
+                let res = self.config.inputs.assign(
+                    &mut region,
+                    0,
+                    &input[0],
+                    &mut local_inner_constants,
+                )?;
+                *constants = local_inner_constants;
+                Ok(res)
+            },
+        )
    }

    ///
-    fn run(message: Vec<Fp>) -> Result<Vec<Vec<Fp>>, ModuleError> {
+    fn run(message: Vec<Fp>) -> Result<Vec<Vec<Fp>>, Box<dyn std::error::Error>> {
        Ok(vec![message])
    }

--- a/src/circuit/modules/poseidon.rs
+++ b/src/circuit/modules/poseidon.rs
@@ -21,7 +21,6 @@ use std::marker::PhantomData;
 use crate::circuit::region::ConstantsMap;
 use crate::tensor::{Tensor, ValTensor, ValType};

-use super::errors::ModuleError;
 use super::Module;

 /// The number of instance columns used by the Poseidon hash function
@@ -175,7 +174,7 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
        layouter: &mut impl Layouter<Fp>,
        message: &[ValTensor<Fp>],
        constants: &mut ConstantsMap<Fp>,
-    ) -> Result<Self::InputAssignments, ModuleError> {
+    ) -> Result<Self::InputAssignments, Error> {
        assert_eq!(message.len(), 1);
        let message = message[0].clone();

@@ -186,82 +185,78 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
        let res = layouter.assign_region(
            || "load message",
            |mut region| {
-                let assigned_message: Result<Vec<AssignedCell<Fp, Fp>>, ModuleError> =
-                    match &message {
-                        ValTensor::Value { inner: v, .. } => {
-                            v.iter()
-                                .enumerate()
-                                .map(|(i, value)| {
-                                    let x = i % WIDTH;
-                                    let y = i / WIDTH;
+                let assigned_message: Result<Vec<AssignedCell<Fp, Fp>>, Error> = match &message {
+                    ValTensor::Value { inner: v, .. } => v
+                        .iter()
+                        .enumerate()
+                        .map(|(i, value)| {
+                            let x = i % WIDTH;
+                            let y = i / WIDTH;

-                                    match value {
-                                        ValType::Value(v) => region
-                                            .assign_advice(
-                                                || format!("load message_{}", i),
-                                                self.config.hash_inputs[x],
-                                                y,
-                                                || *v,
-                                            )
-                                            .map_err(|e| e.into()),
-                                        ValType::PrevAssigned(v)
-                                        | ValType::AssignedConstant(v, ..) => Ok(v.clone()),
-                                        ValType::Constant(f) => {
-                                            if local_constants.contains_key(f) {
-                                                Ok(constants
-                                                    .get(f)
-                                                    .unwrap()
-                                                    .assigned_cell()
-                                                    .ok_or(ModuleError::ConstantNotAssigned)?)
-                                            } else {
-                                                let res = region.assign_advice_from_constant(
-                                                    || format!("load message_{}", i),
-                                                    self.config.hash_inputs[x],
-                                                    y,
-                                                    *f,
-                                                )?;
+                            match value {
+                                ValType::Value(v) => region.assign_advice(
+                                    || format!("load message_{}", i),
+                                    self.config.hash_inputs[x],
+                                    y,
+                                    || *v,
+                                ),
+                                ValType::PrevAssigned(v) | ValType::AssignedConstant(v, ..) => {
+                                    Ok(v.clone())
+                                }
+                                ValType::Constant(f) => {
+                                    if local_constants.contains_key(f) {
+                                        Ok(constants.get(f).unwrap().assigned_cell().ok_or({
+                                            log::error!("constant not previously assigned");
+                                            Error::Synthesis
+                                        })?)
+                                    } else {
+                                        let res = region.assign_advice_from_constant(
+                                            || format!("load message_{}", i),
+                                            self.config.hash_inputs[x],
+                                            y,
+                                            *f,
+                                        )?;

-                                                constants.insert(
-                                                    *f,
-                                                    ValType::AssignedConstant(res.clone(), *f),
-                                                );
+                                        constants
+                                            .insert(*f, ValType::AssignedConstant(res.clone(), *f));

-                                                Ok(res)
-                                            }
-                                        }
-                                        e => Err(ModuleError::WrongInputType(
-                                            format!("{:?}", e),
-                                            "PrevAssigned".to_string(),
-                                        )),
+                                        Ok(res)
                                    }
-                                })
-                                .collect()
-                        }
-                        ValTensor::Instance {
-                            dims,
-                            inner: col,
-                            idx,
-                            initial_offset,
-                            ..
-                        } => {
-                            // this should never ever fail
-                            let num_elems = dims[*idx].iter().product::<usize>();
-                            (0..num_elems)
-                                .map(|i| {
-                                    let x = i % WIDTH;
-                                    let y = i / WIDTH;
-                                    region.assign_advice_from_instance(
-                                        || "pub input anchor",
-                                        *col,
-                                        initial_offset + i,
-                                        self.config.hash_inputs[x],
-                                        y,
-                                    )
-                                })
-                                .collect::<Result<Vec<_>, _>>()
-                                .map_err(|e| e.into())
-                        }
-                    };
+                                }
+                                e => {
+                                    log::error!(
+                                        "wrong input type {:?}, must be previously assigned",
+                                        e
+                                    );
+                                    Err(Error::Synthesis)
+                                }
+                            }
+                        })
+                        .collect(),
+                    ValTensor::Instance {
+                        dims,
+                        inner: col,
+                        idx,
+                        initial_offset,
+                        ..
+                    } => {
+                        // this should never ever fail
+                        let num_elems = dims[*idx].iter().product::<usize>();
+                        (0..num_elems)
+                            .map(|i| {
+                                let x = i % WIDTH;
+                                let y = i / WIDTH;
+                                region.assign_advice_from_instance(
+                                    || "pub input anchor",
+                                    *col,
+                                    initial_offset + i,
+                                    self.config.hash_inputs[x],
+                                    y,
+                                )
+                            })
+                            .collect()
+                    }
+                };

                let offset = message.len() / WIDTH + 1;

@@ -282,7 +277,7 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
            message.len(),
            start_time.elapsed()
        );
-        res.map_err(|e| e.into())
+        res
    }

    /// L is the number of inputs to the hash function
@@ -294,7 +289,7 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
        input: &[ValTensor<Fp>],
        row_offset: usize,
        constants: &mut ConstantsMap<Fp>,
-    ) -> Result<ValTensor<Fp>, ModuleError> {
+    ) -> Result<ValTensor<Fp>, Error> {
        let (mut input_cells, zero_val) = self.layout_inputs(layouter, input, constants)?;
        // extract the values from the input cells
        let mut assigned_input: Tensor<ValType<Fp>> =
@@ -306,7 +301,7 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
        let mut one_iter = false;
        // do the Tree dance baby
        while input_cells.len() > 1 || !one_iter {
-            let hashes: Result<Vec<AssignedCell<Fp, Fp>>, ModuleError> = input_cells
+            let hashes: Result<Vec<AssignedCell<Fp, Fp>>, Error> = input_cells
                .chunks(L)
                .enumerate()
                .map(|(i, block)| {
@@ -337,8 +332,7 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con

                    hash
                })
-                .collect::<Result<Vec<_>, _>>()
-                .map_err(|e| e.into());
+                .collect();

            log::trace!("hashes (N={:?}) took: {:?}", len, start_time.elapsed());
            one_iter = true;
@@ -354,7 +348,7 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
            ValType::PrevAssigned(v) => v,
            _ => {
                log::error!("wrong input type, must be previously assigned");
-                return Err(Error::Synthesis.into());
+                return Err(Error::Synthesis);
            }
        };

@@ -386,7 +380,7 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
    }

    ///
-    fn run(message: Vec<Fp>) -> Result<Vec<Vec<Fp>>, ModuleError> {
+    fn run(message: Vec<Fp>) -> Result<Vec<Vec<Fp>>, Box<dyn std::error::Error>> {
        let mut hash_inputs = message;

        let len = hash_inputs.len();
@@ -406,11 +400,7 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
                        block.extend(vec![Fp::ZERO; L - remainder].iter());
                    }

-                    let block_len = block.len();
-
-                    let message = block
-                        .try_into()
-                        .map_err(|_| ModuleError::InputWrongLength(block_len))?;
+                    let message = block.try_into().map_err(|_| Error::Synthesis)?;

                    Ok(halo2_gadgets::poseidon::primitives::Hash::<
                        _,
@@ -421,7 +411,7 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, con
                    >::init()
                    .hash(message))
                })
-                .collect::<Result<Vec<_>, ModuleError>>()?;
+                .collect::<Result<Vec<_>, Error>>()?;
            one_iter = true;
            hash_inputs = hashes;
        }
--- a/src/circuit/ops/chip.rs
+++ b/src/circuit/ops/chip.rs
@@ -1,5 +1,7 @@
 use std::str::FromStr;

+use thiserror::Error;
+
 use halo2_proofs::{
    circuit::Layouter,
    plonk::{ConstraintSystem, Constraints, Expression, Selector},
@@ -24,11 +26,31 @@ use crate::{
    },
    tensor::{Tensor, TensorType, ValTensor, VarTensor},
 };
-use std::{collections::BTreeMap, marker::PhantomData};
+use std::{collections::BTreeMap, error::Error, marker::PhantomData};

-use super::{lookup::LookupOp, region::RegionCtx, CircuitError, Op};
+use super::{lookup::LookupOp, region::RegionCtx, Op};
 use halo2curves::ff::{Field, PrimeField};

+/// circuit related errors.
+#[derive(Debug, Error)]
+pub enum CircuitError {
+    /// Shape mismatch in circuit construction
+    #[error("dimension mismatch in circuit construction for op: {0}")]
+    DimMismatch(String),
+    /// Error when instantiating lookup tables
+    #[error("failed to instantiate lookup tables")]
+    LookupInstantiation,
+    /// A lookup table was was already assigned
+    #[error("attempting to initialize an already instantiated lookup table")]
+    TableAlreadyAssigned,
+    /// This operation is unsupported
+    #[error("unsupported operation in graph")]
+    UnsupportedOp,
+    ///
+    #[error("invalid einsum expression")]
+    InvalidEinsum,
+}
+
 #[allow(missing_docs)]
 /// An enum representing activating the sanity checks we can perform on the accumulated arguments
 #[derive(
@@ -58,18 +80,14 @@ impl ToFlags for CheckMode {

 impl From<String> for CheckMode {
    fn from(value: String) -> Self {
-        Self::from_str(value.as_str()).unwrap()
-    }
-}
-
-impl FromStr for CheckMode {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "safe" => Ok(CheckMode::SAFE),
-            "unsafe" => Ok(CheckMode::UNSAFE),
-            _ => Err("Invalid value for CheckMode".to_string()),
+        match value.to_lowercase().as_str() {
+            "safe" => CheckMode::SAFE,
+            "unsafe" => CheckMode::UNSAFE,
+            _ => {
+                log::error!("Invalid value for CheckMode");
+                log::warn!("defaulting to SAFE");
+                CheckMode::SAFE
+            }
        }
    }
 }
@@ -491,18 +509,18 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
        lookup_range: Range,
        logrows: usize,
        nl: &LookupOp,
-    ) -> Result<(), CircuitError>
+    ) -> Result<(), Box<dyn Error>>
    where
        F: Field,
    {
        if !index.is_advice() {
-            return Err(CircuitError::WrongColumnType(index.name().to_string()));
+            return Err("wrong input type for lookup index".into());
        }
        if !input.is_advice() {
-            return Err(CircuitError::WrongColumnType(input.name().to_string()));
+            return Err("wrong input type for lookup input".into());
        }
        if !output.is_advice() {
-            return Err(CircuitError::WrongColumnType(output.name().to_string()));
+            return Err("wrong input type for lookup output".into());
        }

        // we borrow mutably twice so we need to do this dance
@@ -632,19 +650,19 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
        cs: &mut ConstraintSystem<F>,
        lookups: &[VarTensor; 3],
        tables: &[VarTensor; 3],
-    ) -> Result<(), CircuitError>
+    ) -> Result<(), Box<dyn Error>>
    where
        F: Field,
    {
        for l in lookups.iter() {
            if !l.is_advice() {
-                return Err(CircuitError::WrongDynamicColumnType(l.name().to_string()));
+                return Err("wrong input type for dynamic lookup".into());
            }
        }

        for t in tables.iter() {
            if !t.is_advice() || t.num_blocks() > 1 || t.num_inner_cols() > 1 {
-                return Err(CircuitError::WrongDynamicColumnType(t.name().to_string()));
+                return Err("wrong table type for dynamic lookup".into());
            }
        }

@@ -715,19 +733,19 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
        cs: &mut ConstraintSystem<F>,
        inputs: &[VarTensor; 2],
        references: &[VarTensor; 2],
-    ) -> Result<(), CircuitError>
+    ) -> Result<(), Box<dyn Error>>
    where
        F: Field,
    {
        for l in inputs.iter() {
            if !l.is_advice() {
-                return Err(CircuitError::WrongDynamicColumnType(l.name().to_string()));
+                return Err("wrong input type for dynamic lookup".into());
            }
        }

        for t in references.iter() {
            if !t.is_advice() || t.num_blocks() > 1 || t.num_inner_cols() > 1 {
-                return Err(CircuitError::WrongDynamicColumnType(t.name().to_string()));
+                return Err("wrong table type for dynamic lookup".into());
            }
        }

@@ -800,12 +818,12 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
        index: &VarTensor,
        range: Range,
        logrows: usize,
-    ) -> Result<(), CircuitError>
+    ) -> Result<(), Box<dyn Error>>
    where
        F: Field,
    {
        if !input.is_advice() {
-            return Err(CircuitError::WrongColumnType(input.name().to_string()));
+            return Err("wrong input type for lookup input".into());
        }

        // we borrow mutably twice so we need to do this dance
@@ -896,7 +914,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
    }

    /// layout_tables must be called before layout.
-    pub fn layout_tables(&mut self, layouter: &mut impl Layouter<F>) -> Result<(), CircuitError> {
+    pub fn layout_tables(&mut self, layouter: &mut impl Layouter<F>) -> Result<(), Box<dyn Error>> {
        for (i, table) in self.static_lookups.tables.values_mut().enumerate() {
            if !table.is_assigned {
                debug!(
@@ -917,7 +935,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
    pub fn layout_range_checks(
        &mut self,
        layouter: &mut impl Layouter<F>,
-    ) -> Result<(), CircuitError> {
+    ) -> Result<(), Box<dyn Error>> {
        for range_check in self.range_checks.ranges.values_mut() {
            if !range_check.is_assigned {
                debug!("laying out range check for {:?}", range_check.range);
@@ -937,7 +955,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
        region: &mut RegionCtx<F>,
        values: &[ValTensor<F>],
        op: Box<dyn Op<F>>,
-    ) -> Result<Option<ValTensor<F>>, CircuitError> {
+    ) -> Result<Option<ValTensor<F>>, Box<dyn Error>> {
        op.layout(self, region, values)
    }
 }
--- a/src/circuit/ops/errors.rs
+++ b/src/circuit/ops/errors.rs
@@ -1,97 +0,0 @@
-use std::convert::Infallible;
-
-use crate::{fieldutils::IntegerRep, tensor::TensorError};
-use halo2_proofs::plonk::Error as PlonkError;
-use thiserror::Error;
-
-/// Error type for the circuit module
-#[derive(Error, Debug)]
-pub enum CircuitError {
-    /// Halo 2 error
-    #[error("[halo2] {0}")]
-    Halo2Error(#[from] PlonkError),
-    /// Tensor error
-    #[error("[tensor] {0}")]
-    TensorError(#[from] TensorError),
-    /// Shape mismatch in circuit construction
-    #[error("dimension mismatch in circuit construction for op: {0}")]
-    DimMismatch(String),
-    /// Error when instantiating lookup tables
-    #[error("failed to instantiate lookup tables")]
-    LookupInstantiation,
-    /// A lookup table was was already assigned
-    #[error("attempting to initialize an already instantiated lookup table")]
-    TableAlreadyAssigned,
-    /// This operation is unsupported
-    #[error("unsupported operation in graph")]
-    UnsupportedOp,
-    ///
-    #[error("invalid einsum expression")]
-    InvalidEinsum,
-    /// Flush error
-    #[error("failed to flush, linear coord is not aligned with the next row")]
-    FlushError,
-    /// Constrain error
-    #[error("constrain_equal: one of the tensors is assigned and the other is not")]
-    ConstrainError,
-    /// Failed to get lookups
-    #[error("failed to get lookups for op: {0}")]
-    GetLookupsError(String),
-    /// Failed to get range checks
-    #[error("failed to get range checks for op: {0}")]
-    GetRangeChecksError(String),
-    /// Failed to get dynamic lookup
-    #[error("failed to get dynamic lookup for op: {0}")]
-    GetDynamicLookupError(String),
-    /// Failed to get shuffle
-    #[error("failed to get shuffle for op: {0}")]
-    GetShuffleError(String),
-    /// Failed to get constants
-    #[error("failed to get constants for op: {0}")]
-    GetConstantsError(String),
-    /// Slice length mismatch
-    #[error("slice length mismatch: {0}")]
-    SliceLengthMismatch(#[from] std::array::TryFromSliceError),
-    /// Bad conversion
-    #[error("invalid conversion: {0}")]
-    InvalidConversion(#[from] Infallible),
-    /// Invalid min/max lookup range
-    #[error("invalid min/max lookup range: min: {0}, max: {1}")]
-    InvalidMinMaxRange(IntegerRep, IntegerRep),
-    /// Missing product in einsum
-    #[error("missing product in einsum")]
-    MissingEinsumProduct,
-    /// Mismatched lookup length
-    #[error("mismatched lookup lengths: {0} and {1}")]
-    MismatchedLookupLength(usize, usize),
-    /// Mismatched shuffle length
-    #[error("mismatched shuffle lengths: {0} and {1}")]
-    MismatchedShuffleLength(usize, usize),
-    /// Mismatched lookup table lengths
-    #[error("mismatched lookup table lengths: {0} and {1}")]
-    MismatchedLookupTableLength(usize, usize),
-    /// Wrong column type for lookup
-    #[error("wrong column type for lookup: {0}")]
-    WrongColumnType(String),
-    /// Wrong column type for dynamic lookup
-    #[error("wrong column type for dynamic lookup: {0}")]
-    WrongDynamicColumnType(String),
-    /// Missing selectors
-    #[error("missing selectors for op: {0}")]
-    MissingSelectors(String),
-    /// Table lookup error
-    #[error("value ({0}) out of range: ({1}, {2})")]
-    TableOOR(IntegerRep, IntegerRep, IntegerRep),
-    /// Loookup not configured
-    #[error("lookup not configured: {0}")]
-    LookupNotConfigured(String),
-    /// Range check not configured
-    #[error("range check not configured: {0}")]
-    RangeCheckNotConfigured(String),
-    /// Missing layout
-    #[error("missing layout for op: {0}")]
-    MissingLayout(String),
-    #[error("[io] {0}")]
-    /// IO error
-    IoError(#[from] std::io::Error),
-}
--- a/src/circuit/ops/hybrid.rs
+++ b/src/circuit/ops/hybrid.rs
@@ -1,7 +1,7 @@
 use super::*;
 use crate::{
    circuit::{layouts, utils, Tolerance},
-    fieldutils::integer_rep_to_felt,
+    fieldutils::i128_to_felt,
    graph::multiplier_to_scale,
    tensor::{self, Tensor, TensorType, ValTensor},
 };
@@ -71,7 +71,7 @@ pub enum HybridOp {
    },
 }

-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash > Op<F> for HybridOp {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for HybridOp {
    ///
    fn requires_homogenous_input_scales(&self) -> Vec<usize> {
        match self {
@@ -155,7 +155,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash > Op<F> for Hybri
        config: &mut crate::circuit::BaseConfig<F>,
        region: &mut RegionCtx<F>,
        values: &[ValTensor<F>],
-    ) -> Result<Option<ValTensor<F>>, CircuitError> {
+    ) -> Result<Option<ValTensor<F>>, Box<dyn std::error::Error>> {
        Ok(Some(match self {
            HybridOp::SumPool {
                padding,
@@ -184,8 +184,8 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash > Op<F> for Hybri
                        config,
                        region,
                        values[..].try_into()?,
-                        integer_rep_to_felt(input_scale.0 as i128),
-                        integer_rep_to_felt(output_scale.0 as i128),
+                        i128_to_felt(input_scale.0 as i128),
+                        i128_to_felt(output_scale.0 as i128),
                    )?
                } else {
                    layouts::nonlinearity(
@@ -209,7 +209,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash > Op<F> for Hybri
                        config,
                        region,
                        values[..].try_into()?,
-                        integer_rep_to_felt(denom.0 as i128),
+                        i128_to_felt(denom.0 as i128),
                    )?
                } else {
                    layouts::nonlinearity(
@@ -287,7 +287,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash > Op<F> for Hybri
        }))
    }

-    fn out_scale(&self, in_scales: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
+    fn out_scale(&self, in_scales: Vec<crate::Scale>) -> Result<crate::Scale, Box<dyn Error>> {
        let scale = match self {
            HybridOp::Greater { .. }
            | HybridOp::GreaterEqual { .. }
--- a/src/circuit/ops/layouts.rs
+++ b/src/circuit/ops/layouts.rs
--- a/src/circuit/ops/lookup.rs
+++ b/src/circuit/ops/lookup.rs
@@ -1,9 +1,10 @@
 use super::*;
 use serde::{Deserialize, Serialize};
+use std::error::Error;

 use crate::{
    circuit::{layouts, table::Range, utils},
-    fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep},
+    fieldutils::{felt_to_i128, i128_to_felt},
    graph::multiplier_to_scale,
    tensor::{self, Tensor, TensorError, TensorType},
 };
@@ -131,63 +132,16 @@ impl LookupOp {
    /// Returns the range of values that can be represented by the table
    pub fn bit_range(max_len: usize) -> Range {
        let range = (max_len - 1) as f64 / 2_f64;
-        let range = range as IntegerRep;
+        let range = range as i128;
        (-range, range)
    }

-    /// as path
-    pub fn as_path(&self) -> String {
-        match self {
-            LookupOp::Abs => "abs".into(),
-            LookupOp::Ceil { scale } => format!("ceil_{}", scale),
-            LookupOp::Floor { scale } => format!("floor_{}", scale),
-            LookupOp::Round { scale } => format!("round_{}", scale),
-            LookupOp::RoundHalfToEven { scale } => format!("round_half_to_even_{}", scale),
-            LookupOp::Pow { scale, a } => format!("pow_{}_{}", scale, a),
-            LookupOp::KroneckerDelta => "kronecker_delta".into(),
-            LookupOp::Max { scale, a } => format!("max_{}_{}", scale, a),
-            LookupOp::Min { scale, a } => format!("min_{}_{}", scale, a),
-            LookupOp::Sign => "sign".into(),
-            LookupOp::LessThan { a } => format!("less_than_{}", a),
-            LookupOp::LessThanEqual { a } => format!("less_than_equal_{}", a),
-            LookupOp::GreaterThan { a } => format!("greater_than_{}", a),
-            LookupOp::GreaterThanEqual { a } => format!("greater_than_equal_{}", a),
-            LookupOp::Div { denom } => format!("div_{}", denom),
-            LookupOp::Cast { scale } => format!("cast_{}", scale),
-            LookupOp::Recip {
-                input_scale,
-                output_scale,
-            } => format!("recip_{}_{}", input_scale, output_scale),
-            LookupOp::ReLU => "relu".to_string(),
-            LookupOp::LeakyReLU { slope: a } => format!("leaky_relu_{}", a),
-            LookupOp::Sigmoid { scale } => format!("sigmoid_{}", scale),
-            LookupOp::Sqrt { scale } => format!("sqrt_{}", scale),
-            LookupOp::Rsqrt { scale } => format!("rsqrt_{}", scale),
-            LookupOp::Erf { scale } => format!("erf_{}", scale),
-            LookupOp::Exp { scale } => format!("exp_{}", scale),
-            LookupOp::Ln { scale } => format!("ln_{}", scale),
-            LookupOp::Cos { scale } => format!("cos_{}", scale),
-            LookupOp::ACos { scale } => format!("acos_{}", scale),
-            LookupOp::Cosh { scale } => format!("cosh_{}", scale),
-            LookupOp::ACosh { scale } => format!("acosh_{}", scale),
-            LookupOp::Sin { scale } => format!("sin_{}", scale),
-            LookupOp::ASin { scale } => format!("asin_{}", scale),
-            LookupOp::Sinh { scale } => format!("sinh_{}", scale),
-            LookupOp::ASinh { scale } => format!("asinh_{}", scale),
-            LookupOp::Tan { scale } => format!("tan_{}", scale),
-            LookupOp::ATan { scale } => format!("atan_{}", scale),
-            LookupOp::ATanh { scale } => format!("atanh_{}", scale),
-            LookupOp::Tanh { scale } => format!("tanh_{}", scale),
-            LookupOp::HardSwish { scale } => format!("hardswish_{}", scale),
-        }
-    }
-
    /// Matches a [Op] to an operation in the `tensor::ops` module.
    pub(crate) fn f<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
        &self,
        x: &[Tensor<F>],
    ) -> Result<ForwardResult<F>, TensorError> {
-        let x = x[0].clone().map(|x| felt_to_integer_rep(x));
+        let x = x[0].clone().map(|x| felt_to_i128(x));
        let res = match &self {
            LookupOp::Abs => Ok(tensor::ops::abs(&x)?),
            LookupOp::Ceil { scale } => Ok(tensor::ops::nonlinearities::ceil(&x, scale.into())),
@@ -274,7 +228,7 @@ impl LookupOp {
            }
        }?;

-        let output = res.map(|x| integer_rep_to_felt(x));
+        let output = res.map(|x| i128_to_felt(x));

        Ok(ForwardResult { output })
    }
@@ -341,7 +295,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Lookup
        config: &mut crate::circuit::BaseConfig<F>,
        region: &mut RegionCtx<F>,
        values: &[ValTensor<F>],
-    ) -> Result<Option<ValTensor<F>>, CircuitError> {
+    ) -> Result<Option<ValTensor<F>>, Box<dyn Error>> {
        Ok(Some(layouts::nonlinearity(
            config,
            region,
@@ -351,7 +305,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Lookup
    }

    /// Returns the scale of the output of the operation.
-    fn out_scale(&self, inputs_scale: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
+    fn out_scale(&self, inputs_scale: Vec<crate::Scale>) -> Result<crate::Scale, Box<dyn Error>> {
        let scale = match self {
            LookupOp::Cast { scale } => {
                let in_scale = inputs_scale[0];
--- a/src/circuit/ops/mod.rs
+++ b/src/circuit/ops/mod.rs
@@ -1,4 +1,4 @@
-use std::any::Any;
+use std::{any::Any, error::Error};

 use serde::{Deserialize, Serialize};

@@ -15,8 +15,6 @@ pub mod base;
 ///
 pub mod chip;
 ///
-pub mod errors;
-///
 pub mod hybrid;
 /// Layouts for specific functions (composed of base ops)
 pub mod layouts;
@@ -27,8 +25,6 @@ pub mod poly;
 ///
 pub mod region;

-pub use errors::CircuitError;
-
 /// A struct representing the result of a forward pass.
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct ForwardResult<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
@@ -48,10 +44,10 @@ pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>:
        config: &mut crate::circuit::BaseConfig<F>,
        region: &mut RegionCtx<F>,
        values: &[ValTensor<F>],
-    ) -> Result<Option<ValTensor<F>>, CircuitError>;
+    ) -> Result<Option<ValTensor<F>>, Box<dyn Error>>;

    /// Returns the scale of the output of the operation.
-    fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError>;
+    fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, Box<dyn Error>>;

    /// Do any of the inputs to this op require homogenous input scales?
    fn requires_homogenous_input_scales(&self) -> Vec<usize> {
@@ -126,8 +122,8 @@ impl InputType {
                *input = T::from_f64(f64_input).unwrap();
            }
            InputType::Int | InputType::TDim => {
-                let int_input = input.clone().to_i64().unwrap();
-                *input = T::from_i64(int_input).unwrap();
+                let int_input = input.clone().to_i128().unwrap();
+                *input = T::from_i128(int_input).unwrap();
            }
        }
    }
@@ -143,7 +139,7 @@ pub struct Input {
 }

 impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input {
-    fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
+    fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, Box<dyn Error>> {
        Ok(self.scale)
    }

@@ -160,7 +156,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input
        config: &mut crate::circuit::BaseConfig<F>,
        region: &mut RegionCtx<F>,
        values: &[ValTensor<F>],
-    ) -> Result<Option<ValTensor<F>>, CircuitError> {
+    ) -> Result<Option<ValTensor<F>>, Box<dyn Error>> {
        let value = values[0].clone();
        if !value.all_prev_assigned() {
            match self.datum_type {
@@ -198,7 +194,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input
 pub struct Unknown;

 impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Unknown {
-    fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
+    fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, Box<dyn Error>> {
        Ok(0)
    }
    fn as_any(&self) -> &dyn Any {
@@ -213,8 +209,8 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Unknow
        _: &mut crate::circuit::BaseConfig<F>,
        _: &mut RegionCtx<F>,
        _: &[ValTensor<F>],
-    ) -> Result<Option<ValTensor<F>>, CircuitError> {
-        Err(super::CircuitError::UnsupportedOp)
+    ) -> Result<Option<ValTensor<F>>, Box<dyn Error>> {
+        Err(Box::new(super::CircuitError::UnsupportedOp))
    }

    fn clone_dyn(&self) -> Box<dyn Op<F>> {
@@ -244,7 +240,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Constant<F> {
        }
    }
    /// Rebase the scale of the constant
-    pub fn rebase_scale(&mut self, new_scale: crate::Scale) -> Result<(), CircuitError> {
+    pub fn rebase_scale(&mut self, new_scale: crate::Scale) -> Result<(), Box<dyn Error>> {
        let visibility = self.quantized_values.visibility().unwrap();
        self.quantized_values = quantize_tensor(self.raw_values.clone(), new_scale, &visibility)?;
        Ok(())
@@ -282,7 +278,7 @@ impl<
        config: &mut crate::circuit::BaseConfig<F>,
        region: &mut RegionCtx<F>,
        _: &[ValTensor<F>],
-    ) -> Result<Option<ValTensor<F>>, CircuitError> {
+    ) -> Result<Option<ValTensor<F>>, Box<dyn Error>> {
        let value = if let Some(value) = &self.pre_assigned_val {
            value.clone()
        } else {
@@ -296,7 +292,7 @@ impl<
        Box::new(self.clone()) // Forward to the derive(Clone) impl
    }

-    fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
+    fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, Box<dyn Error>> {
        Ok(self.quantized_values.scale().unwrap())
    }

--- a/src/circuit/ops/poly.rs
+++ b/src/circuit/ops/poly.rs
@@ -33,7 +33,6 @@ pub enum PolyOp {
    Conv {
        padding: Vec<(usize, usize)>,
        stride: Vec<usize>,
-        group: usize,
    },
    Downsample {
        axis: usize,
@@ -44,7 +43,6 @@ pub enum PolyOp {
        padding: Vec<(usize, usize)>,
        output_padding: Vec<usize>,
        stride: Vec<usize>,
-        group: usize,
    },
    Add,
    Sub,
@@ -99,8 +97,7 @@ impl<
            + PartialOrd
            + std::hash::Hash
            + Serialize
-            + for<'de> Deserialize<'de>
-            ,
+            + for<'de> Deserialize<'de>,
    > Op<F> for PolyOp
 {
    /// Returns a reference to the Any trait.
@@ -150,25 +147,17 @@ impl<
            PolyOp::Sum { axes } => format!("SUM (axes={:?})", axes),
            PolyOp::Prod { .. } => "PROD".into(),
            PolyOp::Pow(_) => "POW".into(),
-            PolyOp::Conv {
-                stride,
-                padding,
-                group,
-            } => {
-                format!(
-                    "CONV (stride={:?}, padding={:?}, group={})",
-                    stride, padding, group
-                )
+            PolyOp::Conv { stride, padding } => {
+                format!("CONV (stride={:?}, padding={:?})", stride, padding)
            }
            PolyOp::DeConv {
                stride,
                padding,
                output_padding,
-                group,
            } => {
                format!(
-                    "DECONV (stride={:?}, padding={:?}, output_padding={:?}, group={})",
-                    stride, padding, output_padding, group
+                    "DECONV (stride={:?}, padding={:?}, output_padding={:?})",
+                    stride, padding, output_padding
                )
            }
            PolyOp::Concat { axis } => format!("CONCAT (axis={})", axis),
@@ -189,7 +178,7 @@ impl<
        config: &mut crate::circuit::BaseConfig<F>,
        region: &mut RegionCtx<F>,
        values: &[ValTensor<F>],
-    ) -> Result<Option<ValTensor<F>>, CircuitError> {
+    ) -> Result<Option<ValTensor<F>>, Box<dyn Error>> {
        Ok(Some(match self {
            PolyOp::MultiBroadcastTo { shape } => {
                layouts::expand(config, region, values[..].try_into()?, shape)?
@@ -222,18 +211,9 @@ impl<
            PolyOp::Prod { axes, .. } => {
                layouts::prod_axes(config, region, values[..].try_into()?, axes)?
            }
-            PolyOp::Conv {
-                padding,
-                stride,
-                group,
-            } => layouts::conv(
-                config,
-                region,
-                values[..].try_into()?,
-                padding,
-                stride,
-                *group,
-            )?,
+            PolyOp::Conv { padding, stride } => {
+                layouts::conv(config, region, values[..].try_into()?, padding, stride)?
+            }
            PolyOp::GatherElements { dim, constant_idx } => {
                if let Some(idx) = constant_idx {
                    tensor::ops::gather_elements(values[0].get_inner_tensor()?, idx, *dim)?.into()
@@ -280,7 +260,6 @@ impl<
                padding,
                output_padding,
                stride,
-                group,
            } => layouts::deconv(
                config,
                region,
@@ -288,7 +267,6 @@ impl<
                padding,
                output_padding,
                stride,
-                *group,
            )?,
            PolyOp::Add => layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Add)?,
            PolyOp::Sub => layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Sub)?,
@@ -299,10 +277,9 @@ impl<
            PolyOp::Reshape(d) | PolyOp::Flatten(d) => layouts::reshape(values[..].try_into()?, d)?,
            PolyOp::Pad(p) => {
                if values.len() != 1 {
-                    return Err(TensorError::DimError(
+                    return Err(Box::new(TensorError::DimError(
                        "Pad operation requires a single input".to_string(),
-                    )
-                    .into());
+                    )));
                }
                let mut input = values[0].clone();
                input.pad(p.clone(), 0)?;
@@ -319,7 +296,7 @@ impl<
        }))
    }

-    fn out_scale(&self, in_scales: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
+    fn out_scale(&self, in_scales: Vec<crate::Scale>) -> Result<crate::Scale, Box<dyn Error>> {
        let scale = match self {
            PolyOp::MeanOfSquares { .. } => 2 * in_scales[0],
            PolyOp::Xor | PolyOp::Or | PolyOp::And | PolyOp::Not => 0,
--- a/src/circuit/ops/region.rs
+++ b/src/circuit/ops/region.rs
@@ -1,7 +1,6 @@
 use crate::{
    circuit::table::Range,
-    fieldutils::IntegerRep,
-    tensor::{Tensor, TensorType, ValTensor, ValType, VarTensor},
+    tensor::{Tensor, TensorError, TensorType, ValTensor, ValType, VarTensor},
 };
 #[cfg(not(target_arch = "wasm32"))]
 use colored::Colorize;
@@ -10,8 +9,7 @@ use halo2_proofs::{
    plonk::{Error, Selector},
 };
 use halo2curves::ff::PrimeField;
-use itertools::Itertools;
-use maybe_rayon::iter::ParallelExtend;
+use portable_atomic::AtomicI128 as AtomicInt;
 use std::{
    cell::RefCell,
    collections::{HashMap, HashSet},
@@ -21,7 +19,7 @@ use std::{
    },
 };

-use super::{lookup::LookupOp, CircuitError};
+use super::lookup::LookupOp;

 /// Constants map
 pub type ConstantsMap<F> = HashMap<F, ValType<F>>;
@@ -86,77 +84,43 @@ impl ShuffleIndex {
    }
 }

-#[derive(Debug, Clone)]
-/// Some settings for a region to differentiate it across the different phases of proof generation
-pub struct RegionSettings {
-    /// whether we are in witness generation mode
-    pub witness_gen: bool,
-    /// whether we should check range checks for validity
-    pub check_range: bool,
+/// Region error
+#[derive(Debug, thiserror::Error)]
+pub enum RegionError {
+    /// wrap other regions
+    #[error("Wrapped region: {0}")]
+    Wrapped(String),
 }

-#[allow(unsafe_code)]
-unsafe impl Sync for RegionSettings {}
-#[allow(unsafe_code)]
-unsafe impl Send for RegionSettings {}
-
-impl RegionSettings {
-    /// Create a new region settings
-    pub fn new(witness_gen: bool, check_range: bool) -> RegionSettings {
-        RegionSettings {
-            witness_gen,
-            check_range,
-        }
-    }
-
-    /// Create a new region settings with all true
-    pub fn all_true() -> RegionSettings {
-        RegionSettings {
-            witness_gen: true,
-            check_range: true,
-        }
-    }
-
-    /// Create a new region settings with all false
-    pub fn all_false() -> RegionSettings {
-        RegionSettings {
-            witness_gen: false,
-            check_range: false,
-        }
+impl From<String> for RegionError {
+    fn from(e: String) -> Self {
+        Self::Wrapped(e)
    }
 }

-#[derive(Debug, Default, Clone)]
-/// Region statistics
-pub struct RegionStatistics {
-    /// the current maximum value of the lookup inputs
-    pub max_lookup_inputs: IntegerRep,
-    /// the current minimum value of the lookup inputs
-    pub min_lookup_inputs: IntegerRep,
-    /// the current maximum value of the range size
-    pub max_range_size: IntegerRep,
-    /// the current set of used lookups
-    pub used_lookups: HashSet<LookupOp>,
-    /// the current set of used range checks
-    pub used_range_checks: HashSet<Range>,
-}
-
-impl RegionStatistics {
-    /// update the statistics with another set of statistics
-    pub fn update(&mut self, other: &RegionStatistics) {
-        self.max_lookup_inputs = self.max_lookup_inputs.max(other.max_lookup_inputs);
-        self.min_lookup_inputs = self.min_lookup_inputs.min(other.min_lookup_inputs);
-        self.max_range_size = self.max_range_size.max(other.max_range_size);
-        self.used_lookups.extend(other.used_lookups.clone());
-        self.used_range_checks
-            .extend(other.used_range_checks.clone());
+impl From<&str> for RegionError {
+    fn from(e: &str) -> Self {
+        Self::Wrapped(e.to_string())
    }
 }

-#[allow(unsafe_code)]
-unsafe impl Sync for RegionStatistics {}
-#[allow(unsafe_code)]
-unsafe impl Send for RegionStatistics {}
+impl From<TensorError> for RegionError {
+    fn from(e: TensorError) -> Self {
+        Self::Wrapped(format!("{:?}", e))
+    }
+}
+
+impl From<Error> for RegionError {
+    fn from(e: Error) -> Self {
+        Self::Wrapped(format!("{:?}", e))
+    }
+}
+
+impl From<Box<dyn std::error::Error>> for RegionError {
+    fn from(e: Box<dyn std::error::Error>) -> Self {
+        Self::Wrapped(format!("{:?}", e))
+    }
+}

 #[derive(Debug)]
 /// A context for a region
@@ -167,8 +131,12 @@ pub struct RegionCtx<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Ha
    num_inner_cols: usize,
    dynamic_lookup_index: DynamicLookupIndex,
    shuffle_index: ShuffleIndex,
-    statistics: RegionStatistics,
-    settings: RegionSettings,
+    used_lookups: HashSet<LookupOp>,
+    used_range_checks: HashSet<Range>,
+    max_lookup_inputs: i128,
+    min_lookup_inputs: i128,
+    max_range_size: i128,
+    witness_gen: bool,
    assigned_constants: ConstantsMap<F>,
 }

@@ -220,17 +188,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a

    ///
    pub fn witness_gen(&self) -> bool {
-        self.settings.witness_gen
-    }
-
-    ///
-    pub fn check_range(&self) -> bool {
-        self.settings.check_range
-    }
-
-    ///
-    pub fn statistics(&self) -> &RegionStatistics {
-        &self.statistics
+        self.witness_gen
    }

    /// Create a new region context
@@ -245,8 +203,12 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
            linear_coord,
            dynamic_lookup_index: DynamicLookupIndex::default(),
            shuffle_index: ShuffleIndex::default(),
-            statistics: RegionStatistics::default(),
-            settings: RegionSettings::all_true(),
+            used_lookups: HashSet::new(),
+            used_range_checks: HashSet::new(),
+            max_lookup_inputs: 0,
+            min_lookup_inputs: 0,
+            max_range_size: 0,
+            witness_gen: true,
            assigned_constants: HashMap::new(),
        }
    }
@@ -262,13 +224,34 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
        new_self.assigned_constants = constants;
        new_self
    }
-
-    /// Create a new region context
-    pub fn new_dummy(
+    /// Create a new region context from a wrapped region
+    pub fn from_wrapped_region(
+        region: Option<RefCell<Region<'a, F>>>,
        row: usize,
        num_inner_cols: usize,
-        settings: RegionSettings,
+        dynamic_lookup_index: DynamicLookupIndex,
+        shuffle_index: ShuffleIndex,
    ) -> RegionCtx<'a, F> {
+        let linear_coord = row * num_inner_cols;
+        RegionCtx {
+            region,
+            num_inner_cols,
+            linear_coord,
+            row,
+            dynamic_lookup_index,
+            shuffle_index,
+            used_lookups: HashSet::new(),
+            used_range_checks: HashSet::new(),
+            max_lookup_inputs: 0,
+            min_lookup_inputs: 0,
+            max_range_size: 0,
+            witness_gen: false,
+            assigned_constants: HashMap::new(),
+        }
+    }
+
+    /// Create a new region context
+    pub fn new_dummy(row: usize, num_inner_cols: usize, witness_gen: bool) -> RegionCtx<'a, F> {
        let region = None;
        let linear_coord = row * num_inner_cols;

@@ -279,8 +262,12 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
            row,
            dynamic_lookup_index: DynamicLookupIndex::default(),
            shuffle_index: ShuffleIndex::default(),
-            statistics: RegionStatistics::default(),
-            settings,
+            used_lookups: HashSet::new(),
+            used_range_checks: HashSet::new(),
+            max_lookup_inputs: 0,
+            min_lookup_inputs: 0,
+            max_range_size: 0,
+            witness_gen,
            assigned_constants: HashMap::new(),
        }
    }
@@ -290,7 +277,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
        row: usize,
        linear_coord: usize,
        num_inner_cols: usize,
-        settings: RegionSettings,
+        witness_gen: bool,
    ) -> RegionCtx<'a, F> {
        let region = None;
        RegionCtx {
@@ -300,8 +287,12 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
            row,
            dynamic_lookup_index: DynamicLookupIndex::default(),
            shuffle_index: ShuffleIndex::default(),
-            statistics: RegionStatistics::default(),
-            settings,
+            used_lookups: HashSet::new(),
+            used_range_checks: HashSet::new(),
+            max_lookup_inputs: 0,
+            min_lookup_inputs: 0,
+            max_range_size: 0,
+            witness_gen,
            assigned_constants: HashMap::new(),
        }
    }
@@ -310,10 +301,10 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
    pub fn apply_in_loop<T: TensorType + Send + Sync>(
        &mut self,
        output: &mut Tensor<T>,
-        inner_loop_function: impl Fn(usize, &mut RegionCtx<'a, F>) -> Result<T, CircuitError>
+        inner_loop_function: impl Fn(usize, &mut RegionCtx<'a, F>) -> Result<T, RegionError>
            + Send
            + Sync,
-    ) -> Result<(), CircuitError> {
+    ) -> Result<(), RegionError> {
        if self.is_dummy() {
            self.dummy_loop(output, inner_loop_function)?;
        } else {
@@ -326,8 +317,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
    pub fn real_loop<T: TensorType + Send + Sync>(
        &mut self,
        output: &mut Tensor<T>,
-        inner_loop_function: impl Fn(usize, &mut RegionCtx<'a, F>) -> Result<T, CircuitError>,
-    ) -> Result<(), CircuitError> {
+        inner_loop_function: impl Fn(usize, &mut RegionCtx<'a, F>) -> Result<T, RegionError>,
+    ) -> Result<(), RegionError> {
        output
            .iter_mut()
            .enumerate()
@@ -335,7 +326,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
                *o = inner_loop_function(i, self)?;
                Ok(())
            })
-            .collect::<Result<Vec<_>, CircuitError>>()?;
+            .collect::<Result<Vec<_>, RegionError>>()?;

        Ok(())
    }
@@ -346,71 +337,114 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
    pub fn dummy_loop<T: TensorType + Send + Sync>(
        &mut self,
        output: &mut Tensor<T>,
-        inner_loop_function: impl Fn(usize, &mut RegionCtx<'a, F>) -> Result<T, CircuitError>
+        inner_loop_function: impl Fn(usize, &mut RegionCtx<'a, F>) -> Result<T, RegionError>
            + Send
            + Sync,
-    ) -> Result<(), CircuitError> {
+    ) -> Result<(), RegionError> {
        let row = AtomicUsize::new(self.row());
        let linear_coord = AtomicUsize::new(self.linear_coord());
-        let statistics = Arc::new(Mutex::new(self.statistics.clone()));
-        let shuffle_index = Arc::new(Mutex::new(self.shuffle_index.clone()));
+        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()));
        let dynamic_lookup_index = Arc::new(Mutex::new(self.dynamic_lookup_index.clone()));
+        let shuffle_index = Arc::new(Mutex::new(self.shuffle_index.clone()));
        let constants = Arc::new(Mutex::new(self.assigned_constants.clone()));

-        *output = output.par_enum_map(|idx, _| {
-            // we kick off the loop with the current offset
-            let starting_offset = row.load(Ordering::SeqCst);
-            let starting_linear_coord = linear_coord.load(Ordering::SeqCst);
-            // get inner value of the locked lookups
+        *output = output
+            .par_enum_map(|idx, _| {
+                // we kick off the loop with the current offset
+                let starting_offset = row.load(Ordering::SeqCst);
+                let starting_linear_coord = linear_coord.load(Ordering::SeqCst);
+                // get inner value of the locked lookups

-            // we need to make sure that the region is not shared between threads
-            let mut local_reg = Self::new_dummy_with_linear_coord(
-                starting_offset,
-                starting_linear_coord,
-                self.num_inner_cols,
-                self.settings.clone(),
-            );
-            let res = inner_loop_function(idx, &mut local_reg);
-            // we update the offset and constants
-            row.fetch_add(local_reg.row() - starting_offset, Ordering::SeqCst);
-            linear_coord.fetch_add(
-                local_reg.linear_coord() - starting_linear_coord,
-                Ordering::SeqCst,
-            );
+                // we need to make sure that the region is not shared between threads
+                let mut local_reg = Self::new_dummy_with_linear_coord(
+                    starting_offset,
+                    starting_linear_coord,
+                    self.num_inner_cols,
+                    self.witness_gen,
+                );
+                let res = inner_loop_function(idx, &mut local_reg);
+                // we update the offset and constants
+                row.fetch_add(local_reg.row() - starting_offset, Ordering::SeqCst);
+                linear_coord.fetch_add(
+                    local_reg.linear_coord() - starting_linear_coord,
+                    Ordering::SeqCst,
+                );

-            // update the lookups
-            let mut statistics = statistics.lock().unwrap();
-            statistics.update(local_reg.statistics());
-            // update the dynamic lookup index
-            let mut dynamic_lookup_index = dynamic_lookup_index.lock().unwrap();
-            dynamic_lookup_index.update(&local_reg.dynamic_lookup_index);
-            // update the shuffle index
-            let mut shuffle_index = shuffle_index.lock().unwrap();
-            shuffle_index.update(&local_reg.shuffle_index);
-            // update the constants
-            let mut constants = constants.lock().unwrap();
-            constants.extend(local_reg.assigned_constants);
+                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());
+                // update the range checks
+                let mut range_checks = range_checks.lock().unwrap();
+                range_checks.extend(local_reg.used_range_checks());
+                // update the dynamic lookup index
+                let mut dynamic_lookup_index = dynamic_lookup_index.lock().unwrap();
+                dynamic_lookup_index.update(&local_reg.dynamic_lookup_index);
+                // update the shuffle index
+                let mut shuffle_index = shuffle_index.lock().unwrap();
+                shuffle_index.update(&local_reg.shuffle_index);
+                // update the constants
+                let mut constants = constants.lock().unwrap();
+                constants.extend(local_reg.assigned_constants);

-            res
-        })?;
+                res
+            })
+            .map_err(|e| RegionError::from(format!("dummy_loop: {:?}", e)))?;
        self.linear_coord = linear_coord.into_inner();
+        #[allow(trivial_numeric_casts)]
+        {
+            self.max_lookup_inputs = max_lookup_inputs.into_inner();
+            self.min_lookup_inputs = min_lookup_inputs.into_inner();
+        }
        self.row = row.into_inner();
-        self.statistics = Arc::try_unwrap(statistics)
-            .map_err(|e| CircuitError::GetLookupsError(format!("{:?}", e)))?
+        self.used_lookups = Arc::try_unwrap(lookups)
+            .map_err(|e| RegionError::from(format!("dummy_loop: failed to get lookups: {:?}", e)))?
            .into_inner()
-            .map_err(|e| CircuitError::GetLookupsError(format!("{:?}", e)))?;
+            .map_err(|e| {
+                RegionError::from(format!("dummy_loop: failed to get lookups: {:?}", e))
+            })?;
+        self.used_range_checks = Arc::try_unwrap(range_checks)
+            .map_err(|e| {
+                RegionError::from(format!("dummy_loop: failed to get range checks: {:?}", e))
+            })?
+            .into_inner()
+            .map_err(|e| {
+                RegionError::from(format!("dummy_loop: failed to get range checks: {:?}", e))
+            })?;
        self.dynamic_lookup_index = Arc::try_unwrap(dynamic_lookup_index)
-            .map_err(|e| CircuitError::GetDynamicLookupError(format!("{:?}", e)))?
+            .map_err(|e| {
+                RegionError::from(format!(
+                    "dummy_loop: failed to get dynamic lookup index: {:?}",
+                    e
+                ))
+            })?
            .into_inner()
-            .map_err(|e| CircuitError::GetDynamicLookupError(format!("{:?}", e)))?;
+            .map_err(|e| {
+                RegionError::from(format!(
+                    "dummy_loop: failed to get dynamic lookup index: {:?}",
+                    e
+                ))
+            })?;
        self.shuffle_index = Arc::try_unwrap(shuffle_index)
-            .map_err(|e| CircuitError::GetShuffleError(format!("{:?}", e)))?
+            .map_err(|e| {
+                RegionError::from(format!("dummy_loop: failed to get shuffle index: {:?}", e))
+            })?
            .into_inner()
-            .map_err(|e| CircuitError::GetShuffleError(format!("{:?}", e)))?;
+            .map_err(|e| {
+                RegionError::from(format!("dummy_loop: failed to get shuffle index: {:?}", e))
+            })?;
        self.assigned_constants = Arc::try_unwrap(constants)
-            .map_err(|e| CircuitError::GetConstantsError(format!("{:?}", e)))?
+            .map_err(|e| {
+                RegionError::from(format!("dummy_loop: failed to get constants: {:?}", e))
+            })?
            .into_inner()
-            .map_err(|e| CircuitError::GetConstantsError(format!("{:?}", e)))?;
+            .map_err(|e| {
+                RegionError::from(format!("dummy_loop: failed to get constants: {:?}", e))
+            })?;

        Ok(())
    }
@@ -419,26 +453,29 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
    pub fn update_max_min_lookup_inputs(
        &mut self,
        inputs: &[ValTensor<F>],
-    ) -> Result<(), CircuitError> {
+    ) -> Result<(), Box<dyn std::error::Error>> {
        let (mut min, mut max) = (0, 0);
        for i in inputs {
-            max = max.max(i.int_evals()?.into_iter().max().unwrap_or_default());
-            min = min.min(i.int_evals()?.into_iter().min().unwrap_or_default());
+            max = max.max(i.get_int_evals()?.into_iter().max().unwrap_or_default());
+            min = min.min(i.get_int_evals()?.into_iter().min().unwrap_or_default());
        }
-        self.statistics.max_lookup_inputs = self.statistics.max_lookup_inputs.max(max);
-        self.statistics.min_lookup_inputs = self.statistics.min_lookup_inputs.min(min);
+        self.max_lookup_inputs = self.max_lookup_inputs.max(max);
+        self.min_lookup_inputs = self.min_lookup_inputs.min(min);
        Ok(())
    }

    /// Update the max and min from inputs
-    pub fn update_max_min_lookup_range(&mut self, range: Range) -> Result<(), CircuitError> {
+    pub fn update_max_min_lookup_range(
+        &mut self,
+        range: Range,
+    ) -> Result<(), Box<dyn std::error::Error>> {
        if range.0 > range.1 {
-            return Err(CircuitError::InvalidMinMaxRange(range.0, range.1));
+            return Err(format!("update_max_min_lookup_range: invalid range {:?}", range).into());
        }

        let range_size = (range.1 - range.0).abs();

-        self.statistics.max_range_size = self.statistics.max_range_size.max(range_size);
+        self.max_range_size = self.max_range_size.max(range_size);
        Ok(())
    }

@@ -452,14 +489,14 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
        &mut self,
        lookup: LookupOp,
        inputs: &[ValTensor<F>],
-    ) -> Result<(), CircuitError> {
-        self.statistics.used_lookups.insert(lookup);
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        self.used_lookups.insert(lookup);
        self.update_max_min_lookup_inputs(inputs)
    }

    /// add used range check
-    pub fn add_used_range_check(&mut self, range: Range) -> Result<(), CircuitError> {
-        self.statistics.used_range_checks.insert(range);
+    pub fn add_used_range_check(&mut self, range: Range) -> Result<(), Box<dyn std::error::Error>> {
+        self.used_range_checks.insert(range);
        self.update_max_min_lookup_range(range)
    }

@@ -500,27 +537,27 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a

    /// get used lookups
    pub fn used_lookups(&self) -> HashSet<LookupOp> {
-        self.statistics.used_lookups.clone()
+        self.used_lookups.clone()
    }

    /// get used range checks
    pub fn used_range_checks(&self) -> HashSet<Range> {
-        self.statistics.used_range_checks.clone()
+        self.used_range_checks.clone()
    }

    /// max lookup inputs
-    pub fn max_lookup_inputs(&self) -> IntegerRep {
-        self.statistics.max_lookup_inputs
+    pub fn max_lookup_inputs(&self) -> i128 {
+        self.max_lookup_inputs
    }

    /// min lookup inputs
-    pub fn min_lookup_inputs(&self) -> IntegerRep {
-        self.statistics.min_lookup_inputs
+    pub fn min_lookup_inputs(&self) -> i128 {
+        self.min_lookup_inputs
    }

    /// max range check
-    pub fn max_range_size(&self) -> IntegerRep {
-        self.statistics.max_range_size
+    pub fn max_range_size(&self) -> i128 {
+        self.max_range_size
    }

    /// Assign a valtensor to a vartensor
@@ -528,18 +565,18 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
        &mut self,
        var: &VarTensor,
        values: &ValTensor<F>,
-    ) -> Result<ValTensor<F>, CircuitError> {
+    ) -> Result<ValTensor<F>, Error> {
        if let Some(region) = &self.region {
-            Ok(var.assign(
+            var.assign(
                &mut region.borrow_mut(),
                self.linear_coord,
                values,
                &mut self.assigned_constants,
-            )?)
+            )
        } else {
            if !values.is_instance() {
                let values_map = values.create_constants_map_iterator();
-                self.assigned_constants.par_extend(values_map);
+                self.assigned_constants.extend(values_map);
            }
            Ok(values.clone())
        }
@@ -555,18 +592,18 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
        &mut self,
        var: &VarTensor,
        values: &ValTensor<F>,
-    ) -> Result<ValTensor<F>, CircuitError> {
+    ) -> Result<ValTensor<F>, Error> {
        if let Some(region) = &self.region {
-            Ok(var.assign(
+            var.assign(
                &mut region.borrow_mut(),
                self.combined_dynamic_shuffle_coord(),
                values,
                &mut self.assigned_constants,
-            )?)
+            )
        } else {
            if !values.is_instance() {
                let values_map = values.create_constants_map_iterator();
-                self.assigned_constants.par_extend(values_map);
+                self.assigned_constants.extend(values_map);
            }
            Ok(values.clone())
        }
@@ -577,7 +614,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
        &mut self,
        var: &VarTensor,
        values: &ValTensor<F>,
-    ) -> Result<ValTensor<F>, CircuitError> {
+    ) -> Result<ValTensor<F>, Error> {
        self.assign_dynamic_lookup(var, values)
    }

@@ -586,24 +623,27 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
        &mut self,
        var: &VarTensor,
        values: &ValTensor<F>,
-        ommissions: &HashSet<usize>,
-    ) -> Result<ValTensor<F>, CircuitError> {
+        ommissions: &HashSet<&usize>,
+    ) -> Result<ValTensor<F>, Error> {
        if let Some(region) = &self.region {
-            Ok(var.assign_with_omissions(
+            var.assign_with_omissions(
                &mut region.borrow_mut(),
                self.linear_coord,
                values,
                ommissions,
                &mut self.assigned_constants,
-            )?)
+            )
        } else {
-            let mut values_clone = values.clone();
-            let mut indices = ommissions.clone().into_iter().collect_vec();
-            values_clone.remove_indices(&mut indices, false)?;
+            let inner_tensor = values.get_inner_tensor().unwrap();
+            let mut values_map = values.create_constants_map();

-            let values_map = values.create_constants_map();
+            for o in ommissions {
+                if let ValType::Constant(value) = inner_tensor.get_flat_index(**o) {
+                    values_map.remove(&value);
+                }
+            }

-            self.assigned_constants.par_extend(values_map);
+            self.assigned_constants.extend(values_map);

            Ok(values.clone())
        }
@@ -650,11 +690,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
    }

    /// constrain equal
-    pub fn constrain_equal(
-        &mut self,
-        a: &ValTensor<F>,
-        b: &ValTensor<F>,
-    ) -> Result<(), CircuitError> {
+    pub fn constrain_equal(&mut self, a: &ValTensor<F>, b: &ValTensor<F>) -> Result<(), Error> {
        if let Some(region) = &self.region {
            let a = a.get_inner_tensor().unwrap();
            let b = b.get_inner_tensor().unwrap();
@@ -664,12 +700,12 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
                let b = b.get_prev_assigned();
                // if they're both assigned, we can constrain them
                if let (Some(a), Some(b)) = (&a, &b) {
-                    region
-                        .borrow_mut()
-                        .constrain_equal(a.cell(), b.cell())
-                        .map_err(|e| e.into())
+                    region.borrow_mut().constrain_equal(a.cell(), b.cell())
                } else if a.is_some() || b.is_some() {
-                    return Err(CircuitError::ConstrainError);
+                    log::error!(
+                        "constrain_equal: one of the tensors is assigned and the other is not"
+                    );
+                    return Err(Error::Synthesis);
                } else {
                    Ok(())
                }
@@ -695,7 +731,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
    }

    /// flush row to the next row
-    pub fn flush(&mut self) -> Result<(), CircuitError> {
+    pub fn flush(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        // increment by the difference between the current linear coord and the next row
        let remainder = self.linear_coord % self.num_inner_cols;
        if remainder != 0 {
@@ -703,7 +739,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
            self.increment(diff);
        }
        if self.linear_coord % self.num_inner_cols != 0 {
-            return Err(CircuitError::FlushError);
+            return Err("flush: linear coord is not aligned with the next row".into());
        }
        Ok(())
    }
--- a/src/circuit/table.rs
+++ b/src/circuit/table.rs
@@ -1,4 +1,4 @@
-use std::marker::PhantomData;
+use std::{error::Error, marker::PhantomData};

 use halo2curves::ff::PrimeField;

@@ -11,33 +11,20 @@ use maybe_rayon::prelude::{IntoParallelIterator, ParallelIterator};

 use crate::{
    circuit::CircuitError,
-    fieldutils::{integer_rep_to_felt, IntegerRep},
+    fieldutils::i128_to_felt,
    tensor::{Tensor, TensorType},
 };

-#[cfg(not(target_arch = "wasm32"))]
-use crate::execute::EZKL_REPO_PATH;
-
 use crate::circuit::lookup::LookupOp;

 /// The range of the lookup table.
-pub type Range = (IntegerRep, IntegerRep);
+pub type Range = (i128, i128);

 /// The safety factor for the range of the lookup table.
-pub const RANGE_MULTIPLIER: IntegerRep = 2;
+pub const RANGE_MULTIPLIER: i128 = 2;
 /// The safety factor offset for the number of rows in the lookup table.
 pub const RESERVED_BLINDING_ROWS_PAD: usize = 3;

-#[cfg(not(target_arch = "wasm32"))]
-lazy_static::lazy_static! {
-    /// an optional directory to read and write the lookup table cache
-    pub static ref LOOKUP_CACHE: String = format!("{}/cache", *EZKL_REPO_PATH);
-}
-
-/// The lookup table cache is disabled on wasm32 target.
-#[cfg(target_arch = "wasm32")]
-pub const LOOKUP_CACHE: &str = "";
-
 #[derive(Debug, Clone)]
 ///
 pub struct SelectorConstructor<F: PrimeField> {
@@ -113,18 +100,17 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
    /// 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_integer_rep(input) - self.range.0).abs()
-            / (self.col_size as IntegerRep);
+        let chunk =
+            (crate::fieldutils::felt_to_i128(input) - self.range.0).abs() / (self.col_size as i128);

-        integer_rep_to_felt(chunk)
+        i128_to_felt(chunk)
    }

    /// get first_element of column
    pub fn get_first_element(&self, chunk: usize) -> (F, F) {
-        let chunk = chunk as IntegerRep;
+        let chunk = chunk as i128;
        // we index from 1 to prevent soundness issues
-        let first_element =
-            integer_rep_to_felt(chunk * (self.col_size as IntegerRep) + self.range.0);
+        let first_element = i128_to_felt(chunk * (self.col_size as i128) + self.range.0);
        let op_f = self
            .nonlinearity
            .f(&[Tensor::from(vec![first_element].into_iter())])
@@ -144,20 +130,12 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
 }

 ///
-pub fn num_cols_required(range_len: IntegerRep, col_size: usize) -> usize {
+pub fn num_cols_required(range_len: i128, col_size: usize) -> usize {
    // number of cols needed to store the range
-    (range_len / (col_size as IntegerRep)) as usize + 1
+    (range_len / (col_size as i128)) as usize + 1
 }

 impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
-    fn name(&self) -> String {
-        format!(
-            "{}_{}_{}",
-            self.nonlinearity.as_path(),
-            self.range.0,
-            self.range.1
-        )
-    }
    /// Configures the table.
    pub fn configure(
        cs: &mut ConstraintSystem<F>,
@@ -216,59 +194,16 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
        &mut self,
        layouter: &mut impl Layouter<F>,
        preassigned_input: bool,
-    ) -> Result<(), CircuitError> {
+    ) -> Result<(), Box<dyn Error>> {
        if self.is_assigned {
-            return Err(CircuitError::TableAlreadyAssigned);
+            return Err(Box::new(CircuitError::TableAlreadyAssigned));
        }

        let smallest = self.range.0;
        let largest = self.range.1;

-        let gen_table = || -> Result<(Tensor<F>, Tensor<F>), crate::tensor::TensorError> {
-            let inputs = Tensor::from(smallest..=largest)
-                .par_enum_map(|_, x| Ok::<_, crate::tensor::TensorError>(integer_rep_to_felt(x)))?;
-            let evals = self.nonlinearity.f(&[inputs.clone()])?;
-            Ok((inputs, evals.output))
-        };
-
-        let (inputs, evals) = if !LOOKUP_CACHE.is_empty() {
-            let cache = std::path::Path::new(&*LOOKUP_CACHE);
-            let cache_path = cache.join(self.name());
-            let input_path = cache_path.join("inputs");
-            let output_path = cache_path.join("outputs");
-            if cache_path.exists() {
-                log::info!("Loading lookup table from cache: {:?}", cache_path);
-                let (input_cache, output_cache) =
-                    (Tensor::load(&input_path)?, Tensor::load(&output_path)?);
-                (input_cache, output_cache)
-            } else {
-                log::info!(
-                    "Generating lookup table and saving to cache: {:?}",
-                    cache_path
-                );
-
-                // mkdir -p cache_path
-                std::fs::create_dir_all(&cache_path).map_err(|e| {
-                    CircuitError::TensorError(crate::tensor::TensorError::FileSaveError(
-                        e.to_string(),
-                    ))
-                })?;
-
-                let (inputs, evals) = gen_table()?;
-                inputs.save(&input_path)?;
-                evals.save(&output_path)?;
-
-                (inputs, evals)
-            }
-        } else {
-            log::info!(
-                "Generating lookup table {} without cache",
-                self.nonlinearity.as_path()
-            );
-
-            gen_table()?
-        };
-
+        let inputs: Tensor<F> = Tensor::from(smallest..=largest).map(|x| i128_to_felt(x));
+        let evals = self.nonlinearity.f(&[inputs.clone()])?;
        let chunked_inputs = inputs.chunks(self.col_size);

        self.is_assigned = true;
@@ -300,7 +235,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
                                    )?;
                                }

-                                let output = evals[row_offset];
+                                let output = evals.output[row_offset];

                                table.assign_cell(
                                    || format!("nl_o_col row {}", row_offset),
@@ -338,16 +273,11 @@ pub struct RangeCheck<F: PrimeField> {
 }

 impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RangeCheck<F> {
-    /// as path
-    pub fn as_path(&self) -> String {
-        format!("rangecheck_{}_{}", self.range.0, self.range.1)
-    }
-
    /// get first_element of column
    pub fn get_first_element(&self, chunk: usize) -> F {
-        let chunk = chunk as IntegerRep;
+        let chunk = chunk as i128;
        // we index from 1 to prevent soundness issues
-        integer_rep_to_felt(chunk * (self.col_size as IntegerRep) + self.range.0)
+        i128_to_felt(chunk * (self.col_size as i128) + self.range.0)
    }

    ///
@@ -363,10 +293,10 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RangeCheck<F> {
    /// 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_integer_rep(input) - self.range.0).abs()
-            / (self.col_size as IntegerRep);
+        let chunk =
+            (crate::fieldutils::felt_to_i128(input) - self.range.0).abs() / (self.col_size as i128);

-        integer_rep_to_felt(chunk)
+        i128_to_felt(chunk)
    }
 }

@@ -412,40 +342,15 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RangeCheck<F> {
    }

    /// Assigns values to the constraints generated when calling `configure`.
-    pub fn layout(&mut self, layouter: &mut impl Layouter<F>) -> Result<(), CircuitError> {
+    pub fn layout(&mut self, layouter: &mut impl Layouter<F>) -> Result<(), Box<dyn Error>> {
        if self.is_assigned {
-            return Err(CircuitError::TableAlreadyAssigned);
+            return Err(Box::new(CircuitError::TableAlreadyAssigned));
        }

        let smallest = self.range.0;
        let largest = self.range.1;

-        let inputs: Tensor<F> = if !LOOKUP_CACHE.is_empty() {
-            let cache = std::path::Path::new(&*LOOKUP_CACHE);
-            let cache_path = cache.join(self.as_path());
-            let input_path = cache_path.join("inputs");
-            if cache_path.exists() {
-                log::info!("Loading range check table from cache: {:?}", cache_path);
-                Tensor::load(&input_path)?
-            } else {
-                log::info!(
-                    "Generating range check table and saving to cache: {:?}",
-                    cache_path
-                );
-
-                // mkdir -p cache_path
-                std::fs::create_dir_all(&cache_path)?;
-
-                let inputs = Tensor::from(smallest..=largest).map(|x| integer_rep_to_felt(x));
-                inputs.save(&input_path)?;
-                inputs
-            }
-        } else {
-            log::info!("Generating range check {} without cache", self.as_path());
-
-            Tensor::from(smallest..=largest).map(|x| integer_rep_to_felt(x))
-        };
-
+        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;
--- a/src/circuit/tests.rs
+++ b/src/circuit/tests.rs
@@ -256,7 +256,7 @@ mod matmul_col_ultra_overflow_double_col {
    use super::*;

    const K: usize = 4;
-    const LEN: usize = 10;
+    const LEN: usize = 20;
    const NUM_INNER_COLS: usize = 2;

    #[derive(Clone)]
@@ -374,7 +374,7 @@ mod matmul_col_ultra_overflow {
    use super::*;

    const K: usize = 4;
-    const LEN: usize = 10;
+    const LEN: usize = 20;

    #[derive(Clone)]
    struct MatmulCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -1050,7 +1050,6 @@ mod conv {
                                Box::new(PolyOp::Conv {
                                    padding: vec![(1, 1); 2],
                                    stride: vec![2; 2],
-                                    group: 1,
                                }),
                            )
                            .map_err(|_| Error::Synthesis)
@@ -1159,7 +1158,7 @@ mod conv_col_ultra_overflow {
    use super::*;

    const K: usize = 4;
-    const LEN: usize = 10;
+    const LEN: usize = 28;

    #[derive(Clone)]
    struct ConvCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -1201,7 +1200,6 @@ mod conv_col_ultra_overflow {
                                Box::new(PolyOp::Conv {
                                    padding: vec![(1, 1); 2],
                                    stride: vec![2; 2],
-                                    group: 1,
                                }),
                            )
                            .map_err(|_| Error::Synthesis)
@@ -1298,7 +1296,7 @@ mod conv_relu_col_ultra_overflow {
    use super::*;

    const K: usize = 4;
-    const LEN: usize = 15;
+    const LEN: usize = 28;

    #[derive(Clone)]
    struct ConvCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -1347,7 +1345,6 @@ mod conv_relu_col_ultra_overflow {
                                Box::new(PolyOp::Conv {
                                    padding: vec![(1, 1); 2],
                                    stride: vec![2; 2],
-                                    group: 1,
                                }),
                            )
                            .map_err(|_| Error::Synthesis);
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				`[{"type":"function","name":"verifyProof","inputs":[{"name":"proof","type":"bytes","internalType":"bytes"},{"name":"instances","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"}]`
				`@@ -1 +0,0 @@`
				{"run_args":{"tolerance":{"val":0.0,"scale":1.0},"input_scale":7,"param_scale":7,"scale_rebase_multiplier":10,"lookup_range":[0,0],"logrows":13,"variables":[["batch_size",1]],"input_visibility":"Private","output_visibility":"Public","param_visibility":"Private"},"num_constraints":5619,"total_const_size":513,"model_instance_shapes":[[1,3,10,10]],"model_output_scales":[14],"model_input_scales":[7],"module_sizes":{"kzg":[],"poseidon":[0,[0]],"elgamal":[0,[0]]},"required_lookups":[],"check_mode":"UNSAFE","version":"0.0.0","num_blinding_factors":null}
				`@@ -1 +0,0 @@`
				`network.onnx filter=lfs diff=lfs merge=lfs -text`