ci: update version string in docs

* fix: remove armv7 rpi4 uses aarch64

* fix: remove 0.0.0 as it is causing failures

.cargo/config

@@ -1,4 +0,0 @@
-[target.wasm32-unknown-unknown]
-runner = 'wasm-bindgen-test-runner'
-rustflags = ["-C", "target-feature=+atomics,+bulk-memory,+mutable-globals","-C",
- "link-arg=--max-memory=4294967296"]

.cargo/config.toml

@@ -0,0 +1,17 @@
+[target.wasm32-unknown-unknown]
+runner = 'wasm-bindgen-test-runner'
+rustflags = ["-C", "target-feature=+atomics,+bulk-memory,+mutable-globals","-C",
+ "link-arg=--max-memory=4294967296"]
+
+
+[target.x86_64-apple-darwin]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]
+
+[target.aarch64-apple-darwin]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]

.github/workflows/engine.yml

@@ -22,15 +22,18 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           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-02-06-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
       - name: Install binaryen
         run: |
           set -e

.github/workflows/large-tests.yml

@@ -11,7 +11,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - name: nanoGPT Mock

.github/workflows/pypi-gpu.yml

@@ -98,14 +98,14 @@ jobs:
       # publishes to PyPI
       - name: Publish package distributions to PyPI
         continue-on-error: true
-        uses: pypa/gh-action-pypi-publish@release/v1
+        uses: pypa/gh-action-pypi-publish@unstable/v1
         with:
           packages-dir: ./
 
       # publishes to TestPyPI
       - name: Publish package distribution to TestPyPI
         continue-on-error: true
-        uses: pypa/gh-action-pypi-publish@release/v1
+        uses: pypa/gh-action-pypi-publish@unstable/v1
         with:
           repository-url: https://test.pypi.org/legacy/
           packages-dir: ./

.github/workflows/pypi.yml

@@ -40,7 +40,7 @@ jobs:
 
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
 
@@ -86,7 +86,7 @@ jobs:
 
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
 
@@ -168,7 +168,7 @@ jobs:
           name: wheels
           path: dist
 
-  # TODO: There's a problem with the maturin-action toolchain for arm arch leading to failed builds
+  #  There's a problem with the maturin-action toolchain for arm arch leading to failed builds
   # linux-cross:
   #   runs-on: ubuntu-latest
   #   strategy:
@@ -283,8 +283,6 @@ jobs:
         platform:
           - target: aarch64-unknown-linux-musl
             arch: aarch64
-          - target: armv7-unknown-linux-musleabihf
-            arch: armv7
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
@@ -308,7 +306,7 @@ jobs:
           manylinux: musllinux_1_2
           args: --release --out dist --features python-bindings
 
-      - uses: uraimo/run-on-arch-action@v2.5.0
+      - uses: uraimo/run-on-arch-action@v2.8.1
         name: Install built wheel
         with:
           arch: ${{ matrix.platform.arch }}
@@ -350,14 +348,14 @@ jobs:
       # publishes to PyPI
       - name: Publish package distributions to PyPI
         continue-on-error: true
-        uses: pypa/gh-action-pypi-publish@release/v1
+        uses: pypa/gh-action-pypi-publish@unstable/v1
         with:
           packages-dir: ./
 
       # publishes to TestPyPI
       - name: Publish package distribution to TestPyPI
         continue-on-error: true
-        uses: pypa/gh-action-pypi-publish@release/v1
+        uses: pypa/gh-action-pypi-publish@unstable/v1
         with:
           repository-url: https://test.pypi.org/legacy/
           packages-dir: ./

.github/workflows/release.yml

@@ -45,7 +45,7 @@ jobs:
     steps:
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - name: Checkout repo
@@ -106,27 +106,27 @@ jobs:
         include:
           - build: windows-msvc
             os: windows-latest
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
             target: x86_64-pc-windows-msvc
           - build: macos
             os: macos-13
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
             target: x86_64-apple-darwin
           - build: macos-aarch64
             os: macos-13
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
             target: aarch64-apple-darwin
           - build: linux-musl
             os: ubuntu-22.04
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
             target: x86_64-unknown-linux-musl
           - build: linux-gnu
             os: ubuntu-22.04
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
             target: x86_64-unknown-linux-gnu
           - build: linux-aarch64
             os: ubuntu-22.04
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
             target: aarch64-unknown-linux-gnu
 
     steps:
@@ -181,9 +181,14 @@ jobs:
           echo "target flag is: ${{ env.TARGET_FLAGS }}"
           echo "target dir is: ${{ env.TARGET_DIR }}"
 
-      - name: Build release binary
+      - name: Build release binary (no asm)
+        if: matrix.build != 'linux-gnu'
         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'
         run: strip "target/${{ matrix.target }}/release/ezkl"

.github/workflows/rust.yml

@@ -26,7 +26,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           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-02-06
+          toolchain: nightly-2024-07-18
           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-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -65,40 +65,40 @@ jobs:
       - name: Library tests (original lookup)
         run: cargo nextest run --lib --verbose --no-default-features --features ezkl
 
-  ultra-overflow-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
-      - uses: baptiste0928/cargo-install@v1
-        with:
-          crate: cargo-nextest
-          locked: true
-      - uses: mwilliamson/setup-wasmtime-action@v2
-        with:
-          wasmtime-version: "3.0.1"
-      - name: Install wasm32-wasi
-        run: rustup target add wasm32-wasi
-      - name: Install cargo-wasi
-        run: cargo install cargo-wasi
-      # - name: Matmul overflow (wasi)
-      #   run: cargo wasi test matmul_col_ultra_overflow -- --include-ignored --nocapture
-      # - name: Conv overflow (wasi)
-      #   run: cargo wasi test conv_col_ultra_overflow -- --include-ignored --nocapture
-      - name: lookup overflow
-        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  --release conv_relu_col_ultra_overflow --no-capture --features icicle -- --include-ignored
+  # ultra-overflow-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
+  #     - uses: baptiste0928/cargo-install@v1
+  #       with:
+  #         crate: cargo-nextest
+  #         locked: true
+  #     - uses: mwilliamson/setup-wasmtime-action@v2
+  #       with:
+  #         wasmtime-version: "3.0.1"
+  #     - name: Install wasm32-wasi
+  #       run: rustup target add wasm32-wasi
+  #     - name: Install cargo-wasi
+  #       run: cargo install cargo-wasi
+  #     # - name: Matmul overflow (wasi)
+  #     #   run: cargo wasi test matmul_col_ultra_overflow -- --include-ignored --nocapture
+  #     # - 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
+  #     - 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
 
   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-02-06
+          toolchain: nightly-2024-07-18
           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-02-06
+          toolchain: nightly-2024-07-18
           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-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -184,44 +184,29 @@ jobs:
 
   wasm32-tests:
     runs-on: ubuntu-latest
-    needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           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-02-06-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-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
         run: wasm-pack test --chrome --headless -- -Z build-std="panic_abort,std" --features web
 
-  tutorial:
-    runs-on: ubuntu-latest
-    needs: [build, library-tests, docs, python-tests, python-integration-tests]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly-2024-02-06
-          override: true
-          components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@v1
-        with:
-          crate: cargo-nextest
-          locked: true
-      - name: Circuit Render
-        run: cargo nextest run --release --verbose tests::tutorial_
-
   mock-proving-tests:
     runs-on: non-gpu
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
@@ -229,7 +214,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -238,10 +223,12 @@ jobs:
           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 bounded lookup log
+        run: cargo nextest run --release --verbose tests::mock_bounded_lookup_log --test-threads 32
       - name: public outputs and tolerance > 0
         run: cargo nextest run --release --verbose tests::mock_tolerance_public_outputs_ --test-threads 32
       - name: public outputs + batch size == 10
-        run: cargo nextest run --release --verbose tests::mock_large_batch_public_outputs_ --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_large_batch_public_outputs_ --test-threads 16
       - name: kzg inputs
         run: cargo nextest run --release --verbose tests::mock_kzg_input_::t  --test-threads 32
       - name: kzg params
@@ -260,6 +247,8 @@ 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
@@ -288,7 +277,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -306,7 +295,7 @@ jobs:
           node-version: "18.12.1"
           cache: "pnpm"
       - name: "Add rust-src"
-        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
       - name: Install dependencies for js tests and in-browser-evm-verifier package
         run: |
           pnpm install --frozen-lockfile
@@ -325,12 +314,12 @@ 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 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
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
+      - name: KZG prove and verify tests (EVM + reusable verifier + col-overflow)
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_prove_and_verify_reusable_verifier --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg all)
         run: cargo nextest run --release --verbose tests_evm::kzg_evm_kzg_all_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg inputs)
@@ -367,15 +356,18 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           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-02-06-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
       - uses: actions/checkout@v3
       - name: Use pnpm 8
         uses: pnpm/action-setup@v2
@@ -433,40 +425,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-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-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-mock-aggr-tests:
     runs-on: self-hosted
@@ -475,7 +467,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -485,23 +477,23 @@ jobs:
       - name: Mock aggr tests (KZG)
         run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_mock_prove_and_verify_  --test-threads 8
 
-  prove-and-verify-aggr-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
-      - uses: baptiste0928/cargo-install@v1
-        with:
-          crate: cargo-nextest
-          locked: true
-      - name: KZG )tests
-        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-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
+  #     - uses: baptiste0928/cargo-install@v1
+  #       with:
+  #         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
 
   prove-and-verify-aggr-tests:
     runs-on: large-self-hosted
@@ -510,7 +502,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -527,17 +519,17 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           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 c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --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
 
@@ -548,7 +540,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -568,17 +560,17 @@ jobs:
           python-version: "3.12"
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           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 c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
       - name: Build python ezkl
         run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
       - name: Run pytest
@@ -594,7 +586,7 @@ jobs:
           python-version: "3.12"
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -605,8 +597,6 @@ jobs:
         run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt;
       - name: Build python ezkl
         run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
-      - name: Div rebase
-        run: source .env/bin/activate; cargo nextest run --release --verbose tests::accuracy_measurement_div_rebase_
       - name: Public inputs
         run: source .env/bin/activate; cargo nextest run --release --verbose tests::accuracy_measurement_public_inputs_
       - name: fixed params
@@ -643,23 +633,27 @@ jobs:
           python-version: "3.11"
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
           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 c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
       - name: Install pip
         run: python -m ensurepip --upgrade
       - name: Setup Virtual Env and Install python dependencies
         run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt; python -m ensurepip --upgrade
       - name: Build python ezkl
         run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
+      - name: Neural bow
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::neural_bag_of_words_ --no-capture
+      - name: Felt conversion
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::felt_conversion_test_ --no-capture
       - name: Postgres tutorials
         run: source .env/bin/activate; cargo nextest run py_tests::tests::postgres_ --no-capture
       - name: Tictactoe tutorials
@@ -679,3 +673,68 @@ jobs:
         run: source .env/bin/activate; cargo nextest run py_tests::tests::voice_
       - name: NBEATS tutorial
         run: source .env/bin/activate; cargo nextest run py_tests::tests::nbeats_
+      # - name: Reusable verifier tutorial
+        # run: source .env/bin/activate; cargo nextest run py_tests::tests::reusable_
+
+  ios-integration-tests:
+      runs-on: macos-latest
+      steps:
+        - uses: actions/checkout@v4
+        - uses: actions-rs/toolchain@v1
+          with:
+            toolchain: nightly-2024-07-18
+            override: true
+            components: rustfmt, clippy
+        - uses: baptiste0928/cargo-install@v1
+          with:
+            crate: cargo-nextest
+            locked: true
+        - name: Run ios tests
+          run: CARGO_BUILD_TARGET=aarch64-apple-darwin RUSTUP_TOOLCHAIN=nightly-2024-07-18-aarch64-apple-darwin cargo test --test ios_integration_tests --features ios-bindings-test --no-default-features
+
+  swift-package-tests:
+      runs-on: macos-latest
+      needs: [ios-integration-tests]
+
+      steps:
+        - uses: actions/checkout@v4
+        - uses: actions-rs/toolchain@v1
+          with:
+            toolchain: nightly-2024-07-18
+            override: true
+            components: rustfmt, clippy
+        - name: Build EzklCoreBindings
+          run: CONFIGURATION=debug cargo run --bin ios_gen_bindings --features "ios-bindings uuid camino uniffi_bindgen" --no-default-features
+
+        - name: Clone ezkl-swift- repository
+          run: |
+            git clone https://github.com/zkonduit/ezkl-swift-package.git
+
+        - name: Copy EzklCoreBindings
+          run: |
+            rm -rf ezkl-swift-package/Sources/EzklCoreBindings
+            cp -r build/EzklCoreBindings ezkl-swift-package/Sources/
+
+        - name: Set up Xcode environment
+          run: |
+            sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
+            sudo xcodebuild -license accept
+
+        - name: Run Package Tests
+          run: |
+            cd ezkl-swift-package
+            xcodebuild test \
+              -scheme EzklPackage \
+              -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=17.5' \
+              -resultBundlePath ../testResults
+
+        - name: Run Example App Tests
+          run: |
+            cd ezkl-swift-package/Example
+            xcodebuild test \
+              -project Example.xcodeproj \
+              -scheme EzklApp \
+              -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=17.5' \
+              -parallel-testing-enabled NO \
+              -resultBundlePath ../../exampleTestResults \
+              -skip-testing:EzklAppUITests/EzklAppUITests/testButtonClicksInOrder

.github/workflows/update-ios-package.yml

@@ -0,0 +1,85 @@
+name: Build and Publish EZKL iOS SPM package
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "The tag to release"
+        required: true
+  push:
+    tags:
+      - "*"
+
+jobs:
+  build-and-update:
+    runs-on: macos-latest
+
+    steps:
+      - name: Checkout EZKL
+        uses: actions/checkout@v3
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          override: true
+
+      - name: Build EzklCoreBindings
+        run: CONFIGURATION=release cargo run --bin ios_gen_bindings --features "ios-bindings uuid camino uniffi_bindgen" --no-default-features
+
+      - name: Clone ezkl-swift-package repository
+        run: |
+          git clone https://github.com/zkonduit/ezkl-swift-package.git
+
+      - name: Copy EzklCoreBindings
+        run: |
+          rm -rf ezkl-swift-package/Sources/EzklCoreBindings
+          cp -r build/EzklCoreBindings ezkl-swift-package/Sources/
+
+      - name: Copy Test Files
+        run: |
+          rm -rf ezkl-swift-package/Tests/EzklAssets/*
+          
+          cp tests/assets/kzg ezkl-swift-package/Tests/EzklAssets/kzg.srs
+          cp tests/assets/input.json ezkl-swift-package/Tests/EzklAssets/input.json
+          cp tests/assets/model.compiled ezkl-swift-package/Tests/EzklAssets/network.ezkl
+          cp tests/assets/settings.json ezkl-swift-package/Tests/EzklAssets/settings.json
+
+      - name: Set up Xcode environment
+        run: |
+          sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
+          sudo xcodebuild -license accept
+
+      - name: Run Package Tests
+        run: |
+          cd ezkl-swift-package
+          xcodebuild test \
+            -scheme EzklPackage \
+            -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=17.5' \
+            -resultBundlePath ../testResults
+
+      - name: Run Example App Tests
+        run: |
+          cd ezkl-swift-package/Example
+          xcodebuild test \
+            -project Example.xcodeproj \
+            -scheme EzklApp \
+            -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=17.5' \
+            -parallel-testing-enabled NO \
+            -resultBundlePath ../../exampleTestResults \
+            -skip-testing:EzklAppUITests/EzklAppUITests/testButtonClicksInOrder
+
+      - name: Commit and Push Changes to feat/ezkl-direct-integration
+        run: |
+          cd ezkl-swift-package
+          git config user.name "GitHub Action"
+          git config user.email "action@github.com"
+          git add Sources/EzklCoreBindings
+          git add Tests/EzklAssets
+          git commit -m "Automatically updated EzklCoreBindings for EZKL"
+          git tag ${{ github.event.inputs.tag }}
+          git remote set-url origin https://zkonduit:${EZKL_PORTER_TOKEN}@github.com/zkonduit/ezkl-swift-package.git
+          git push origin
+          git push origin tag ${{ github.event.inputs.tag }}
+        env:
+          EZKL_PORTER_TOKEN: ${{ secrets.EZKL_PORTER_TOKEN }}

.gitignore

@@ -27,7 +27,6 @@ __pycache__/
 *.pyc
 *.pyo
 *.py[cod]
-bin/
 build/
 develop-eggs/
 dist/
@@ -46,7 +45,7 @@ var/
 node_modules
 /dist
 timingData.json
-!tests/wasm/pk.key
-!tests/wasm/vk.key
+!tests/assets/pk.key
+!tests/assets/vk.key
 docs/python/build
-!tests/wasm/vk_aggr.key
+!tests/assets/vk_aggr.key

Cargo.toml

@@ -4,6 +4,7 @@ cargo-features = ["profile-rustflags"]
 name = "ezkl"
 version = "0.0.0"
 edition = "2021"
+default-run = "ezkl"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -11,86 +12,109 @@ edition = "2021"
 # Name to be imported within python
 # Example: import ezkl
 name = "ezkl"
-crate-type = ["cdylib", "rlib"]
+crate-type = ["cdylib", "rlib", "staticlib"]
 
 
 [dependencies]
-halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch = "ac/optional-selector-poly" }
-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 = [
+halo2_gadgets = { git = "https://github.com/zkonduit/halo2" }
+halo2curves = { git = "https://github.com/privacy-scaling-explorations/halo2curves", rev = "b753a832e92d5c86c5c997327a9cf9de86a18851", features = [
     "derive_serde",
 ] }
-rand = { version = "0.8", default_features = false }
-itertools = { version = "0.10.3", default_features = false }
-clap = { version = "4.5.3", features = ["derive"] }
-clap_complete = "4.5.2"
-serde = { version = "1.0.126", features = ["derive"], optional = true }
-serde_json = { version = "1.0.97", default_features = false, features = [
-    "float_roundtrip",
-    "raw_value",
-], optional = true }
-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_proofs = { git = "https://github.com/zkonduit/halo2", package = "halo2_proofs", features = [
+    "circuit-params",
+] }
+rand = { version = "0.8", default-features = false }
+itertools = { version = "0.10.3", default-features = false }
+clap = { version = "4.5.3", features = ["derive"], optional = true }
+serde = { version = "1.0.126", features = ["derive"] }
+clap_complete = { version = "4.5.2", optional = true }
+log = { version = "0.4.17", default-features = false }
+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 = [
     "derive_serde",
 ] }
-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 }
+halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier", optional = true }
+maybe-rayon = { version = "0.1.1", default-features = false }
+bincode = { version = "1.3.3", 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" }
-metal = { git = "https://github.com/gfx-rs/metal-rs", optional = true }
-semver = "1.0.22"
+portable-atomic = { version = "1.6.0", optional = true }
+tosubcommand = { git = "https://github.com/zkonduit/enum_to_subcommand", package = "tosubcommand", optional = true }
+semver = { version = "1.0.22", optional = true }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+serde_json = { version = "1.0.97", features = ["float_roundtrip", "raw_value"] }
 
 # 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"
-indicatif = { version = "0.17.5", features = ["rayon"] }
-gag = { version = "1.0.0", default_features = false }
+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",
+
+], optional = true }
+foundry-compilers = { version = "0.4.1", features = [
+    "svm-solc",
+], optional = true }
+ethabi = { version = "18", optional = true }
+indicatif = { version = "0.17.5", features = ["rayon"], optional = true }
+gag = { version = "1.0.0", default-features = false, optional = true }
 instant = { version = "0.1" }
 reqwest = { version = "0.12.4", default-features = false, features = [
     "default-tls",
     "multipart",
     "stream",
-] }
-openssl = { version = "0.10.55", features = ["vendored"] }
-tokio-postgres = "0.7.10"
-pg_bigdecimal = "0.1.5"
-lazy_static = "1.4.0"
-colored_json = { version = "3.0.1", default_features = false, optional = true }
-regex = { version = "1", default_features = false }
-tokio = { version = "1.35", default_features = false, features = [
+], optional = true }
+openssl = { version = "0.10.55", features = ["vendored"], optional = true }
+tokio-postgres = { version = "0.7.10", optional = true }
+pg_bigdecimal = { version = "0.1.5", optional = true }
+lazy_static = { version = "1.4.0", optional = true }
+colored_json = { version = "3.0.1", default-features = false, optional = true }
+regex = { version = "1", default-features = false, optional = true }
+tokio = { version = "1.35.0", default-features = false, features = [
     "macros",
-    "rt-multi-thread"
-] }
-pyo3 = { version = "0.21.2", features = [
+    "rt-multi-thread",
+], optional = true }
+pyo3 = { version = "0.23.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 = [
+], default-features = false, optional = true }
+pyo3-async-runtimes = { git = "https://github.com/PyO3/pyo3-async-runtimes", version = "0.23.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 }
+], default-features = false, optional = true }
+pyo3-log = { version = "0.12.0", default-features = false, optional = true }
+tract-onnx = { git = "https://github.com/sonos/tract/", rev = "37132e0397d0a73e5bd3a8615d932dabe44f6736", 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 = { version = "0.1", optional = true }
+pyo3-stub-gen = { version = "0.6.0", optional = true }
 
+# universal bindings
+uniffi = { version = "=0.28.0", optional = true }
+getrandom = { version = "0.2.8", optional = true }
+uniffi_bindgen = { version = "=0.28.0", optional = true }
+camino = { version = "^1.1", optional = true }
+uuid = { version = "1.10.0", features = ["v4"], optional = true }
 
 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
-colored = { version = "2.0.0", default_features = false, optional = true }
-env_logger = { version = "0.10.0", default_features = false, optional = true }
-chrono = "0.4.31"
-sha256 = "1.4.0"
+colored = { version = "2.0.0", default-features = false, optional = true }
+env_logger = { version = "0.10.0", default-features = false, optional = true }
+chrono = { version = "0.4.31", optional = true }
+sha256 = { version = "1.4.0", optional = true }
+
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
+serde_json = { version = "1.0.97", default-features = false, features = [
+    "float_roundtrip",
+    "raw_value",
+] }
 getrandom = { version = "0.2.8", features = ["js"] }
 instant = { version = "0.1", features = ["wasm-bindgen", "inaccurate"] }
 
@@ -106,6 +130,10 @@ 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"] }
 
+
+[build-dependencies]
+uniffi = { version = "0.28", features = ["build"], optional = true }
+
 [dev-dependencies]
 tempfile = "3.3.0"
 lazy_static = "1.4.0"
@@ -157,16 +185,20 @@ harness = false
 
 
 [[bench]]
-name = "relu"
+name = "sigmoid"
 harness = false
 
 [[bench]]
-name = "accum_matmul_relu"
+name = "relu_lookupless"
+harness = false
+
+[[bench]]
+name = "accum_matmul_sigmoid"
 harness = false
 
 
 [[bench]]
-name = "accum_matmul_relu_overflow"
+name = "accum_matmul_sigmoid_overflow"
 harness = false
 
 [[bin]]
@@ -175,42 +207,82 @@ test = false
 bench = false
 required-features = ["ezkl"]
 
+[[bin]]
+name = "ios_gen_bindings"
+required-features = ["ios-bindings", "uuid", "camino", "uniffi_bindgen"]
+
+[[bin]]
+name = "py_stub_gen"
+required-features = ["python-bindings"]
+
 [features]
 web = ["wasm-bindgen-rayon"]
-default = ["ezkl", "mv-lookup", "no-banner", "parallel-poly-read"]
+default = [
+    "ezkl",
+    "mv-lookup",
+    "precompute-coset",
+    "no-banner",
+    "parallel-poly-read",
+]
 onnx = ["dep:tract-onnx"]
-python-bindings = ["pyo3", "pyo3-log", "pyo3-asyncio"]
+python-bindings = ["pyo3", "pyo3-log", "pyo3-async-runtimes", "pyo3-stub-gen"]
+ios-bindings = ["mv-lookup", "precompute-coset", "parallel-poly-read", "uniffi"]
+ios-bindings-test = ["ios-bindings", "uniffi/bindgen-tests"]
 ezkl = [
     "onnx",
-    "serde",
-    "serde_json",
-    "log",
-    "colored",
-    "env_logger",
+    "dep:colored",
+    "dep:env_logger",
     "tabled/color",
+    "serde_json/std",
     "colored_json",
-    "halo2_proofs/circuit-params",
+    "dep:alloy",
+    "dep:foundry-compilers",
+    "dep:ethabi",
+    "dep:indicatif",
+    "dep:gag",
+    "dep:reqwest",
+    "dep:openssl",
+    "dep:tokio-postgres",
+    "dep:pg_bigdecimal",
+    "dep:lazy_static",
+    "dep:regex",
+    "dep:tokio",
+    "dep:mimalloc",
+    "dep:chrono",
+    "dep:sha256",
+    "dep:portable-atomic",
+    "dep:clap_complete",
+    "dep:halo2_solidity_verifier",
+    "dep:semver",
+    "dep:clap",
+    "dep:tosubcommand",
+]
+parallel-poly-read = [
+    "halo2_proofs/circuit-params",
+    "halo2_proofs/parallel-poly-read",
 ]
-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 = []
-metal = ["dep:metal", "dep:objc"]
 
-# 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#8cfca221f53069a0374687654882b99e729041d7", package = "halo2_proofs" }
+halo2_proofs = { git = "https://github.com/zkonduit/halo2#0654e92bdf725fd44d849bfef3643870a8c7d50b", package = "halo2_proofs" }
 
+[patch.crates-io]
+uniffi_testing = { git = "https://github.com/ElusAegis/uniffi-rs", branch = "feat/testing-feature-build-fix" }
 
 [profile.release]
 rustflags = ["-C", "relocation-model=pic"]
+lto = "fat"
+codegen-units = 1
+# panic = "abort"

abis/DataAttestationSingle.json

@@ -0,0 +1,147 @@
+[
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "_contractAddresses",
+                "type": "address"
+            },
+            {
+                "internalType": "bytes",
+                "name": "_callData",
+                "type": "bytes"
+            },
+            {
+                "internalType": "uint256",
+                "name": "_decimals",
+                "type": "uint256"
+            },
+            {
+                "internalType": "uint256[]",
+                "name": "_scales",
+                "type": "uint256[]"
+            },
+            {
+                "internalType": "uint8",
+                "name": "_instanceOffset",
+                "type": "uint8"
+            },
+            {
+                "internalType": "address",
+                "name": "_admin",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "inputs": [],
+        "name": "accountCall",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "contractAddress",
+                "type": "address"
+            },
+            {
+                "internalType": "bytes",
+                "name": "callData",
+                "type": "bytes"
+            },
+            {
+                "internalType": "uint256",
+                "name": "decimals",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "admin",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "instanceOffset",
+        "outputs": [
+            {
+                "internalType": "uint8",
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "_contractAddresses",
+                "type": "address"
+            },
+            {
+                "internalType": "bytes",
+                "name": "_callData",
+                "type": "bytes"
+            },
+            {
+                "internalType": "uint256",
+                "name": "_decimals",
+                "type": "uint256"
+            }
+        ],
+        "name": "updateAccountCalls",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "_admin",
+                "type": "address"
+            }
+        ],
+        "name": "updateAdmin",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "verifier",
+                "type": "address"
+            },
+            {
+                "internalType": "bytes",
+                "name": "encoded",
+                "type": "bytes"
+            }
+        ],
+        "name": "verifyWithDataAttestation",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    }
+]

abis/QuantizeData.json

@@ -1,4 +1,23 @@
 [
+	{
+		"inputs": [
+			{
+				"internalType": "int256[]",
+				"name": "quantized_data",
+				"type": "int256[]"
+			}
+		],
+		"name": "check_is_valid_field_element",
+		"outputs": [
+			{
+				"internalType": "uint256[]",
+				"name": "output",
+				"type": "uint256[]"
+			}
+		],
+		"stateMutability": "pure",
+		"type": "function"
+	},
 	{
 		"inputs": [
 			{
@@ -17,12 +36,41 @@
 				"type": "uint256[]"
 			}
 		],
-		"name": "quantize_data",
+		"name": "quantize_data_multi",
 		"outputs": [
 			{
-				"internalType": "int64[]",
+				"internalType": "int256[]",
 				"name": "quantized_data",
-				"type": "int64[]"
+				"type": "int256[]"
+			}
+		],
+		"stateMutability": "pure",
+		"type": "function"
+	},
+	{
+		"inputs": [
+			{
+				"internalType": "bytes",
+				"name": "data",
+				"type": "bytes"
+			},
+			{
+				"internalType": "uint256",
+				"name": "decimals",
+				"type": "uint256"
+			},
+			{
+				"internalType": "uint256[]",
+				"name": "scales",
+				"type": "uint256[]"
+			}
+		],
+		"name": "quantize_data_single",
+		"outputs": [
+			{
+				"internalType": "int256[]",
+				"name": "quantized_data",
+				"type": "int256[]"
 			}
 		],
 		"stateMutability": "pure",

benches/accum_conv.rs

@@ -64,7 +64,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(
                         &mut region,
@@ -72,6 +72,7 @@ impl Circuit<Fr> for MyCircuit {
                         Box::new(PolyOp::Conv {
                             padding: vec![(0, 0)],
                             stride: vec![1; 2],
+                            group: 1,
                         }),
                     )
                     .unwrap();

benches/accum_dot.rs

@@ -55,7 +55,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(
                         &mut region,

benches/accum_einsum_matmul.rs

@@ -57,7 +57,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(
                         &mut region,

benches/accum_matmul_sigmoid.rs

@@ -57,7 +57,15 @@ impl Circuit<Fr> for MyCircuit {
 
         // sets up a new relu table
         base_config
-            .configure_lookup(cs, &b, &output, &a, BITS, K, &LookupOp::ReLU)
+            .configure_lookup(
+                cs,
+                &b,
+                &output,
+                &a,
+                BITS,
+                K,
+                &LookupOp::Sigmoid { scale: 1.0.into() },
+            )
             .unwrap();
 
         MyConfig { base_config }
@@ -75,14 +83,18 @@ impl Circuit<Fr> for MyCircuit {
                 let op = PolyOp::Einsum {
                     equation: "ij,jk->ik".to_string(),
                 };
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 let output = config
                     .base_config
                     .layout(&mut region, &self.inputs, Box::new(op))
                     .unwrap();
                 let _output = config
                     .base_config
-                    .layout(&mut region, &[output.unwrap()], Box::new(LookupOp::ReLU))
+                    .layout(
+                        &mut region,
+                        &[output.unwrap()],
+                        Box::new(LookupOp::Sigmoid { scale: 1.0.into() }),
+                    )
                     .unwrap();
                 Ok(())
             },

benches/accum_matmul_sigmoid_overflow.rs

@@ -58,7 +58,15 @@ impl Circuit<Fr> for MyCircuit {
 
         // sets up a new relu table
         base_config
-            .configure_lookup(cs, &b, &output, &a, BITS, k, &LookupOp::ReLU)
+            .configure_lookup(
+                cs,
+                &b,
+                &output,
+                &a,
+                BITS,
+                k,
+                &LookupOp::Sigmoid { scale: 1.0.into() },
+            )
             .unwrap();
 
         MyConfig { base_config }
@@ -76,14 +84,18 @@ impl Circuit<Fr> for MyCircuit {
                 let op = PolyOp::Einsum {
                     equation: "ij,jk->ik".to_string(),
                 };
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 let output = config
                     .base_config
                     .layout(&mut region, &self.inputs, Box::new(op))
                     .unwrap();
                 let _output = config
                     .base_config
-                    .layout(&mut region, &[output.unwrap()], Box::new(LookupOp::ReLU))
+                    .layout(
+                        &mut region,
+                        &[output.unwrap()],
+                        Box::new(LookupOp::Sigmoid { scale: 1.0.into() }),
+                    )
                     .unwrap();
                 Ok(())
             },

benches/accum_sum.rs

@@ -55,7 +55,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(
                         &mut region,

benches/accum_sumpool.rs

@@ -59,7 +59,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(
                         &mut region,

benches/pairwise_add.rs

@@ -55,7 +55,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1);
+                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(&mut region, &self.inputs, Box::new(PolyOp::Add))
                     .unwrap();

benches/pairwise_pow.rs

@@ -56,7 +56,7 @@ impl Circuit<Fr> for MyCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = RegionCtx::new(region, 0, 1);
+                let mut region = RegionCtx::new(region, 0, 1, 1024, 2);
                 config
                     .layout(&mut region, &self.inputs, Box::new(PolyOp::Pow(4)))
                     .unwrap();

benches/relu_lookupless.rs

@@ -0,0 +1,150 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use ezkl::circuit::poly::PolyOp;
+use ezkl::circuit::region::RegionCtx;
+use ezkl::circuit::{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};
+use ezkl::tensor::*;
+use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
+use halo2_proofs::poly::kzg::strategy::SingleStrategy;
+use halo2_proofs::{
+    circuit::{Layouter, SimpleFloorPlanner, Value},
+    plonk::{Circuit, ConstraintSystem, Error},
+};
+use halo2curves::bn256::{Bn256, Fr};
+use rand::Rng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
+
+static mut LEN: usize = 4;
+const K: usize = 16;
+
+#[derive(Clone)]
+struct NLCircuit {
+    pub input: ValTensor<Fr>,
+}
+
+impl Circuit<Fr> for NLCircuit {
+    type Config = Config<Fr>;
+    type FloorPlanner = SimpleFloorPlanner;
+    type Params = ();
+
+    fn without_witnesses(&self) -> Self {
+        self.clone()
+    }
+
+    fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
+        unsafe {
+            let advices = (0..3)
+                .map(|_| VarTensor::new_advice(cs, K, 1, LEN))
+                .collect::<Vec<_>>();
+
+            let mut config = Config::default();
+
+            config
+                .configure_range_check(cs, &advices[0], &advices[1], (-1, 1), K)
+                .unwrap();
+
+            config
+                .configure_range_check(cs, &advices[0], &advices[1], (0, 1023), K)
+                .unwrap();
+
+            let _constant = VarTensor::constant_cols(cs, K, LEN, false);
+
+            config
+        }
+    }
+
+    fn synthesize(
+        &self,
+        mut config: Self::Config,
+        mut layouter: impl Layouter<Fr>, // layouter is our 'write buffer' for the circuit
+    ) -> Result<(), Error> {
+        config.layout_range_checks(&mut layouter).unwrap();
+        layouter.assign_region(
+            || "",
+            |region| {
+                let mut region = RegionCtx::new(region, 0, 1, 1024, 2);
+                config
+                    .layout(
+                        &mut region,
+                        &[self.input.clone()],
+                        Box::new(PolyOp::LeakyReLU {
+                            slope: 0.0.into(),
+                            scale: 1,
+                        }),
+                    )
+                    .unwrap();
+                Ok(())
+            },
+        )?;
+        Ok(())
+    }
+}
+
+fn runrelu(c: &mut Criterion) {
+    let mut group = c.benchmark_group("relu");
+
+    let mut rng = rand::thread_rng();
+    let params = gen_srs::<KZGCommitmentScheme<_>>(17);
+    for &len in [4, 8].iter() {
+        unsafe {
+            LEN = len;
+        };
+
+        let input: Tensor<Value<Fr>> =
+            Tensor::<IntegerRep>::from((0..len).map(|_| rng.gen_range(0..10))).into();
+
+        let circuit = NLCircuit {
+            input: ValTensor::from(input.clone()),
+        };
+
+        group.throughput(Throughput::Elements(len as u64));
+        group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
+            b.iter(|| {
+                create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, &params, true)
+                    .unwrap();
+            });
+        });
+
+        let pk =
+            create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, &params, true).unwrap();
+
+        group.throughput(Throughput::Elements(len as u64));
+        group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
+            b.iter(|| {
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    NLCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
+                    circuit.clone(),
+                    vec![],
+                    &params,
+                    &pk,
+                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
+                    TranscriptType::EVM,
+                    None,
+                    None,
+                );
+                prover.unwrap();
+            });
+        });
+    }
+    group.finish();
+}
+
+criterion_group! {
+  name = benches;
+  config = Criterion::default().with_plots();
+  targets = runrelu
+}
+criterion_main!(benches);

benches/sigmoid.rs

@@ -2,6 +2,7 @@ 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};
@@ -41,7 +42,7 @@ impl Circuit<Fr> for NLCircuit {
                 .map(|_| VarTensor::new_advice(cs, K, 1, LEN))
                 .collect::<Vec<_>>();
 
-            let nl = LookupOp::ReLU;
+            let nl = LookupOp::Sigmoid { scale: 1.0.into() };
 
             let mut config = Config::default();
 
@@ -62,9 +63,13 @@ impl Circuit<Fr> for NLCircuit {
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = RegionCtx::new(region, 0, 1);
+                let mut region = RegionCtx::new(region, 0, 1, 1024, 2);
                 config
-                    .layout(&mut region, &[self.input.clone()], Box::new(LookupOp::ReLU))
+                    .layout(
+                        &mut region,
+                        &[self.input.clone()],
+                        Box::new(LookupOp::Sigmoid { scale: 1.0.into() }),
+                    )
                     .unwrap();
                 Ok(())
             },
@@ -84,7 +89,7 @@ fn runrelu(c: &mut Criterion) {
         };
 
         let input: Tensor<Value<Fr>> =
-            Tensor::<i32>::from((0..len).map(|_| rng.gen_range(0..10))).into();
+            Tensor::<IntegerRep>::from((0..len).map(|_| rng.gen_range(0..10))).into();
 
         let circuit = NLCircuit {
             input: ValTensor::from(input.clone()),

build.rs

@@ -0,0 +1,7 @@
+fn main() {
+    if cfg!(feature = "ios-bindings-test") {
+        println!("cargo::rustc-env=UNIFFI_CARGO_BUILD_EXTRA_ARGS=--features=ios-bindings --no-default-features");
+    }
+
+    println!("cargo::rerun-if-changed=build.rs");
+}

contracts/AttestData.sol

@@ -163,6 +163,253 @@ contract SwapProofCommitments {
     } /// end checkKzgCommits
 }
 
+contract DataAttestationSingle is LoadInstances, SwapProofCommitments {
+    /**
+     * @notice Struct used to make view only call to account to fetch the data that EZKL reads from.
+     * @param the address of the account to make calls to
+     * @param the abi encoded function calls to make to the `contractAddress`
+     */
+    struct AccountCall {
+        address contractAddress;
+        bytes callData;
+        uint256 decimals;
+    }
+    AccountCall public accountCall;
+
+    uint[] scales;
+
+    address public admin;
+
+    /**
+     * @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 INPUT_LEN = 0;
+
+    uint256 constant OUTPUT_LEN = 0;
+
+    uint8 public instanceOffset;
+
+    /**
+     * @dev Initialize the contract with account calls the EZKL model will read from.
+     * @param _contractAddresses - The calls to all the contracts EZKL reads storage from.
+     * @param _callData - The abi encoded function calls to make to the `contractAddress` that EZKL reads storage from.
+     */
+    constructor(
+        address _contractAddresses,
+        bytes memory _callData,
+        uint256 _decimals,
+        uint[] memory _scales,
+        uint8 _instanceOffset,
+        address _admin
+    ) {
+        admin = _admin;
+        for (uint i; i < _scales.length; i++) {
+            scales.push(1 << _scales[i]);
+        }
+        populateAccountCalls(_contractAddresses, _callData, _decimals);
+        instanceOffset = _instanceOffset;
+    }
+
+    function updateAdmin(address _admin) external {
+        require(msg.sender == admin, "Only admin can update admin");
+        if (_admin == address(0)) {
+            revert();
+        }
+        admin = _admin;
+    }
+
+    function updateAccountCalls(
+        address _contractAddresses,
+        bytes memory _callData,
+        uint256 _decimals
+    ) external {
+        require(msg.sender == admin, "Only admin can update account calls");
+        populateAccountCalls(_contractAddresses, _callData, _decimals);
+    }
+
+    function populateAccountCalls(
+        address _contractAddresses,
+        bytes memory _callData,
+        uint256 _decimals
+    ) internal {
+        AccountCall memory _accountCall = accountCall;
+        _accountCall.contractAddress = _contractAddresses;
+        _accountCall.callData = _callData;
+        _accountCall.decimals = 10 ** _decimals;
+        accountCall = _accountCall;
+    }
+
+    function mulDiv(
+        uint256 x,
+        uint256 y,
+        uint256 denominator
+    ) internal pure returns (uint256 result) {
+        unchecked {
+            uint256 prod0;
+            uint256 prod1;
+            assembly {
+                let mm := mulmod(x, y, not(0))
+                prod0 := mul(x, y)
+                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
+            }
+
+            if (prod1 == 0) {
+                return prod0 / denominator;
+            }
+
+            require(denominator > prod1, "Math: mulDiv overflow");
+
+            uint256 remainder;
+            assembly {
+                remainder := mulmod(x, y, denominator)
+                prod1 := sub(prod1, gt(remainder, prod0))
+                prod0 := sub(prod0, remainder)
+            }
+
+            uint256 twos = denominator & (~denominator + 1);
+            assembly {
+                denominator := div(denominator, twos)
+                prod0 := div(prod0, twos)
+                twos := add(div(sub(0, twos), twos), 1)
+            }
+
+            prod0 |= prod1 * twos;
+
+            uint256 inverse = (3 * denominator) ^ 2;
+
+            inverse *= 2 - denominator * inverse;
+            inverse *= 2 - denominator * inverse;
+            inverse *= 2 - denominator * inverse;
+            inverse *= 2 - denominator * inverse;
+            inverse *= 2 - denominator * inverse;
+            inverse *= 2 - denominator * inverse;
+
+            result = prod0 * inverse;
+            return result;
+        }
+    }
+    /**
+     * @dev Quantize the data returned from the account calls to the scale used by the EZKL model.
+     * @param x - One of the elements of the data returned from the account calls
+     * @param _decimals - Number of base 10 decimals to scale the data by.
+     * @param _scale - The base 2 scale used to convert the floating point value into a fixed point value.
+     *
+     */
+    function quantizeData(
+        int x,
+        uint256 _decimals,
+        uint256 _scale
+    ) internal pure returns (int256 quantized_data) {
+        bool neg = x < 0;
+        if (neg) x = -x;
+        uint output = mulDiv(uint256(x), _scale, _decimals);
+        if (mulmod(uint256(x), _scale, _decimals) * 2 >= _decimals) {
+            output += 1;
+        }
+        quantized_data = neg ? -int256(output) : int256(output);
+    }
+    /**
+     * @dev Make a static call to the account to fetch the data that EZKL reads from.
+     * @param target - The address of the account to make calls to.
+     * @param data  - The abi encoded function calls to make to the `contractAddress` that EZKL reads storage from.
+     * @return The data returned from the account calls. (Must come from either a view or pure function. Will throw an error otherwise)
+     */
+    function staticCall(
+        address target,
+        bytes memory data
+    ) internal view returns (bytes memory) {
+        (bool success, bytes memory returndata) = target.staticcall(data);
+        if (success) {
+            if (returndata.length == 0) {
+                require(
+                    target.code.length > 0,
+                    "Address: call to non-contract"
+                );
+            }
+            return returndata;
+        } else {
+            revert("Address: low-level call failed");
+        }
+    }
+    /**
+     * @dev Convert the fixed point quantized data into a field element.
+     * @param x - The quantized data.
+     * @return field_element - The 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;
+    }
+
+    /**
+     * @dev Make the account calls to fetch the data that EZKL reads from and attest to the data.
+     * @param instances - The public instances to the proof (the data in the proof that publicly accessible to the verifier).
+     */
+    function attestData(uint256[] memory instances) internal view {
+        require(
+            instances.length >= INPUT_LEN + OUTPUT_LEN,
+            "Invalid public inputs length"
+        );
+        AccountCall memory _accountCall = accountCall;
+        uint[] memory _scales = scales;
+        bytes memory returnData = staticCall(
+            _accountCall.contractAddress,
+            _accountCall.callData
+        );
+        int256[] memory x = abi.decode(returnData, (int256[]));
+        uint _offset;
+        int output = quantizeData(x[0], _accountCall.decimals, _scales[0]);
+        uint field_element = toFieldElement(output);
+        for (uint i = 0; i < x.length; i++) {
+            if (field_element != instances[i + instanceOffset]) {
+                _offset += 1;
+            } else {
+                break;
+            }
+        }
+        uint length = x.length - _offset;
+        for (uint i = 1; i < length; i++) {
+            output = quantizeData(x[i], _accountCall.decimals, _scales[i]);
+            field_element = toFieldElement(output);
+            require(
+                field_element == instances[i + instanceOffset + _offset],
+                "Public input does not match"
+            );
+        }
+    }
+
+    /**
+     * @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");
+        attestData(getInstancesCalldata(encoded));
+        // static call the verifier contract to verify the proof
+        (bool success, bytes memory returndata) = verifier.staticcall(encoded);
+
+        if (success) {
+            return abi.decode(returndata, (bool));
+        } else {
+            revert("low-level call to verifier failed");
+        }
+    }
+}
+
 // 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.
 // It is particularly constructed to read only int256 data from specified on-chain contracts' view functions.
@@ -173,11 +420,11 @@ contract SwapProofCommitments {
 // 3. Static Calls: Makes static calls to fetch data from other contracts. See the `staticCall` method.
 // 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,
+// 6. Proof Verification: The `verifyWithDataAttestationMulti` 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 DataAttestationMulti is LoadInstances, SwapProofCommitments {
     /**
      * @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

docs/python/requirements-docs.txt

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

docs/python/src/conf.py

@@ -1,7 +1,7 @@
 import ezkl
 
 project = 'ezkl'
-release = '11.6.2'
+release = '16.2.1'
 version = release
 
 

examples/conv2d_mnist/main.rs

@@ -2,8 +2,7 @@ use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::{
     ops::lookup::LookupOp, ops::poly::PolyOp, BaseConfig as PolyConfig, CheckMode,
 };
-use ezkl::fieldutils;
-use ezkl::fieldutils::i32_to_felt;
+use ezkl::fieldutils::{self, integer_rep_to_felt, IntegerRep};
 use ezkl::tensor::*;
 use halo2_proofs::dev::MockProver;
 use halo2_proofs::poly::commitment::Params;
@@ -42,8 +41,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: i64,
-    const LOOKUP_MAX: i64,
+    const LOOKUP_MIN: IntegerRep,
+    const LOOKUP_MAX: IntegerRep,
     // Convolution
     const KERNEL_HEIGHT: usize,
     const KERNEL_WIDTH: usize,
@@ -66,8 +65,8 @@ struct Config<
 struct MyCircuit<
     const LEN: usize, //LEN = CHOUT x OH x OW flattened
     const CLASSES: usize,
-    const LOOKUP_MIN: i64,
-    const LOOKUP_MAX: i64,
+    const LOOKUP_MIN: IntegerRep,
+    const LOOKUP_MAX: IntegerRep,
     // Convolution
     const KERNEL_HEIGHT: usize,
     const KERNEL_WIDTH: usize,
@@ -90,8 +89,8 @@ struct MyCircuit<
 impl<
         const LEN: usize,
         const CLASSES: usize,
-        const LOOKUP_MIN: i64,
-        const LOOKUP_MAX: i64,
+        const LOOKUP_MIN: IntegerRep,
+        const LOOKUP_MAX: IntegerRep,
         // Convolution
         const KERNEL_HEIGHT: usize,
         const KERNEL_WIDTH: usize,
@@ -147,6 +146,8 @@ where
         let params = VarTensor::new_advice(cs, K, NUM_INNER_COLS, LEN);
         let output = VarTensor::new_advice(cs, K, NUM_INNER_COLS, LEN);
 
+        let _constant = VarTensor::constant_cols(cs, K, LEN, false);
+
         println!("INPUT COL {:#?}", input);
 
         let mut layer_config = PolyConfig::configure(
@@ -157,15 +158,11 @@ where
         );
 
         layer_config
-            .configure_lookup(
-                cs,
-                &input,
-                &output,
-                &params,
-                (LOOKUP_MIN, LOOKUP_MAX),
-                K,
-                &LookupOp::ReLU,
-            )
+            .configure_range_check(cs, &input, &params, (-1, 1), K)
+            .unwrap();
+
+        layer_config
+            .configure_range_check(cs, &input, &params, (0, 1023), K)
             .unwrap();
 
         layer_config
@@ -196,15 +193,21 @@ where
     ) -> Result<(), Error> {
         config.layer_config.layout_tables(&mut layouter).unwrap();
 
+        config
+            .layer_config
+            .layout_range_checks(&mut layouter)
+            .unwrap();
+
         let x = layouter
             .assign_region(
                 || "mlp_4d",
                 |region| {
-                    let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS);
+                    let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS, 1024, 2);
 
                     let op = PolyOp::Conv {
                         padding: vec![(PADDING, PADDING); 2],
                         stride: vec![STRIDE; 2],
+                        group: 1,
                     };
                     let x = config
                         .layer_config
@@ -221,7 +224,14 @@ where
 
                     let x = config
                         .layer_config
-                        .layout(&mut region, &[x.unwrap()], Box::new(LookupOp::ReLU))
+                        .layout(
+                            &mut region,
+                            &[x.unwrap()],
+                            Box::new(PolyOp::LeakyReLU {
+                                slope: 0.0.into(),
+                                scale: 1,
+                            }),
+                        )
                         .unwrap();
 
                     let mut x = config
@@ -281,7 +291,7 @@ where
 }
 
 pub fn runconv() {
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     env_logger::init();
 
     const KERNEL_HEIGHT: usize = 5;
@@ -315,7 +325,11 @@ pub fn runconv() {
         .test_set_length(10_000)
         .finalize();
 
-    let mut train_data = Tensor::from(trn_img.iter().map(|x| i32_to_felt::<F>(*x as i32 / 16)));
+    let mut train_data = Tensor::from(
+        trn_img
+            .iter()
+            .map(|x| integer_rep_to_felt::<F>(*x as IntegerRep / 16)),
+    );
     train_data.reshape(&[50_000, 28, 28]).unwrap();
 
     let mut train_labels = Tensor::from(trn_lbl.iter().map(|x| *x as f32));
@@ -343,8 +357,8 @@ pub fn runconv() {
             .map(|fl| {
                 let dx = fl * 32_f32;
                 let rounded = dx.round();
-                let integral: i32 = unsafe { rounded.to_int_unchecked() };
-                fieldutils::i32_to_felt(integral)
+                let integral: IntegerRep = unsafe { rounded.to_int_unchecked() };
+                fieldutils::integer_rep_to_felt(integral)
             }),
     );
 
@@ -355,7 +369,8 @@ pub fn runconv() {
 
     let l0_kernels = l0_kernels.try_into().unwrap();
 
-    let mut l0_bias = Tensor::<F>::from((0..OUT_CHANNELS).map(|_| fieldutils::i32_to_felt(0)));
+    let mut l0_bias =
+        Tensor::<F>::from((0..OUT_CHANNELS).map(|_| fieldutils::integer_rep_to_felt(0)));
     l0_bias.set_visibility(&ezkl::graph::Visibility::Private);
 
     let l0_bias = l0_bias.try_into().unwrap();
@@ -363,8 +378,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: i32 = unsafe { rounded.to_int_unchecked() };
-        fieldutils::i32_to_felt(integral)
+        let integral: IntegerRep = unsafe { rounded.to_int_unchecked() };
+        fieldutils::integer_rep_to_felt(integral)
     }));
     l2_biases.set_visibility(&ezkl::graph::Visibility::Private);
     l2_biases.reshape(&[l2_biases.len(), 1]).unwrap();
@@ -374,8 +389,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: i32 = unsafe { rounded.to_int_unchecked() };
-        fieldutils::i32_to_felt(integral)
+        let integral: IntegerRep = unsafe { rounded.to_int_unchecked() };
+        fieldutils::integer_rep_to_felt(integral)
     }));
     l2_weights.set_visibility(&ezkl::graph::Visibility::Private);
     l2_weights.reshape(&[CLASSES, LEN]).unwrap();
@@ -401,13 +416,13 @@ pub fn runconv() {
         l2_params: [l2_weights, l2_biases],
     };
 
-    let public_input: Tensor<i32> = vec![
-        -25124i32, -19304, -16668, -4399, -6209, -4548, -2317, -8349, -6117, -23461,
+    let public_input: Tensor<IntegerRep> = vec![
+        -25124, -19304, -16668, -4399, -6209, -4548, -2317, -8349, -6117, -23461,
     ]
     .into_iter()
     .into();
 
-    let pi_inner: Tensor<F> = public_input.map(i32_to_felt::<F>);
+    let pi_inner: Tensor<F> = public_input.map(integer_rep_to_felt::<F>);
 
     println!("MOCK PROVING");
     let now = Instant::now();

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::i32_to_felt;
+use ezkl::fieldutils::{integer_rep_to_felt, IntegerRep};
 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: i64,
-    const LOOKUP_MAX: i64,
+    const LOOKUP_MIN: IntegerRep,
+    const LOOKUP_MAX: IntegerRep,
 > {
     // 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: i64, const LOOKUP_MAX: i64> Circuit<F>
+impl<const LEN: usize, const LOOKUP_MIN: IntegerRep, const LOOKUP_MAX: IntegerRep> Circuit<F>
     for MyCircuit<LEN, LOOKUP_MIN, LOOKUP_MAX>
 {
     type Config = MyConfig;
@@ -53,6 +53,10 @@ impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
         let output = VarTensor::new_advice(cs, K, 1, LEN);
         // tells the config layer to add an affine op to the circuit gate
 
+        let _constant = VarTensor::constant_cols(cs, K, LEN, false);
+
+        println!("INPUT COL {:#?}", input);
+
         let mut layer_config = PolyConfig::<F>::configure(
             cs,
             &[input.clone(), params.clone()],
@@ -60,17 +64,12 @@ impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
             CheckMode::SAFE,
         );
 
-        // sets up a new ReLU table and resuses it for l1 and l3 non linearities
         layer_config
-            .configure_lookup(
-                cs,
-                &input,
-                &output,
-                &params,
-                (LOOKUP_MIN, LOOKUP_MAX),
-                K,
-                &LookupOp::ReLU,
-            )
+            .configure_range_check(cs, &input, &params, (-1, 1), K)
+            .unwrap();
+
+        layer_config
+            .configure_range_check(cs, &input, &params, (0, 1023), K)
             .unwrap();
 
         // sets up a new ReLU table and resuses it for l1 and l3 non linearities
@@ -104,11 +103,16 @@ impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
     ) -> Result<(), Error> {
         config.layer_config.layout_tables(&mut layouter).unwrap();
 
+        config
+            .layer_config
+            .layout_range_checks(&mut layouter)
+            .unwrap();
+
         let x = layouter
             .assign_region(
                 || "mlp_4d",
                 |region| {
-                    let mut region = RegionCtx::new(region, 0, 1);
+                    let mut region = RegionCtx::new(region, 0, 1, 1024, 2);
                     let x = config
                         .layer_config
                         .layout(
@@ -141,7 +145,14 @@ impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
                     println!("x shape: {:?}", x.dims());
                     let mut x = config
                         .layer_config
-                        .layout(&mut region, &[x], Box::new(LookupOp::ReLU))
+                        .layout(
+                            &mut region,
+                            &[x],
+                            Box::new(PolyOp::LeakyReLU {
+                                scale: 1,
+                                slope: 0.0.into(),
+                            }),
+                        )
                         .unwrap()
                         .unwrap();
                     println!("3");
@@ -177,7 +188,14 @@ impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
                     println!("x shape: {:?}", x.dims());
                     let x = config
                         .layer_config
-                        .layout(&mut region, &[x], Box::new(LookupOp::ReLU))
+                        .layout(
+                            &mut region,
+                            &[x],
+                            Box::new(PolyOp::LeakyReLU {
+                                scale: 1,
+                                slope: 0.0.into(),
+                            }),
+                        )
                         .unwrap();
                     println!("6");
                     println!("offset: {}", region.row());
@@ -212,36 +230,36 @@ impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
 }
 
 pub fn runmlp() {
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     env_logger::init();
     // parameters
-    let mut l0_kernel: Tensor<F> = Tensor::<i32>::new(
+    let mut l0_kernel: Tensor<F> = Tensor::<IntegerRep>::new(
         Some(&[10, 0, 0, -1, 0, 10, 1, 0, 0, 1, 10, 0, 1, 0, 0, 10]),
         &[4, 4],
     )
     .unwrap()
-    .map(i32_to_felt);
+    .map(integer_rep_to_felt);
     l0_kernel.set_visibility(&ezkl::graph::Visibility::Private);
 
-    let mut l0_bias: Tensor<F> = Tensor::<i32>::new(Some(&[0, 0, 0, 1]), &[4, 1])
+    let mut l0_bias: Tensor<F> = Tensor::<IntegerRep>::new(Some(&[0, 0, 0, 1]), &[4, 1])
         .unwrap()
-        .map(i32_to_felt);
+        .map(integer_rep_to_felt);
     l0_bias.set_visibility(&ezkl::graph::Visibility::Private);
 
-    let mut l2_kernel: Tensor<F> = Tensor::<i32>::new(
+    let mut l2_kernel: Tensor<F> = Tensor::<IntegerRep>::new(
         Some(&[0, 3, 10, -1, 0, 10, 1, 0, 0, 1, 0, 12, 1, -2, 32, 0]),
         &[4, 4],
     )
     .unwrap()
-    .map(i32_to_felt);
+    .map(integer_rep_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::<i32>::new(Some(&[-30, -21, 11, 40]), &[4, 1])
+    let input: Tensor<Value<F>> = Tensor::<IntegerRep>::new(Some(&[-30, -21, 11, 40]), &[4, 1])
         .unwrap()
         .into();
-    let mut l2_bias: Tensor<F> = Tensor::<i32>::new(Some(&[0, 0, 0, 1]), &[4, 1])
+    let mut l2_bias: Tensor<F> = Tensor::<IntegerRep>::new(Some(&[0, 0, 0, 1]), &[4, 1])
         .unwrap()
-        .map(i32_to_felt);
+        .map(integer_rep_to_felt);
     l2_bias.set_visibility(&ezkl::graph::Visibility::Private);
 
     let circuit = MyCircuit::<4, -8192, 8192> {
@@ -251,12 +269,12 @@ pub fn runmlp() {
         _marker: PhantomData,
     };
 
-    let public_input: Vec<i32> = unsafe {
+    let public_input: Vec<IntegerRep> = unsafe {
         vec![
-            (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>(),
+            (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>(),
         ]
     };
 
@@ -265,7 +283,10 @@ pub fn runmlp() {
     let prover = MockProver::run(
         K as u32,
         &circuit,
-        vec![public_input.iter().map(|x| i32_to_felt::<F>(*x)).collect()],
+        vec![public_input
+            .iter()
+            .map(|x| integer_rep_to_felt::<F>(*x))
+            .collect()],
     )
     .unwrap();
     prover.assert_satisfied();

examples/notebooks/data_attest.ipynb

@@ -592,7 +592,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.12.2"
+            "version": "3.12.5"
         },
         "orig_nbformat": 4
     },

examples/notebooks/data_attest_hashed.ipynb

@@ -648,10 +648,10 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.7"
         },
         "orig_nbformat": 4
     },
     "nbformat": 4,
     "nbformat_minor": 2
-}
+}

examples/notebooks/logistic_regression.ipynb

@@ -271,7 +271,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.12.2"
+            "version": "3.12.7"
         }
     },
     "nbformat": 4,

examples/notebooks/neural_bow.ipynb

@@ -0,0 +1,766 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "This is a zk version of the tutorial found [here](https://github.com/bentrevett/pytorch-sentiment-analysis/blob/main/1%20-%20Neural%20Bag%20of%20Words.ipynb). The original tutorial is part of the PyTorch Sentiment Analysis series by Ben Trevett.\n",
+    "\n",
+    "1 - NBoW\n",
+    "\n",
+    "In this series we'll be building a machine learning model to perform sentiment analysis -- a subset of text classification where the task is to detect if a given sentence is positive or negative -- using PyTorch and torchtext. The dataset used will be movie reviews from the IMDb dataset, which we'll obtain using the datasets library.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "Preparing Data\n",
+    "\n",
+    "Before we can implement our NBoW model, we first have to perform quite a few steps to get our data ready to use. NLP usually requires quite a lot of data wrangling beforehand, though libraries such as datasets and torchtext handle most of this for us.\n",
+    "\n",
+    "The steps to take are:\n",
+    "\n",
+    "    1. importing modules\n",
+    "    2. loading data\n",
+    "    3. tokenizing data\n",
+    "    4. creating data splits\n",
+    "    5. creating a vocabulary\n",
+    "    6. numericalizing data\n",
+    "    7. creating the data loaders\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! pip install torchtex"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import collections\n",
+    "\n",
+    "import datasets\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "import torchtext\n",
+    "import tqdm\n",
+    "\n",
+    "# It is usually good practice to run your experiments multiple times with different random seeds -- both to measure the variance of your model and also to avoid having results only calculated with either \"good\" or \"bad\" seeds, i.e. being very lucky or unlucky with the randomness in the training process.\n",
+    "\n",
+    "seed = 1234\n",
+    "\n",
+    "np.random.seed(seed)\n",
+    "torch.manual_seed(seed)\n",
+    "torch.cuda.manual_seed(seed)\n",
+    "torch.backends.cudnn.deterministic = True\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data, test_data = datasets.load_dataset(\"imdb\", split=[\"train\", \"test\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can check the features attribute of a split to get more information about the features. We can see that text is a Value of dtype=string -- in other words, it's a string -- and that label is a ClassLabel. A ClassLabel means the feature is an integer representation of which class the example belongs to. num_classes=2 means that our labels are one of two values, 0 or 1, and names=['neg', 'pos'] gives us the human-readable versions of those values. Thus, a label of 0 means the example is a negative review and a label of 1 means the example is a positive review."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data.features\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One of the first things we need to do to our data is tokenize it. Machine learning models aren't designed to handle strings, they're design to handle numbers. So what we need to do is break down our string into individual tokens, and then convert these tokens to numbers. We'll get to the conversion later, but first we'll look at tokenization.\n",
+    "\n",
+    "Tokenization involves using a tokenizer to process the strings in our dataset. A tokenizer is a function that goes from a string to a list of strings. There are many types of tokenizers available, but we're going to use a relatively simple one provided by torchtext called the basic_english tokenizer. We load our tokenizer as such:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer = torchtext.data.utils.get_tokenizer(\"basic_english\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def tokenize_example(example, tokenizer, max_length):\n",
+    "    tokens = tokenizer(example[\"text\"])[:max_length]\n",
+    "    return {\"tokens\": tokens}\n",
+    "\n",
+    "\n",
+    "max_length = 256\n",
+    "\n",
+    "train_data = train_data.map(\n",
+    "    tokenize_example, fn_kwargs={\"tokenizer\": tokenizer, \"max_length\": max_length}\n",
+    ")\n",
+    "test_data = test_data.map(\n",
+    "    tokenize_example, fn_kwargs={\"tokenizer\": tokenizer, \"max_length\": max_length}\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# create validation data \n",
+    "# Why have both a validation set and a test set? Your test set respresents the real world data that you'd see if you actually deployed this model. You won't be able to see what data your model will be fed once deployed, and your test set is supposed to reflect that. Every time we tune our model hyperparameters or training set-up to make it do a bit better on the test set, we are leak information from the test set into the training process. If we do this too often then we begin to overfit on the test set. Hence, we need some data which can act as a \"proxy\" test set which we can look at more frequently in order to evaluate how well our model actually does on unseen data -- this is the validation set.\n",
+    "\n",
+    "test_size = 0.25\n",
+    "\n",
+    "train_valid_data = train_data.train_test_split(test_size=test_size)\n",
+    "train_data = train_valid_data[\"train\"]\n",
+    "valid_data = train_valid_data[\"test\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we have to build a vocabulary. This is look-up table where every unique token in your dataset has a corresponding index (an integer).\n",
+    "\n",
+    "We do this as machine learning models cannot operate on strings, only numerical vaslues. Each index is used to construct a one-hot vector for each token. A one-hot vector is a vector where all the elements are 0, except one, which is 1, and the dimensionality is the total number of unique tokens in your vocabulary, commonly denoted by V."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "min_freq = 5\n",
+    "special_tokens = [\"<unk>\", \"<pad>\"]\n",
+    "\n",
+    "vocab = torchtext.vocab.build_vocab_from_iterator(\n",
+    "    train_data[\"tokens\"],\n",
+    "    min_freq=min_freq,\n",
+    "    specials=special_tokens,\n",
+    ")\n",
+    "\n",
+    "# We store the indices of the unknown and padding tokens (zero and one, respectively) in variables, as we'll use these further on in this notebook.\n",
+    "\n",
+    "unk_index = vocab[\"<unk>\"]\n",
+    "pad_index = vocab[\"<pad>\"]\n",
+    "\n",
+    "\n",
+    "vocab.set_default_index(unk_index)\n",
+    "\n",
+    "# To look-up a list of tokens, we can use the vocabulary's lookup_indices method.\n",
+    "vocab.lookup_indices([\"hello\", \"world\", \"some_token\", \"<pad>\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we have our vocabulary, we can numericalize our data. This involves converting the tokens within our dataset into indices. Similar to how we tokenized our data using the Dataset.map method, we'll define a function that takes an example and our vocabulary, gets the index for each token in each example and then creates an ids field which containes the numericalized tokens."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def numericalize_example(example, vocab):\n",
+    "    ids = vocab.lookup_indices(example[\"tokens\"])\n",
+    "    return {\"ids\": ids}\n",
+    "\n",
+    "train_data = train_data.map(numericalize_example, fn_kwargs={\"vocab\": vocab})\n",
+    "valid_data = valid_data.map(numericalize_example, fn_kwargs={\"vocab\": vocab})\n",
+    "test_data = test_data.map(numericalize_example, fn_kwargs={\"vocab\": vocab})\n",
+    "\n",
+    "train_data = train_data.with_format(type=\"torch\", columns=[\"ids\", \"label\"])\n",
+    "valid_data = valid_data.with_format(type=\"torch\", columns=[\"ids\", \"label\"])\n",
+    "test_data = test_data.with_format(type=\"torch\", columns=[\"ids\", \"label\"])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The final step of preparing the data is creating the data loaders. We can iterate over a data loader to retrieve batches of examples. This is also where we will perform any padding that is necessary.\n",
+    "\n",
+    "We first need to define a function to collate a batch, consisting of a list of examples, into what we want our data loader to output.\n",
+    "\n",
+    "Here, our desired output from the data loader is a dictionary with keys of \"ids\" and \"label\".\n",
+    "\n",
+    "The value of batch[\"ids\"] should be a tensor of shape [batch size, length], where length is the length of the longest sentence (in terms of tokens) within the batch, and all sentences shorter than this should be padded to that length.\n",
+    "\n",
+    "The value of batch[\"label\"] should be a tensor of shape [batch size] consisting of the label for each sentence in the batch.\n",
+    "\n",
+    "We define a function, get_collate_fn, which is passed the pad token index and returns the actual collate function. Within the actual collate function, collate_fn, we get a list of \"ids\" tensors for each example in the batch, and then use the pad_sequence function, which converts the list of tensors into the desired [batch size, length] shaped tensor and performs padding using the specified pad_index. By default, pad_sequence will return a [length, batch size] shaped tensor, but by setting batch_first=True, these two dimensions are switched. We get a list of \"label\" tensors and convert the list of tensors into a single [batch size] shaped tensor."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_collate_fn(pad_index):\n",
+    "    def collate_fn(batch):\n",
+    "        batch_ids = [i[\"ids\"] for i in batch]\n",
+    "        batch_ids = nn.utils.rnn.pad_sequence(\n",
+    "            batch_ids, padding_value=pad_index, batch_first=True\n",
+    "        )\n",
+    "        batch_label = [i[\"label\"] for i in batch]\n",
+    "        batch_label = torch.stack(batch_label)\n",
+    "        batch = {\"ids\": batch_ids, \"label\": batch_label}\n",
+    "        return batch\n",
+    "\n",
+    "    return collate_fn\n",
+    "\n",
+    "def get_data_loader(dataset, batch_size, pad_index, shuffle=False):\n",
+    "    collate_fn = get_collate_fn(pad_index)\n",
+    "    data_loader = torch.utils.data.DataLoader(\n",
+    "        dataset=dataset,\n",
+    "        batch_size=batch_size,\n",
+    "        collate_fn=collate_fn,\n",
+    "        shuffle=shuffle,\n",
+    "    )\n",
+    "    return data_loader\n",
+    "\n",
+    "\n",
+    "batch_size = 512\n",
+    "\n",
+    "train_data_loader = get_data_loader(train_data, batch_size, pad_index, shuffle=True)\n",
+    "valid_data_loader = get_data_loader(valid_data, batch_size, pad_index)\n",
+    "test_data_loader = get_data_loader(test_data, batch_size, pad_index)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "\n",
+    "class NBoW(nn.Module):\n",
+    "    def __init__(self, vocab_size, embedding_dim, output_dim, pad_index):\n",
+    "        super().__init__()\n",
+    "        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=pad_index)\n",
+    "        self.fc = nn.Linear(embedding_dim, output_dim)\n",
+    "\n",
+    "    def forward(self, ids):\n",
+    "        # ids = [batch size, seq len]\n",
+    "        embedded = self.embedding(ids)\n",
+    "        # embedded = [batch size, seq len, embedding dim]\n",
+    "        pooled = embedded.mean(dim=1)\n",
+    "        # pooled = [batch size, embedding dim]\n",
+    "        prediction = self.fc(pooled)\n",
+    "        # prediction = [batch size, output dim]\n",
+    "        return prediction\n",
+    "\n",
+    "\n",
+    "vocab_size = len(vocab)\n",
+    "embedding_dim = 300\n",
+    "output_dim = len(train_data.unique(\"label\"))\n",
+    "\n",
+    "model = NBoW(vocab_size, embedding_dim, output_dim, pad_index)\n",
+    "\n",
+    "def count_parameters(model):\n",
+    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
+    "\n",
+    "\n",
+    "print(f\"The model has {count_parameters(model):,} trainable parameters\")\n",
+    "\n",
+    "vectors = torchtext.vocab.GloVe()\n",
+    "\n",
+    "pretrained_embedding = vectors.get_vecs_by_tokens(vocab.get_itos())\n",
+    "\n",
+    "optimizer = optim.Adam(model.parameters())\n",
+    "\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "model = model.to(device)\n",
+    "criterion = criterion.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train(data_loader, model, criterion, optimizer, device):\n",
+    "    model.train()\n",
+    "    epoch_losses = []\n",
+    "    epoch_accs = []\n",
+    "    for batch in tqdm.tqdm(data_loader, desc=\"training...\"):\n",
+    "        ids = batch[\"ids\"].to(device)\n",
+    "        label = batch[\"label\"].to(device)\n",
+    "        prediction = model(ids)\n",
+    "        loss = criterion(prediction, label)\n",
+    "        accuracy = get_accuracy(prediction, label)\n",
+    "        optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        epoch_losses.append(loss.item())\n",
+    "        epoch_accs.append(accuracy.item())\n",
+    "    return np.mean(epoch_losses), np.mean(epoch_accs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def evaluate(data_loader, model, criterion, device):\n",
+    "    model.eval()\n",
+    "    epoch_losses = []\n",
+    "    epoch_accs = []\n",
+    "    with torch.no_grad():\n",
+    "        for batch in tqdm.tqdm(data_loader, desc=\"evaluating...\"):\n",
+    "            ids = batch[\"ids\"].to(device)\n",
+    "            label = batch[\"label\"].to(device)\n",
+    "            prediction = model(ids)\n",
+    "            loss = criterion(prediction, label)\n",
+    "            accuracy = get_accuracy(prediction, label)\n",
+    "            epoch_losses.append(loss.item())\n",
+    "            epoch_accs.append(accuracy.item())\n",
+    "    return np.mean(epoch_losses), np.mean(epoch_accs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_accuracy(prediction, label):\n",
+    "    batch_size, _ = prediction.shape\n",
+    "    predicted_classes = prediction.argmax(dim=-1)\n",
+    "    correct_predictions = predicted_classes.eq(label).sum()\n",
+    "    accuracy = correct_predictions / batch_size\n",
+    "    return accuracy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_epochs = 10\n",
+    "best_valid_loss = float(\"inf\")\n",
+    "\n",
+    "metrics = collections.defaultdict(list)\n",
+    "\n",
+    "for epoch in range(n_epochs):\n",
+    "    train_loss, train_acc = train(\n",
+    "        train_data_loader, model, criterion, optimizer, device\n",
+    "    )\n",
+    "    valid_loss, valid_acc = evaluate(valid_data_loader, model, criterion, device)\n",
+    "    metrics[\"train_losses\"].append(train_loss)\n",
+    "    metrics[\"train_accs\"].append(train_acc)\n",
+    "    metrics[\"valid_losses\"].append(valid_loss)\n",
+    "    metrics[\"valid_accs\"].append(valid_acc)\n",
+    "    if valid_loss < best_valid_loss:\n",
+    "        best_valid_loss = valid_loss\n",
+    "        torch.save(model.state_dict(), \"nbow.pt\")\n",
+    "    print(f\"epoch: {epoch}\")\n",
+    "    print(f\"train_loss: {train_loss:.3f}, train_acc: {train_acc:.3f}\")\n",
+    "    print(f\"valid_loss: {valid_loss:.3f}, valid_acc: {valid_acc:.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig = plt.figure(figsize=(10, 6))\n",
+    "ax = fig.add_subplot(1, 1, 1)\n",
+    "ax.plot(metrics[\"train_losses\"], label=\"train loss\")\n",
+    "ax.plot(metrics[\"valid_losses\"], label=\"valid loss\")\n",
+    "ax.set_xlabel(\"epoch\")\n",
+    "ax.set_ylabel(\"loss\")\n",
+    "ax.set_xticks(range(n_epochs))\n",
+    "ax.legend()\n",
+    "ax.grid()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig = plt.figure(figsize=(10, 6))\n",
+    "ax = fig.add_subplot(1, 1, 1)\n",
+    "ax.plot(metrics[\"train_accs\"], label=\"train accuracy\")\n",
+    "ax.plot(metrics[\"valid_accs\"], label=\"valid accuracy\")\n",
+    "ax.set_xlabel(\"epoch\")\n",
+    "ax.set_ylabel(\"loss\")\n",
+    "ax.set_xticks(range(n_epochs))\n",
+    "ax.legend()\n",
+    "ax.grid()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.load_state_dict(torch.load(\"nbow.pt\"))\n",
+    "\n",
+    "test_loss, test_acc = evaluate(test_data_loader, model, criterion, device)\n",
+    "\n",
+    "print(f\"test_loss: {test_loss:.3f}, test_acc: {test_acc:.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict_sentiment(text, model, tokenizer, vocab, device):\n",
+    "    tokens = tokenizer(text)\n",
+    "    ids = vocab.lookup_indices(tokens)\n",
+    "    tensor = torch.LongTensor(ids).unsqueeze(dim=0).to(device)\n",
+    "    prediction = model(tensor).squeeze(dim=0)\n",
+    "    probability = torch.softmax(prediction, dim=-1)\n",
+    "    predicted_class = prediction.argmax(dim=-1).item()\n",
+    "    predicted_probability = probability[predicted_class].item()\n",
+    "    return predicted_class, predicted_probability"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text = \"This film is terrible!\"\n",
+    "\n",
+    "predict_sentiment(text, model, tokenizer, vocab, device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text = \"This film is great!\"\n",
+    "\n",
+    "predict_sentiment(text, model, tokenizer, vocab, device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text = \"This film is not terrible, it's great!\"\n",
+    "\n",
+    "predict_sentiment(text, model, tokenizer, vocab, device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text = \"This film is not great, it's terrible!\"\n",
+    "\n",
+    "predict_sentiment(text, model, tokenizer, vocab, device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def text_to_tensor(text, tokenizer, vocab, device):\n",
+    "    tokens = tokenizer(text)\n",
+    "    ids = vocab.lookup_indices(tokens)\n",
+    "    tensor = torch.LongTensor(ids).unsqueeze(dim=0).to(device)\n",
+    "    return tensor\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we do onnx stuff to get the data ready for the zk-circuit."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import json\n",
+    "\n",
+    "text = \"This film is terrible!\"\n",
+    "x = text_to_tensor(text, tokenizer, vocab, device)\n",
+    "\n",
+    "# Flips the neural net into inference mode\n",
+    "model.eval()\n",
+    "model.to('cpu')\n",
+    "\n",
+    "model_path = \"network.onnx\"\n",
+    "data_path = \"input.json\"\n",
+    "\n",
+    "    # Export the model\n",
+    "torch.onnx.export(model,               # model being run\n",
+    "                      x,                   # model input (or a tuple for multiple inputs)\n",
+    "                      model_path,            # 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",
+    "\n",
+    "\n",
+    "data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
+    "\n",
+    "data_json = dict(input_data = [data_array])\n",
+    "\n",
+    "print(data_json)\n",
+    "\n",
+    "    # Serialize data into file:\n",
+    "json.dump(data_json, open(data_path, 'w'))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ezkl\n",
+    "\n",
+    "run_args = ezkl.PyRunArgs()\n",
+    "run_args.logrows = 23\n",
+    "run_args.scale_rebase_multiplier = 10\n",
+    "# inputs should be auditable by all\n",
+    "run_args.input_visibility = \"public\"\n",
+    "# same with outputs\n",
+    "run_args.output_visibility = \"public\"\n",
+    "# for simplicity, we'll just use the fixed model visibility: i.e it is public and can't be changed by the prover\n",
+    "run_args.param_visibility = \"fixed\"\n",
+    "\n",
+    "\n",
+    "# TODO: Dictionary outputs\n",
+    "res = ezkl.gen_settings(py_run_args=run_args)\n",
+    "assert res == True\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res = ezkl.compile_circuit()\n",
+    "assert res == True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# srs path\n",
+    "res = await ezkl.get_srs()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# now generate the witness file\n",
+    "res = await ezkl.gen_witness()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res = ezkl.mock()\n",
+    "assert res == True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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",
+    "res = ezkl.setup()\n",
+    "\n",
+    "assert res == True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# GENERATE A PROOF\n",
+    "res = ezkl.prove(proof_path=\"proof.json\")\n",
+    "\n",
+    "print(res)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# VERIFY IT\n",
+    "res = ezkl.verify()\n",
+    "\n",
+    "assert res == True\n",
+    "print(\"verified\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also verify it on chain by creating an onchain verifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# check if notebook is in colab\n",
+    "try:\n",
+    "    import google.colab\n",
+    "    import subprocess\n",
+    "    import sys\n",
+    "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"solc-select\"])\n",
+    "    !solc-select install 0.8.20\n",
+    "    !solc-select use 0.8.20\n",
+    "    !solc --version\n",
+    "    import os\n",
+    "\n",
+    "# rely on local installation if the notebook is not in colab\n",
+    "except:\n",
+    "    import os\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res = await ezkl.create_evm_verifier()\n",
+    "assert res == True\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You should see a `Verifier.sol`. Right-click and save it locally.\n",
+    "\n",
+    "Now go to [https://remix.ethereum.org](https://remix.ethereum.org).\n",
+    "\n",
+    "Create a new file within remix and copy the verifier code over.\n",
+    "\n",
+    "Finally, compile the code and deploy. For the demo you can deploy to the test environment within remix.\n",
+    "\n",
+    "If everything works, you would have deployed your verifer onchain! Copy the values in the cell above to the respective fields to test if the verifier is working."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".env",
+   "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.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

examples/notebooks/proof_splitting.ipynb

@@ -232,7 +232,7 @@
                 "run_args.param_visibility = \"fixed\"\n",
                 "run_args.output_visibility = \"public\"\n",
                 "run_args.input_scale = 2\n",
-                "run_args.logrows = 8\n",
+                "run_args.logrows = 15\n",
                 "\n",
                 "ezkl.get_srs(logrows=run_args.logrows, commitment=ezkl.PyCommitments.KZG)"
             ]
@@ -404,7 +404,7 @@
                 "run_args.output_visibility = \"polycommit\"\n",
                 "run_args.variables = [(\"batch_size\", 1)]\n",
                 "run_args.input_scale = 2\n",
-                "run_args.logrows = 8\n"
+                "run_args.logrows = 15\n"
             ]
         },
         {
@@ -466,7 +466,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.12.2"
+            "version": "3.12.5"
         },
         "orig_nbformat": 4
     },

examples/notebooks/reusable_verifier.ipynb

@@ -0,0 +1,339 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Reusable Verifiers \n",
+    "\n",
+    "This notebook demonstrates how to create and reuse the same set of separated verifiers for different models. Specifically, we will use the same verifier for the following four models:\n",
+    "\n",
+    "- `1l_mlp sigmoid`\n",
+    "- `1l_mlp relu`\n",
+    "- `1l_conv sigmoid`\n",
+    "- `1l_conv relu`\n",
+    "\n",
+    "When deploying EZKL verifiers on the blockchain, each associated model typically requires its own unique verifier, leading to increased on-chain state usage. \n",
+    "However, with the reusable verifier, we can deploy a single verifier that can be used to verify proofs for any valid H2 circuit. This notebook shows how to do so. \n",
+    "\n",
+    "By reusing the same verifier across multiple models, we significantly reduce the amount of state bloat on the blockchain. Instead of deploying a unique verifier for each model, we deploy a unique and much smaller verifying key artifact (VKA) contract for each model while sharing a common separated verifier. The VKA contains the VK for the model as well circuit specific metadata that was otherwise hardcoded into the stack of the original non-reusable verifier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.onnx\n",
+    "\n",
+    "# Define the models\n",
+    "class MLP_Sigmoid(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(MLP_Sigmoid, self).__init__()\n",
+    "        self.fc = nn.Linear(3, 3)\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.fc(x)\n",
+    "        x = self.sigmoid(x)\n",
+    "        return x\n",
+    "\n",
+    "class MLP_Relu(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(MLP_Relu, self).__init__()\n",
+    "        self.fc = nn.Linear(3, 3)\n",
+    "        self.relu = nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.fc(x)\n",
+    "        x = self.relu(x)\n",
+    "        return x\n",
+    "\n",
+    "class Conv_Sigmoid(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Conv_Sigmoid, self).__init__()\n",
+    "        self.conv = nn.Conv1d(1, 1, kernel_size=3, stride=1)\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv(x)\n",
+    "        x = self.sigmoid(x)\n",
+    "        return x\n",
+    "\n",
+    "class Conv_Relu(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Conv_Relu, self).__init__()\n",
+    "        self.conv = nn.Conv1d(1, 1, kernel_size=3, stride=1)\n",
+    "        self.relu = nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv(x)\n",
+    "        x = self.relu(x)\n",
+    "        return x\n",
+    "\n",
+    "# Instantiate the models\n",
+    "mlp_sigmoid = MLP_Sigmoid()\n",
+    "mlp_relu = MLP_Relu()\n",
+    "conv_sigmoid = Conv_Sigmoid()\n",
+    "conv_relu = Conv_Relu()\n",
+    "\n",
+    "# Dummy input tensor for mlp\n",
+    "dummy_input_mlp = torch.tensor([[-1.5737053155899048, -1.708398461341858, 0.19544155895709991]])\n",
+    "input_mlp_path = 'mlp_input.json'\n",
+    "\n",
+    "# Dummy input tensor for conv\n",
+    "dummy_input_conv = torch.tensor([[[1.4124163389205933, 0.6938204169273376, 1.0664031505584717]]])\n",
+    "input_conv_path = 'conv_input.json'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "names = ['mlp_sigmoid', 'mlp_relu', 'conv_sigmoid', 'conv_relu']\n",
+    "models = [mlp_sigmoid, mlp_relu, conv_sigmoid, conv_relu]\n",
+    "inputs = [dummy_input_mlp, dummy_input_mlp, dummy_input_conv, dummy_input_conv]\n",
+    "input_paths = [input_mlp_path, input_mlp_path, input_conv_path, input_conv_path]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import json\n",
+    "import torch\n",
+    "import ezkl\n",
+    "\n",
+    "for name, model, x, input_path in zip(names, models, inputs, input_paths):\n",
+    "    # Create a new directory for the model if it doesn't exist\n",
+    "    if not os.path.exists(name):\n",
+    "        os.mkdir(name)\n",
+    "    # Store the paths in each of their respective directories\n",
+    "    model_path = os.path.join(name, \"network.onnx\")\n",
+    "    compiled_model_path = os.path.join(name, \"network.compiled\")\n",
+    "    pk_path = os.path.join(name, \"test.pk\")\n",
+    "    vk_path = os.path.join(name, \"test.vk\")\n",
+    "    settings_path = os.path.join(name, \"settings.json\")\n",
+    "\n",
+    "    witness_path = os.path.join(name, \"witness.json\")\n",
+    "    sol_code_path = os.path.join(name, 'test.sol')\n",
+    "    sol_key_code_path = os.path.join(name, 'test_key.sol')\n",
+    "    abi_path = os.path.join(name, 'test.abi')\n",
+    "    proof_path = os.path.join(name, \"proof.json\")\n",
+    "\n",
+    "    # Flips the neural net into inference mode\n",
+    "    model.eval()\n",
+    "\n",
+    "    # Export the model\n",
+    "    torch.onnx.export(model, x, model_path, export_params=True, opset_version=10,\n",
+    "                      do_constant_folding=True, input_names=['input'],\n",
+    "                      output_names=['output'], dynamic_axes={'input': {0: 'batch_size'},\n",
+    "                                                              'output': {0: 'batch_size'}})\n",
+    "\n",
+    "    data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
+    "    data = dict(input_data=[data_array])\n",
+    "    json.dump(data, open(input_path, 'w'))\n",
+    "\n",
+    "    py_run_args = ezkl.PyRunArgs()\n",
+    "    py_run_args.input_visibility = \"private\"\n",
+    "    py_run_args.output_visibility = \"public\"\n",
+    "    py_run_args.param_visibility = \"fixed\"  # private by default\n",
+    "\n",
+    "    res = ezkl.gen_settings(model_path, settings_path, py_run_args=py_run_args)\n",
+    "    assert res == True\n",
+    "\n",
+    "    await ezkl.calibrate_settings(input_path, model_path, settings_path, \"resources\")\n",
+    "\n",
+    "    res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
+    "    assert res == True\n",
+    "\n",
+    "    res = await ezkl.get_srs(settings_path)\n",
+    "    assert res == True\n",
+    "\n",
+    "    # now generate the witness file\n",
+    "    res = await ezkl.gen_witness(input_path, compiled_model_path, witness_path)\n",
+    "    assert os.path.isfile(witness_path) == True\n",
+    "\n",
+    "    # SETUP \n",
+    "    # We recommend disabling selector compression for the setup as it decreases the size of the VK artifact\n",
+    "    res = ezkl.setup(compiled_model_path, vk_path, pk_path, disable_selector_compression=True)\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)\n",
+    "\n",
+    "    # GENERATE A PROOF\n",
+    "    res = ezkl.prove(witness_path, compiled_model_path, pk_path, proof_path, \"single\")\n",
+    "    assert os.path.isfile(proof_path)\n",
+    "\n",
+    "    res = await ezkl.create_evm_verifier(vk_path, settings_path, sol_code_path, abi_path, reusable=True)\n",
+    "    assert res == True\n",
+    "\n",
+    "    res = await ezkl.create_evm_vka(vk_path, settings_path, sol_key_code_path, abi_path)\n",
+    "    assert res == True\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import subprocess\n",
+    "import time\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"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Check that the generated verifiers are identical for all models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "start_anvil()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import filecmp\n",
+    "\n",
+    "def compare_files(file1, file2):\n",
+    "    return filecmp.cmp(file1, file2, shallow=False)\n",
+    "\n",
+    "sol_code_path_0 = os.path.join(\"mlp_sigmoid\", 'test.sol')\n",
+    "sol_code_path_1 = os.path.join(\"mlp_relu\", 'test.sol')\n",
+    "\n",
+    "sol_code_path_2 = os.path.join(\"conv_sigmoid\", 'test.sol')\n",
+    "sol_code_path_3 = os.path.join(\"conv_relu\", 'test.sol')\n",
+    "\n",
+    "\n",
+    "assert compare_files(sol_code_path_0, sol_code_path_1) == True\n",
+    "assert compare_files(sol_code_path_2, sol_code_path_3) == True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we deploy separate verifier that will be shared by the four models. We picked the `1l_mlp sigmoid` model as an example but you could have used any of the generated verifiers since they are all identical. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os \n",
+    "addr_path_verifier = \"addr_verifier.txt\"\n",
+    "sol_code_path = os.path.join(\"mlp_sigmoid\", 'test.sol')\n",
+    "\n",
+    "res = await ezkl.deploy_evm(\n",
+    "    addr_path_verifier,\n",
+    "    sol_code_path,\n",
+    "    'http://127.0.0.1:3030',\n",
+    "    \"verifier/reusable\"\n",
+    ")\n",
+    "\n",
+    "assert res == True\n",
+    "\n",
+    "with open(addr_path_verifier, 'r') as file:\n",
+    "    addr = file.read().rstrip()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally we deploy each of the unique VK-artifacts and verify them using the shared verifier deployed in the previous step."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for name in names:\n",
+    "    addr_path_vk = \"addr_vk.txt\"\n",
+    "    sol_key_code_path = os.path.join(name, 'test_key.sol')\n",
+    "    res = await ezkl.deploy_evm(addr_path_vk, sol_key_code_path, 'http://127.0.0.1:3030', \"vka\")\n",
+    "    assert res == True\n",
+    "\n",
+    "    with open(addr_path_vk, 'r') as file:\n",
+    "        addr_vk = file.read().rstrip()\n",
+    "        \n",
+    "    proof_path = os.path.join(name, \"proof.json\")\n",
+    "    sol_code_path = os.path.join(name, 'vk.sol')\n",
+    "    res = await ezkl.verify_evm(\n",
+    "        addr,\n",
+    "        proof_path,\n",
+    "        \"http://127.0.0.1:3030\",\n",
+    "        addr_vk = addr_vk\n",
+    "    )\n",
+    "    assert res == True"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".env",
+   "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

examples/notebooks/simple_demo_aggregated_proofs.ipynb

@@ -171,7 +171,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -328,7 +328,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 26,
             "id": "171702d3",
             "metadata": {},
             "outputs": [],
@@ -348,7 +348,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 27,
             "id": "671dfdd5",
             "metadata": {},
             "outputs": [],
@@ -364,7 +364,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 28,
             "id": "50eba2f4",
             "metadata": {},
             "outputs": [],
@@ -399,9 +399,9 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.7"
         }
     },
     "nbformat": 4,
     "nbformat_minor": 5
-}
+}

examples/notebooks/univ3-da.ipynb

@@ -0,0 +1,763 @@
+{
+    "cells": [
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "# univ3-da-ezkl\n",
+                "\n",
+                "Here's an example leveraging EZKL whereby the inputs to the model are read and attested to from an on-chain source. For this setup we make a single call to a view function that returns an array of UniV3 historical TWAP price data that we will attest to 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": 2,
+            "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": 3,
+            "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": 4,
+            "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": 44,
+            "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\", \"--fork-url\", \"https://arb1.arbitrum.io/rpc\", \"--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`: \"private\"\n",
+                "- `output_visibility`: public\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 6,
+            "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 = \"private\"\n",
+                "run_args.output_visibility = \"public\"\n",
+                "run_args.num_inner_cols = 1\n",
+                "run_args.variables = [(\"batch_size\", 1)]"
+            ]
+        },
+        {
+            "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": [
+                "# 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 for a single call data source:\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",
+                "            \"call_data\": \"1f3be514000000000000000000000000c6962004f452be9203591991d15f6b388e09e8d00000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000\", // The abi encoded call data to a view function that returns an array of on-chain data points we are attesting to. \n",
+                "            \"decimals\": 0, // 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",
+                "            \"address\": \"9A213F53334279C128C37DA962E5472eCD90554f\", // The address of the contract that we are calling to get the data. \n",
+                "            \"len\": 12 // The number of data points returned by the view function (the length of the array)\n",
+                "        }\n",
+                "    }\n",
+                "}\n",
+                "```"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from web3 import Web3, HTTPProvider\n",
+                "from solcx import compile_standard\n",
+                "from decimal import Decimal\n",
+                "import json\n",
+                "import os\n",
+                "import torch\n",
+                "import requests\n",
+                "\n",
+                "# This function counts the decimal places of a floating point number\n",
+                "def count_decimal_places(num):\n",
+                "    num_str = str(num)\n",
+                "    if '.' in num_str:\n",
+                "        return len(num_str) - 1 - num_str.index('.')\n",
+                "    else:\n",
+                "        return 0\n",
+                "\n",
+                "# setup web3 instance\n",
+                "w3 = Web3(HTTPProvider(RPC_URL)) \n",
+                "\n",
+                "def set_next_block_timestamp(anvil_url, timestamp):\n",
+                "    # Send the JSON-RPC request to Anvil\n",
+                "    payload = {\n",
+                "        \"jsonrpc\": \"2.0\",\n",
+                "        \"id\": 1,\n",
+                "        \"method\": \"evm_setNextBlockTimestamp\",\n",
+                "        \"params\": [timestamp]\n",
+                "    }\n",
+                "    response = requests.post(anvil_url, json=payload)\n",
+                "    if response.status_code == 200:\n",
+                "        print(f\"Next block timestamp set to: {timestamp}\")\n",
+                "    else:\n",
+                "        print(f\"Failed to set next block timestamp: {response.text}\")\n",
+                "\n",
+                "def on_chain_data(tensor):\n",
+                "    # Step 0: Convert the tensor to a flat list\n",
+                "    data = tensor.view(-1).tolist()\n",
+                "\n",
+                "    # Step 1: Prepare the calldata\n",
+                "    secondsAgo = [len(data) - 1 - i for i in range(len(data))]\n",
+                "\n",
+                "    # Step 2: Prepare and compile the contract UniTickAttestor contract\n",
+                "    contract_source_code = '''\n",
+                "    // SPDX-License-Identifier: MIT\n",
+                "    pragma solidity ^0.8.20;\n",
+                "\n",
+                "    /// @title Pool state that is not stored\n",
+                "    /// @notice Contains view functions to provide information about the pool that is computed rather than stored on the\n",
+                "    /// blockchain. The functions here may have variable gas costs.\n",
+                "    interface IUniswapV3PoolDerivedState {\n",
+                "        /// @notice Returns the cumulative tick and liquidity as of each timestamp `secondsAgo` from the current block timestamp\n",
+                "        /// @dev To get a time weighted average tick or liquidity-in-range, you must call this with two values, one representing\n",
+                "        /// the beginning of the period and another for the end of the period. E.g., to get the last hour time-weighted average tick,\n",
+                "        /// you must call it with secondsAgos = [3600, 0].\n",
+                "        /// log base sqrt(1.0001) of token1 / token0. The TickMath library can be used to go from a tick value to a ratio.\n",
+                "        /// @dev The time weighted average tick represents the geometric time weighted average price of the pool, in\n",
+                "        /// @param secondsAgos From how long ago each cumulative tick and liquidity value should be returned\n",
+                "        /// @return tickCumulatives Cumulative tick values as of each `secondsAgos` from the current block timestamp\n",
+                "        /// @return secondsPerLiquidityCumulativeX128s Cumulative seconds per liquidity-in-range value as of each `secondsAgos` from the current block\n",
+                "        /// timestamp\n",
+                "        function observe(\n",
+                "            uint32[] calldata secondsAgos\n",
+                "        )\n",
+                "            external\n",
+                "            view\n",
+                "            returns (\n",
+                "                int56[] memory tickCumulatives,\n",
+                "                uint160[] memory secondsPerLiquidityCumulativeX128s\n",
+                "            );\n",
+                "    }\n",
+                "\n",
+                "    /// @title Uniswap Wrapper around `pool.observe` that stores the parameters for fetching and then attesting to historical data\n",
+                "    /// @notice Provides functions to integrate with V3 pool oracle\n",
+                "    contract UniTickAttestor {\n",
+                "        /**\n",
+                "        * @notice Calculates time-weighted means of tick and liquidity for a given Uniswap V3 pool\n",
+                "        * @param pool Address of the pool that we want to observe\n",
+                "        * @param secondsAgo Number of seconds in the past from which to calculate the time-weighted means\n",
+                "        * @return tickCumulatives The cumulative tick values as of each `secondsAgo` from the current block timestamp\n",
+                "        */\n",
+                "        function consult(\n",
+                "            IUniswapV3PoolDerivedState pool,\n",
+                "            uint32[] memory secondsAgo\n",
+                "        ) public view returns (int256[] memory tickCumulatives) {\n",
+                "            tickCumulatives = new int256[](secondsAgo.length);\n",
+                "            (int56[] memory _ticks,) = pool.observe(secondsAgo);\n",
+                "            for (uint256 i = 0; i < secondsAgo.length; i++) {\n",
+                "                tickCumulatives[i] = int256(_ticks[i]);\n",
+                "            }\n",
+                "        }\n",
+                "    }\n",
+                "    '''\n",
+                "\n",
+                "    compiled_sol = compile_standard({\n",
+                "        \"language\": \"Solidity\",\n",
+                "        \"sources\": {\"UniTickAttestor.sol\": {\"content\": contract_source_code}},\n",
+                "        \"settings\": {\"outputSelection\": {\"*\": {\"*\": [\"metadata\", \"evm.bytecode\", \"abi\"]}}}\n",
+                "    })\n",
+                "\n",
+                "    # Get bytecode\n",
+                "    bytecode = compiled_sol['contracts']['UniTickAttestor.sol']['UniTickAttestor']['evm']['bytecode']['object']\n",
+                "\n",
+                "    # Get ABI\n",
+                "    # In production if you are reading from really large contracts you can just use\n",
+                "    # a stripped down version of the ABI of the contract you are calling, containing only the view functions you will fetch data from.\n",
+                "    abi = json.loads(compiled_sol['contracts']['UniTickAttestor.sol']['UniTickAttestor']['metadata'])['output']['abi']\n",
+                "\n",
+                "    # Step 3: Deploy the contract\n",
+                "    UniTickAttestor = w3.eth.contract(abi=abi, bytecode=bytecode)\n",
+                "    tx_hash = UniTickAttestor.constructor().transact()\n",
+                "    tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)\n",
+                "    # If you are deploying to production you can skip the 3 lines of code above and just instantiate the contract like this,\n",
+                "    # passing the address and abi of the contract you are fetching data from.\n",
+                "    contract = w3.eth.contract(address=tx_receipt['contractAddress'], abi=abi)\n",
+                "\n",
+                "    # Step 4: Interact with the contract\n",
+                "    call = contract.functions.consult(\n",
+                "        # Address of the UniV3 usdc-weth pool 0.005 fee\n",
+                "        \"0xC6962004f452bE9203591991D15f6b388e09E8D0\",\n",
+                "        secondsAgo\n",
+                "    ).build_transaction()\n",
+                "    result = contract.functions.consult(\n",
+                "        # Address of the UniV3 usdc-weth pool 0.005 fee\n",
+                "        \"0xC6962004f452bE9203591991D15f6b388e09E8D0\",\n",
+                "        secondsAgo\n",
+                "    ).call()\n",
+                "    \n",
+                "    print(f'result: {result}')\n",
+                "    calldata = call['data'][2:]\n",
+                "\n",
+                "    time_stamp = w3.eth.get_block('latest')['timestamp']\n",
+                "\n",
+                "    print(f'time_stamp: {time_stamp}')\n",
+                "\n",
+                "    # Set the next block timestamp using the fetched time_stamp\n",
+                "    set_next_block_timestamp(RPC_URL, time_stamp)\n",
+                "\n",
+                "\n",
+                "    # Prepare the calls_to_account object\n",
+                "    # If you were calling view functions across multiple contracts,\n",
+                "    # you would have multiple entries in the calls_to_account array,\n",
+                "    # one for each contract.\n",
+                "    call_to_account = {\n",
+                "        'call_data': calldata,\n",
+                "        'decimals': 0,\n",
+                "        'address': contract.address[2:], # remove the '0x' prefix\n",
+                "        'len': len(data),\n",
+                "    }\n",
+                "\n",
+                "    print(f'call_to_account: {call_to_account}')\n",
+                "\n",
+                "    return call_to_account\n",
+                "\n",
+                "# Now let's start the Anvil process. You don't need to do this if you are deploying to a non-local chain.\n",
+                "start_anvil()\n",
+                "\n",
+                "# Now let's call our function, passing in the same input tensor we used to export the model 2 cells above.\n",
+                "calls_to_account = on_chain_data(x)\n",
+                "\n",
+                "data = dict(input_data =  {'rpc': RPC_URL, 'calls': calls_to_account })\n",
+                "\n",
+                "# Serialize on-chain data into file:\n",
+                "json.dump(data, open(\"input.json\", 'w'))"
+            ]
+        },
+        {
+            "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)"
+            ]
+        },
+        {
+            "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)"
+            ]
+        },
+        {
+            "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",
+                "        \"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",
+                "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",
+                "        settings_path,\n",
+                "        sol_code_path,\n",
+                "        abi_path,\n",
+                "    )\n",
+                "assert res == True"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import json\n",
+                "\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": [
+                "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. "
+            ]
+        },
+        {
+            "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",
+                "    )"
+            ]
+        },
+        {
+            "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": [
+                "Here we need to regenerate the witness, prove and then verify all within the same cell. This is because we want to reduce the amount of latency between reading on-chain state and verifying it on-chain. This is because the attest input values read from the oracle are time sensitive (their values are derived from computing on block.timestamp) and can change between the time of reading and the time of verifying.\n",
+                "\n",
+                "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": [
+                "# !export RUST_BACKTRACE=1\n",
+                "\n",
+                "calls_to_account = on_chain_data(x)\n",
+                "\n",
+                "data = dict(input_data =  {'rpc': RPC_URL, 'calls': calls_to_account })\n",
+                "\n",
+                "# Serialize on-chain data into file:\n",
+                "json.dump(data, open(\"input.json\", 'w'))\n",
+                "\n",
+                "# setup web3 instance\n",
+                "w3 = Web3(HTTPProvider(RPC_URL)) \n",
+                "\n",
+                "time_stamp = w3.eth.get_block('latest')['timestamp']\n",
+                "\n",
+                "print(f'time_stamp: {time_stamp}')\n",
+                "\n",
+                "\n",
+                "witness_path = \"witness.json\"\n",
+                "\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "\n",
+                "res = ezkl.prove(\n",
+                "        witness_path,\n",
+                "        compiled_model_path,\n",
+                "        pk_path,\n",
+                "        proof_path,\n",
+                "        \"single\",\n",
+                "    )\n",
+                "\n",
+                "print(res)\n",
+                "assert os.path.isfile(proof_path)\n",
+                "# 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": ".env",
+            "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.11.5"
+        },
+        "orig_nbformat": 4
+    },
+    "nbformat": 4,
+    "nbformat_minor": 2
+}

examples/onnx/boolean/gen.py

@@ -9,7 +9,9 @@ class MyModel(nn.Module):
         super(MyModel, self).__init__()
 
     def forward(self, w, x, y, z):
-        return [((x & y)) == (x & (y | (z ^ w)))]
+        a = (x & y)
+        b = (y & (z ^ w))
+        return [a & b]
 
 
 circuit = MyModel()

examples/onnx/boolean/input.json

@@ -1 +1 @@
-{"input_data": [[false, true, false], [true, false, false], [true, false, false], [false, false, false]]}
+{"input_data": [[false, true, true], [false, true, true], [true, false, false], [false, true, true]]}

examples/onnx/boolean/network.onnx

@@ -1,21 +1,17 @@
-pytorch1.12.1:«
-+
+pytorch2.2.2:„
+*
 input1
-input2
-onnx::Equal_4And_0"And
+input2
+/And_output_0/And"And
 )
-input3
-input
-onnx::Or_5Xor_1"Xor
+input3
+input
 /Xor_output_0/Xor"Xor
-input2
-
-onnx::Or_5onnx::And_6Or_2"Or
-0
-input1
-onnx::And_6
-onnx::Equal_7And_3"And
-6
+5
+input2
+
+/Xor_output_0/And_1_output_0/And_1"And
+5
 
 /And_output_0
 /And_1_output_0output/And_2"And

examples/onnx/exp/gen.py

@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.exp(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))

examples/onnx/exp/input.json

@@ -0,0 +1 @@
+{"input_data": [[0.5801457762718201, 0.6019012331962585, 0.8695418238639832, 0.17170941829681396, 0.500616729259491, 0.353726327419281, 0.6726185083389282, 0.5936906337738037]]}

examples/onnx/exp/network.onnx

@@ -0,0 +1,14 @@
+pytorch2.2.2:o
+
+inputoutput/Exp"Exp
+main_graphZ!
+input
+

+
+batch_size
+b"
+output
+

+
+batch_size
+B

examples/onnx/general_exp/gen.py

@@ -0,0 +1,41 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = 10**x
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))

examples/onnx/general_exp/input.json

@@ -0,0 +1 @@
+{"input_data": [[0.9837989807128906, 0.026381194591522217, 0.3403851389884949, 0.14531707763671875, 0.24652725458145142, 0.7945117354393005, 0.4076554775238037, 0.23064672946929932]]}

examples/onnx/log/gen.py

@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.log(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 3)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))

examples/onnx/log/input.json

@@ -0,0 +1 @@
+{"input_data": [[1.9252371788024902, 1.8418371677398682, 0.8400403261184692, 2.083845853805542, 0.9760497808456421, 0.6940176486968994, 0.015579521656036377, 2.2689192295074463]]}

examples/onnx/log/network.onnx

@@ -0,0 +1,14 @@
+pytorch2.2.2:o
+
+inputoutput/Log"Log
+main_graphZ!
+input
+

+
+batch_size
+b"
+output
+

+
+batch_size
+B

examples/onnx/rounding_ops/gen.py

@@ -21,9 +21,9 @@ def main():
     torch_model = Circuit()
     # Input to the model
     shape = [3, 2, 3]
-    w = 0.1*torch.rand(1, *shape, requires_grad=True)
-    x = 0.1*torch.rand(1, *shape, requires_grad=True)
-    y = 0.1*torch.rand(1, *shape, requires_grad=True)
+    w = 2 * torch.rand(1, *shape, requires_grad=True) - 1
+    x = 2 * torch.rand(1, *shape, requires_grad=True) - 1
+    y = 2 * torch.rand(1, *shape, requires_grad=True) - 1
     torch_out = torch_model(w, x, y)
     # Export the model
     torch.onnx.export(torch_model,               # model being run

examples/onnx/rounding_ops/input.json

@@ -1 +1,148 @@
-{"input_shapes": [[3, 2, 3], [3, 2, 3], [3, 2, 3], [3, 2, 3]], "input_data": [[0.0025284828152507544, 0.04976580664515495, 0.025840921327471733, 0.0829394981265068, 0.09595223516225815, 0.08764562010765076, 0.06308566778898239, 0.062386948615312576, 0.08090643584728241, 0.09267748892307281, 0.07428313046693802, 0.08987367898225784, 0.005716216750442982, 0.0666426345705986, 0.012837404385209084, 0.05769496038556099, 0.05761152133345604, 0.08006472885608673], [0.007834953255951405, 0.011380612850189209, 0.08560049533843994, 0.022283583879470825, 0.07879520952701569, 0.04422441124916077, 0.030812596902251244, 0.006081616971641779, 0.011045408435165882, 0.08776585012674332, 0.044985152781009674, 0.015603715553879738, 0.07923348993062973, 0.04872611165046692, 0.0036642670165747404, 0.05142095685005188, 0.0963878259062767, 0.03225792199373245], [0.09952805936336517, 0.002214533044025302, 0.011696457862854004, 0.022422820329666138, 0.04151459410786629, 0.027647346258163452, 0.011919880285859108, 0.006539052817970514, 0.06569185107946396, 0.034328874200582504, 0.0032284557819366455, 0.004105025436729193, 0.022395813837647438, 0.07135921716690063, 0.07882415503263474, 0.09764843434095383, 0.05335796996951103, 0.0525360181927681]], "output_data": [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]]}
+{
+    "input_shapes": [
+        [
+            3,
+            2,
+            3
+        ],
+        [
+            3,
+            2,
+            3
+        ],
+        [
+            3,
+            2,
+            3
+        ],
+        [
+            3,
+            2,
+            3
+        ]
+    ],
+    "input_data": [
+        [
+            0.5,
+            1.5,
+            -0.04514765739440918,
+            0.5936200618743896,
+            0.9271858930587769,
+            0.6688600778579712,
+            -0.20331168174743652,
+            -0.7016235589981079,
+            0.025863051414489746,
+            -0.19426143169403076,
+            0.9827852249145508,
+            0.4897397756576538,
+            -1.5,
+            -0.5,
+            0.9278832674026489,
+            0.5943725109100342,
+            -0.573331356048584,
+            0.3675816059112549
+        ],
+        [
+            0.7803324460983276,
+            -0.9616303443908691,
+            0.6070173978805542,
+            -0.028337717056274414,
+            -0.5080242156982422,
+            -0.9280107021331787,
+            0.6150380373001099,
+            0.3865993022918701,
+            -0.43668973445892334,
+            0.17152702808380127,
+            0.5144252777099609,
+            -0.28881049156188965,
+            0.8932310342788696,
+            0.059034109115600586,
+            0.6865451335906982,
+            0.009820222854614258,
+            0.23011493682861328,
+            -0.9492779970169067
+        ],
+        [
+            -0.21352827548980713,
+            -0.16015326976776123,
+            -0.38964390754699707,
+            0.13464701175689697,
+            -0.8814496994018555,
+            0.5037975311279297,
+            -0.804405927658081,
+            0.9858957529067993,
+            0.19567716121673584,
+            0.9777265787124634,
+            0.6151977777481079,
+            0.568595290184021,
+            0.10584986209869385,
+            -0.8975653648376465,
+            0.6235959529876709,
+            -0.547879695892334,
+            0.9289869070053101,
+            0.7567293643951416
+        ]
+    ],
+    "output_data": [
+        [
+            1.0,
+            0.0,
+            -0.0,
+            1.0,
+            1.0,
+            1.0,
+            -0.0,
+            -1.0,
+            0.0,
+            -0.0,
+            1.0,
+            0.0,
+            0.0,
+            1.0,
+            1.0,
+            1.0,
+            -1.0,
+            0.0
+        ],
+        [
+            0.0,
+            -1.0,
+            0.0,
+            -1.0,
+            -1.0,
+            -1.0,
+            0.0,
+            0.0,
+            -1.0,
+            0.0,
+            0.0,
+            -1.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            -1.0
+        ],
+        [
+            -0.0,
+            -0.0,
+            -0.0,
+            1.0,
+            -0.0,
+            1.0,
+            -0.0,
+            1.0,
+            1.0,
+            1.0,
+            1.0,
+            1.0,
+            1.0,
+            -0.0,
+            1.0,
+            -0.0,
+            1.0,
+            1.0
+        ]
+    ]
+}

examples/onnx/rounding_ops/network.onnx

@@ -1,10 +1,11 @@
-pytorch2.0.1:â
+pytorch2.2.2:ă
 
 
woutput_w/Round"Round
 
 
xoutput_x/Floor"Floor
 
-
youtput_y/Ceil"Ceil	torch_jitZ%
+
youtput_y/Ceil"Ceil
+main_graphZ%
 
w 
 

 

examples/onnx/rsqrt/gen.py

@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):         
+        # reciprocal sqrt 
+        m = 1 / torch.sqrt(x)
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))

examples/onnx/rsqrt/input.json

@@ -0,0 +1 @@
+{"input_data": [[0.8590779900550842, 0.4029041528701782, 0.6507361531257629, 0.9782488942146301, 0.37392884492874146, 0.6867020726203918, 0.11407750844955444, 0.362740159034729]]}

examples/onnx/rsqrt/network.onnx

@@ -0,0 +1,17 @@
+pytorch2.2.2:Ź

+$
+input/Sqrt_output_0/Sqrt"Sqrt
+1
+/Sqrt_output_0output/Reciprocal"
+Reciprocal
+main_graphZ!
+input
+

+
+batch_size
+b"
+output
+

+
+batch_size
+B

examples/onnx/scatter_nd/gen.py

@@ -1,75 +1,52 @@
-import torch
-import torch.nn as nn
-import sys
+from torch import nn
 import json
-
-sys.path.append("..")
-
-class Model(nn.Module):
-    """
-    Just one Linear layer
-    """
-    def __init__(self, configs):
-        super(Model, self).__init__()
-        self.seq_len = configs.seq_len
-        self.pred_len = configs.pred_len
-
-        # Use this line if you want to visualize the weights
-        # self.Linear.weight = nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len,self.seq_len]))
-        self.channels = configs.enc_in
-        self.individual = configs.individual
-        if self.individual:
-            self.Linear = nn.ModuleList()
-            for i in range(self.channels):
-                self.Linear.append(nn.Linear(self.seq_len,self.pred_len))
-        else:
-            self.Linear = nn.Linear(self.seq_len, self.pred_len)
-
-    def forward(self, x):
-        # x: [Batch, Input length, Channel]
-        if self.individual:
-            output = torch.zeros([x.size(0),self.pred_len,x.size(2)],dtype=x.dtype).to(x.device)
-            for i in range(self.channels):
-                output[:,:,i] = self.Linear[i](x[:,:,i])
-            x = output
-        else:
-            x = self.Linear(x.permute(0,2,1)).permute(0,2,1)
-        return x # [Batch, Output length, Channel]
-
-class Configs:
-    def __init__(self, seq_len, pred_len, enc_in=321, individual=True):
-      self.seq_len = seq_len
-      self.pred_len = pred_len
-      self.enc_in = enc_in
-      self.individual = individual
-
-model = 'Linear'
-seq_len = 10
-pred_len = 4
-enc_in = 3
-
-configs = Configs(seq_len, pred_len, enc_in, True)
-circuit = Model(configs)
-
-x = torch.randn(1, seq_len, pred_len)
+import numpy as np
+import tf2onnx
 
 
-torch.onnx.export(circuit, x, "network.onnx",
-                  export_params=True,        # store the trained parameter weights inside the model file
-                  opset_version=15,          # the ONNX version to export the model to
-                  do_constant_folding=True,  # whether to execute constant folding for optimization
-                  # the model's input names
-                  input_names=['input'],
-                  output_names=['output'],  # the model's output names
-                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
-                                'output': {0: 'batch_size'}})
+import tensorflow as tf
+from tensorflow.keras.layers import *
+from tensorflow.keras.models import Model
 
 
-d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+# gather_nd in tf then export to onnx
+x = in1 = Input((4, 1), dtype=tf.int32)
+w = in2 = Input((4, ), dtype=tf.int32)
+
+class MyLayer(Layer):
+    def call(self, x, w):
+        shape = tf.constant([8])
+        return tf.scatter_nd(x, w, shape)
+
+x = MyLayer()(x, w)
+
+
+
+tm = Model((in1, in2), x)
+tm.summary()
+tm.compile(optimizer='adam', loss='mse')
+
+shape = [1, 4, 1]
+index_shape = [1, 4]
+# After training, export to onnx (network.onnx) and create a data file (input.json)
+x = np.random.randint(0, 4, shape)
+# w = random int tensor
+w = np.random.randint(0, 4, index_shape)
+
+spec = tf.TensorSpec(shape, tf.int32, name='input_0')
+index_spec = tf.TensorSpec(index_shape, tf.int32, name='input_1')
+
+model_path = "network.onnx"
+
+tf2onnx.convert.from_keras(tm, input_signature=[spec, index_spec], inputs_as_nchw=['input_0', 'input_1'], opset=12, output_path=model_path)
+
+
+d = x.reshape([-1]).tolist()
+d1 = w.reshape([-1]).tolist()
 
 
 data = dict(
-    input_data=[d1],
+    input_data=[d, d1],
 )
 
 # Serialize data into file:

examples/onnx/scatter_nd/input.json

@@ -1 +1,16 @@
-{"input_data": [[0.1874287724494934, 1.0498261451721191, 0.22384068369865417, 1.048445224761963, -0.5670360326766968, -0.38653188943862915, 0.12878702580928802, -2.3675858974456787, 0.5800458192825317, -0.43653929233551025, -0.2511898875236511, 0.3324051797389984, 0.27960312366485596, 0.4763695001602173, 0.3796705901622772, 1.1334782838821411, -0.87981778383255, -1.2451434135437012, 0.7672272324562073, -0.24404007196426392, -0.6875824928283691, 0.3619358539581299, -0.10131897777318954, 0.7169521450996399, 1.6585893630981445, -0.5451845526695251, 0.429487019777298, 0.7426952123641968, -0.2543637454509735, 0.06546942889690399, 0.7939824461936951, 0.1579471379518509, -0.043604474514722824, -0.8621711730957031, -0.5344759821891785, -0.05880478024482727, -0.17351101338863373, 0.5095029473304749, -0.7864817976951599, -0.449171245098114]]}
+{
+    "input_data": [
+        [
+            0,
+            1,
+            2,
+            3
+        ],
+        [
+            1,
+            0,
+            2,
+            1
+        ]
+    ]
+}

ezkl.pyi

@@ -0,0 +1,851 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import os
+import pathlib
+import typing
+from enum import Enum, auto
+
+class PyG1:
+    r"""
+    pyclass containing the struct used for G1, this is mostly a helper class
+    """
+    ...
+
+class PyG1Affine:
+    r"""
+    pyclass containing the struct used for G1
+    """
+    ...
+
+class PyRunArgs:
+    r"""
+    Python class containing the struct used for run_args
+    
+    Returns
+    -------
+    PyRunArgs
+    """
+    ...
+
+class PyCommitments(Enum):
+    r"""
+    pyclass representing an enum, denoting the type of commitment
+    """
+    KZG = auto()
+    IPA = auto()
+
+class PyInputType(Enum):
+    Bool = auto()
+    F16 = auto()
+    F32 = auto()
+    F64 = auto()
+    Int = auto()
+    TDim = auto()
+
+class PyTestDataSource(Enum):
+    r"""
+    pyclass representing an enum
+    """
+    File = auto()
+    OnChain = auto()
+
+def aggregate(aggregation_snarks:typing.Sequence[str | os.PathLike | pathlib.Path],proof_path:str | os.PathLike | pathlib.Path,vk_path:str | os.PathLike | pathlib.Path,transcript:str,logrows:int,check_mode:str,split_proofs:bool,srs_path:typing.Optional[str | os.PathLike | pathlib.Path],commitment:PyCommitments) -> bool:
+    r"""
+    Creates an aggregated proof
+    
+    Arguments
+    ---------
+    aggregation_snarks: list[str]
+        List of paths to the various proofs
+    
+    proof_path: str
+        Path to output the aggregated proof
+    
+    vk_path: str
+        Path to the VK file
+    
+    transcript:
+        Proof transcript type to be used. `evm` used by default. `poseidon` is also supported
+    
+    logrows:
+        Logrows used for aggregation circuit
+    
+    check_mode: str
+        Run sanity checks during calculations. Accepts `safe` or `unsafe`
+    
+    split-proofs: bool
+         Whether the accumulated proofs are segments of a larger circuit
+    
+    srs_path: str
+        Path to the SRS used
+    
+    commitment: str
+        Accepts "kzg" or "ipa"
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def buffer_to_felts(buffer:typing.Sequence[int]) -> list[str]:
+    r"""
+    Converts a buffer to vector of field elements
+    
+    Arguments
+    -------
+    buffer: list[int]
+        List of integers representing a buffer
+    
+    Returns
+    -------
+    list[str]
+        List of field elements represented as strings
+    """
+    ...
+
+def calibrate_settings(data:str | os.PathLike | pathlib.Path,model:str | os.PathLike | pathlib.Path,settings:str | os.PathLike | pathlib.Path,target:str,lookup_safety_margin:float,scales:typing.Optional[typing.Sequence[int]],scale_rebase_multiplier:typing.Sequence[int],max_logrows:typing.Optional[int]) -> typing.Any:
+    r"""
+    Calibrates the circuit settings
+    
+    Arguments
+    ---------
+    data: str
+        Path to the calibration data
+    
+    model: str
+        Path to the onnx file
+    
+    settings: str
+        Path to the settings file
+    
+    lookup_safety_margin: int
+         the lookup safety margin to use for calibration. if the max lookup is 2^k, then the max lookup will be 2^k * lookup_safety_margin. larger = safer but slower
+    
+    scales: list[int]
+        Optional scales to specifically try for calibration
+    
+    scale_rebase_multiplier: list[int]
+        Optional scale rebase multipliers to specifically try for calibration. This is the multiplier at which we divide to return to the input scale.
+    
+    max_logrows: int
+        Optional max logrows to use for calibration
+    
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def compile_circuit(model:str | os.PathLike | pathlib.Path,compiled_circuit:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path) -> bool:
+    r"""
+    Compiles the circuit for use in other steps
+    
+    Arguments
+    ---------
+    model: str
+        Path to the onnx model file
+    
+    compiled_circuit: str
+        Path to output the compiled circuit
+    
+    settings_path: str
+        Path to the settings files
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def create_evm_data_attestation(input_data:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path,sol_code_path:str | os.PathLike | pathlib.Path,abi_path:str | os.PathLike | pathlib.Path,witness_path:typing.Optional[str | os.PathLike | pathlib.Path]) -> typing.Any:
+    r"""
+    Creates an EVM compatible data attestation verifier, you will need solc installed in your environment to run this
+    
+    Arguments
+    ---------
+    input_data: str
+        The path to the .json data file, which should contain the necessary calldata and account addresses needed to read from all the on-chain view functions that return the data that the network ingests as inputs
+    
+    settings_path: str
+        The path to the settings file
+    
+    sol_code_path: str
+        The path to the create the solidity verifier
+    
+    abi_path: str
+        The path to create the ABI for the solidity verifier
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def create_evm_verifier(vk_path:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path,sol_code_path:str | os.PathLike | pathlib.Path,abi_path:str | os.PathLike | pathlib.Path,srs_path:typing.Optional[str | os.PathLike | pathlib.Path],reusable:bool) -> typing.Any:
+    r"""
+    Creates an EVM compatible verifier, you will need solc installed in your environment to run this
+    
+    Arguments
+    ---------
+    vk_path: str
+        The path to the verification key file
+    
+    settings_path: str
+        The path to the settings file
+    
+    sol_code_path: str
+        The path to the create the solidity verifier
+    
+    abi_path: str
+        The path to create the ABI for the solidity verifier
+    
+    srs_path: str
+        The path to the SRS file
+    
+    reusable: bool
+        Whether the verifier should be rendered as a reusable contract. If so, then you will need to deploy the VK artifact separately which you can generate using the create_evm_vka command
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def create_evm_verifier_aggr(aggregation_settings:typing.Sequence[str | os.PathLike | pathlib.Path],vk_path:str | os.PathLike | pathlib.Path,sol_code_path:str | os.PathLike | pathlib.Path,abi_path:str | os.PathLike | pathlib.Path,logrows:int,srs_path:typing.Optional[str | os.PathLike | pathlib.Path],reusable:bool) -> typing.Any:
+    r"""
+    Creates an evm compatible aggregate verifier, you will need solc installed in your environment to run this
+    
+    Arguments
+    ---------
+    aggregation_settings: str
+        path to the settings file
+    
+    vk_path: str
+        The path to load the desired verification key file
+    
+    sol_code_path: str
+        The path to the Solidity code
+    
+    abi_path: str
+        The path to output the Solidity verifier ABI
+    
+    logrows: int
+        Number of logrows used during aggregated setup
+    
+    srs_path: str
+        The path to the SRS file
+    
+    reusable: bool
+        Whether the verifier should be rendered as a reusable contract. If so, then you will need to deploy the VK artifact separately which you can generate using the create_evm_vka command
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def create_evm_vka(vk_path:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path,sol_code_path:str | os.PathLike | pathlib.Path,abi_path:str | os.PathLike | pathlib.Path,srs_path:typing.Optional[str | os.PathLike | pathlib.Path]) -> typing.Any:
+    r"""
+    Creates an Evm VK artifact. This command generated a VK with circuit specific meta data encoding in memory for use by the reusable H2 verifier.
+    This is useful for deploying verifier that were otherwise too big to fit on chain and required aggregation.
+    
+    Arguments
+    ---------
+    vk_path: str
+        The path to the verification key file
+    
+    settings_path: str
+        The path to the settings file
+    
+    sol_code_path: str
+        The path to the create the solidity verifying key.
+    
+    abi_path: str
+        The path to create the ABI for the solidity verifier
+    
+    srs_path: str
+        The path to the SRS file
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def deploy_da_evm(addr_path:str | os.PathLike | pathlib.Path,input_data:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path,sol_code_path:str | os.PathLike | pathlib.Path,rpc_url:typing.Optional[str],optimizer_runs:int,private_key:typing.Optional[str]) -> typing.Any:
+    r"""
+    deploys the solidity da verifier
+    """
+    ...
+
+def deploy_evm(addr_path:str | os.PathLike | pathlib.Path,sol_code_path:str | os.PathLike | pathlib.Path,rpc_url:typing.Optional[str],contract_type:str,optimizer_runs:int,private_key:typing.Optional[str]) -> typing.Any:
+    r"""
+    deploys the solidity verifier
+    """
+    ...
+
+def encode_evm_calldata(proof:str | os.PathLike | pathlib.Path,calldata:str | os.PathLike | pathlib.Path,addr_vk:typing.Optional[str]) -> list[int]:
+    r"""
+    Creates encoded evm calldata from a proof file
+    
+    Arguments
+    ---------
+    proof: str
+        Path to the proof file
+    
+    calldata: str
+       Path to the calldata file to save
+    
+    addr_vk: str
+       The address of the verification key contract (if the verifier key is to be rendered as a separate contract)
+    
+    Returns
+    -------
+    vec[u8]
+       The encoded calldata
+    """
+    ...
+
+def felt_to_big_endian(felt:str) -> str:
+    r"""
+    Converts a field element hex string to big endian
+    
+    Arguments
+    -------
+    felt: str
+        The field element represented as a string
+    
+    
+    Returns
+    -------
+    str
+        field element represented as a string
+    """
+    ...
+
+def felt_to_float(felt:str,scale:int) -> float:
+    r"""
+    Converts a field element hex string to a floating point number
+    
+    Arguments
+    -------
+    felt: str
+       The field element represented as a string
+    
+    scale: float
+        The scaling factor used to convert the field element into a floating point representation
+    
+    Returns
+    -------
+    float
+    """
+    ...
+
+def felt_to_int(felt:str) -> int:
+    r"""
+    Converts a field element hex string to an integer
+    
+    Arguments
+    -------
+    felt: str
+        The field element represented as a string
+    
+    Returns
+    -------
+    int
+    """
+    ...
+
+def float_to_felt(input:float,scale:int,input_type:PyInputType) -> str:
+    r"""
+    Converts a floating point element to a field element hex string
+    
+    Arguments
+    -------
+    input: float
+       The field element represented as a string
+    
+    scale: float
+        The scaling factor used to quantize the float into a field element
+    
+    input_type: PyInputType
+        The type of the input
+    
+    Returns
+    -------
+    str
+        The field element represented as a string
+    """
+    ...
+
+def gen_settings(model:str | os.PathLike | pathlib.Path,output:str | os.PathLike | pathlib.Path,py_run_args:typing.Optional[PyRunArgs]) -> bool:
+    r"""
+    Generates the circuit settings
+    
+    Arguments
+    ---------
+    model: str
+        Path to the onnx file
+    
+    output: str
+        Path to create the settings file
+    
+    py_run_args: PyRunArgs
+        PyRunArgs object to initialize the settings
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def gen_srs(srs_path:str | os.PathLike | pathlib.Path,logrows:int) -> None:
+    r"""
+    Generates the Structured Reference String (SRS), use this only for testing purposes
+    
+    Arguments
+    ---------
+    srs_path: str
+        Path to the create the SRS file
+    
+    logrows: int
+        The number of logrows for the SRS file
+    """
+    ...
+
+def gen_vk_from_pk_aggr(path_to_pk:str | os.PathLike | pathlib.Path,vk_output_path:str | os.PathLike | pathlib.Path) -> bool:
+    r"""
+    Generates a vk from a pk for an aggregate circuit and saves it to a file
+    
+    Arguments
+    -------
+    path_to_pk: str
+        Path to the proving key
+    
+    vk_output_path: str
+        Path to create the vk file
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def gen_vk_from_pk_single(path_to_pk:str | os.PathLike | pathlib.Path,circuit_settings_path:str | os.PathLike | pathlib.Path,vk_output_path:str | os.PathLike | pathlib.Path) -> bool:
+    r"""
+    Generates a vk from a pk for a model circuit and saves it to a file
+    
+    Arguments
+    -------
+    path_to_pk: str
+        Path to the proving key
+    
+    circuit_settings_path: str
+        Path to the witness file
+    
+    vk_output_path: str
+        Path to create the vk file
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def gen_witness(data:str | os.PathLike | pathlib.Path,model:str | os.PathLike | pathlib.Path,output:typing.Optional[str | os.PathLike | pathlib.Path],vk_path:typing.Optional[str | os.PathLike | pathlib.Path],srs_path:typing.Optional[str | os.PathLike | pathlib.Path]) -> typing.Any:
+    r"""
+    Runs the forward pass operation to generate a witness
+    
+    Arguments
+    ---------
+    data: str
+        Path to the data file
+    
+    model: str
+        Path to the compiled model file
+    
+    output: str
+        Path to create the witness file
+    
+    vk_path: str
+        Path to the verification key
+    
+    srs_path: str
+        Path to the SRS file
+    
+    Returns
+    -------
+    dict
+        Python object containing the witness values
+    """
+    ...
+
+def get_srs(settings_path:typing.Optional[str | os.PathLike | pathlib.Path],logrows:typing.Optional[int],srs_path:typing.Optional[str | os.PathLike | pathlib.Path],commitment:typing.Optional[PyCommitments]) -> typing.Any:
+    r"""
+    Gets a public srs
+    
+    Arguments
+    ---------
+    settings_path: str
+        Path to the settings file
+    
+    logrows: int
+        The number of logrows for the SRS file
+    
+    srs_path: str
+        Path to the create the SRS file
+    
+    commitment: str
+        Specify the commitment used ("kzg", "ipa")
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def ipa_commit(message:typing.Sequence[str],vk_path:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path,srs_path:typing.Optional[str | os.PathLike | pathlib.Path]) -> list[PyG1Affine]:
+    r"""
+    Generate an ipa commitment.
+    
+    Arguments
+    -------
+    message: list[str]
+        List of field elements represnted as strings
+    
+    vk_path: str
+        Path to the verification key
+    
+    settings_path: str
+        Path to the settings file
+    
+    srs_path: str
+        Path to the Structure Reference String (SRS) file
+    
+    Returns
+    -------
+    list[PyG1Affine]
+    """
+    ...
+
+def kzg_commit(message:typing.Sequence[str],vk_path:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path,srs_path:typing.Optional[str | os.PathLike | pathlib.Path]) -> list[PyG1Affine]:
+    r"""
+    Generate a kzg commitment.
+    
+    Arguments
+    -------
+    message: list[str]
+        List of field elements represnted as strings
+    
+    vk_path: str
+        Path to the verification key
+    
+    settings_path: str
+        Path to the settings file
+    
+    srs_path: str
+        Path to the Structure Reference String (SRS) file
+    
+    Returns
+    -------
+    list[PyG1Affine]
+    """
+    ...
+
+def mock(witness:str | os.PathLike | pathlib.Path,model:str | os.PathLike | pathlib.Path) -> bool:
+    r"""
+    Mocks the prover
+    
+    Arguments
+    ---------
+    witness: str
+        Path to the witness file
+    
+    model: str
+        Path to the compiled model file
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def mock_aggregate(aggregation_snarks:typing.Sequence[str | os.PathLike | pathlib.Path],logrows:int,split_proofs:bool) -> bool:
+    r"""
+    Mocks the aggregate prover
+    
+    Arguments
+    ---------
+    aggregation_snarks: list[str]
+        List of paths to the relevant proof files
+    
+    logrows: int
+        Number of logrows to use for the aggregation circuit
+    
+    split_proofs: bool
+        Indicates whether the accumulated are segments of a larger proof
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def poseidon_hash(message:typing.Sequence[str]) -> list[str]:
+    r"""
+    Generate a poseidon hash.
+    
+    Arguments
+    -------
+    message: list[str]
+        List of field elements represented as strings
+    
+    Returns
+    -------
+    list[str]
+        List of field elements represented as strings
+    """
+    ...
+
+def prove(witness:str | os.PathLike | pathlib.Path,model:str | os.PathLike | pathlib.Path,pk_path:str | os.PathLike | pathlib.Path,proof_path:typing.Optional[str | os.PathLike | pathlib.Path],proof_type:str,srs_path:typing.Optional[str | os.PathLike | pathlib.Path]) -> typing.Any:
+    r"""
+    Runs the prover on a set of inputs
+    
+    Arguments
+    ---------
+    witness: str
+        Path to the witness file
+    
+    model: str
+        Path to the compiled model file
+    
+    pk_path: str
+        Path to the proving key file
+    
+    proof_path: str
+        Path to create the proof file
+    
+    proof_type: str
+        Accepts `single`, `for-aggr`
+    
+    srs_path: str
+        Path to the SRS file
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def setup(model:str | os.PathLike | pathlib.Path,vk_path:str | os.PathLike | pathlib.Path,pk_path:str | os.PathLike | pathlib.Path,srs_path:typing.Optional[str | os.PathLike | pathlib.Path],witness_path:typing.Optional[str | os.PathLike | pathlib.Path],disable_selector_compression:bool) -> bool:
+    r"""
+    Runs the setup process
+    
+    Arguments
+    ---------
+    model: str
+        Path to the compiled model file
+    
+    vk_path: str
+        Path to create the verification key file
+    
+    pk_path: str
+        Path to create the proving key file
+    
+    srs_path: str
+        Path to the SRS file
+    
+    witness_path: str
+        Path to the witness file
+    
+    disable_selector_compression: bool
+        Whether to compress the selectors or not
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def setup_aggregate(sample_snarks:typing.Sequence[str | os.PathLike | pathlib.Path],vk_path:str | os.PathLike | pathlib.Path,pk_path:str | os.PathLike | pathlib.Path,logrows:int,split_proofs:bool,srs_path:typing.Optional[str | os.PathLike | pathlib.Path],disable_selector_compression:bool,commitment:PyCommitments) -> bool:
+    r"""
+     Runs the setup process for an aggregate setup
+    
+    Arguments
+    ---------
+    sample_snarks: list[str]
+        List of paths to the various proofs
+    
+    vk_path: str
+        Path to create the aggregated VK
+    
+    pk_path: str
+        Path to create the aggregated PK
+    
+    logrows: int
+        Number of logrows to use
+    
+    split_proofs: bool
+        Whether the accumulated are segments of a larger proof
+    
+    srs_path: str
+        Path to the SRS file
+    
+    disable_selector_compression: bool
+        Whether to compress selectors
+    
+    commitment: str
+        Accepts `kzg`, `ipa`
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def setup_test_evm_witness(data_path:str | os.PathLike | pathlib.Path,compiled_circuit_path:str | os.PathLike | pathlib.Path,test_data:str | os.PathLike | pathlib.Path,input_source:PyTestDataSource,output_source:PyTestDataSource,rpc_url:typing.Optional[str]) -> typing.Any:
+    r"""
+    Setup test evm witness
+    
+    Arguments
+    ---------
+    data_path: str
+        The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
+    
+    compiled_circuit_path: str
+        The path to the compiled model file (generated using the compile-circuit command)
+    
+    test_data: str
+        For testing purposes only. The optional path to the .json data file that will be generated that contains the OnChain data storage information derived from the file information in the data .json file. Should include both the network input (possibly private) and the network output (public input to the proof)
+    
+    input_sources: str
+        Where the input data comes from
+    
+    output_source: str
+        Where the output data comes from
+    
+    rpc_url: str
+        RPC URL for an EVM compatible node, if None, uses Anvil as a local RPC node
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def swap_proof_commitments(proof_path:str | os.PathLike | pathlib.Path,witness_path:str | os.PathLike | pathlib.Path) -> None:
+    r"""
+    Swap the commitments in a proof
+    
+    Arguments
+    -------
+    proof_path: str
+        Path to the proof file
+    
+    witness_path: str
+        Path to the witness file
+    """
+    ...
+
+def table(model:str | os.PathLike | pathlib.Path,py_run_args:typing.Optional[PyRunArgs]) -> str:
+    r"""
+    Displays the table as a string in python
+    
+    Arguments
+    ---------
+    model: str
+        Path to the onnx file
+    
+    Returns
+    ---------
+    str
+        Table of the nodes in the onnx file
+    """
+    ...
+
+def verify(proof_path:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path,vk_path:str | os.PathLike | pathlib.Path,srs_path:typing.Optional[str | os.PathLike | pathlib.Path],reduced_srs:bool) -> bool:
+    r"""
+    Verifies a given proof
+    
+    Arguments
+    ---------
+    proof_path: str
+        Path to create the proof file
+    
+    settings_path: str
+        Path to the settings file
+    
+    vk_path: str
+        Path to the verification key file
+    
+    srs_path: str
+        Path to the SRS file
+    
+    non_reduced_srs: bool
+        Whether to reduce the number of SRS logrows to the number of instances rather than the number of logrows used for proofs (only works if the srs were generated in the same ceremony)
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def verify_aggr(proof_path:str | os.PathLike | pathlib.Path,vk_path:str | os.PathLike | pathlib.Path,logrows:int,commitment:PyCommitments,reduced_srs:bool,srs_path:typing.Optional[str | os.PathLike | pathlib.Path]) -> bool:
+    r"""
+    Verifies and aggregate proof
+    
+    Arguments
+    ---------
+    proof_path: str
+         The path to the proof file
+    
+    vk_path: str
+        The path to the verification key file
+    
+    logrows: int
+        logrows used for aggregation circuit
+    
+    commitment: str
+        Accepts "kzg" or "ipa"
+    
+    reduced_srs: bool
+        Whether to reduce the number of SRS logrows to the number of instances rather than the number of logrows used for proofs (only works if the srs were generated in the same ceremony)
+    
+    srs_path: str
+        The path to the SRS file
+    
+    Returns
+    -------
+    bool
+    """
+    ...
+
+def verify_evm(addr_verifier:str,proof_path:str | os.PathLike | pathlib.Path,rpc_url:typing.Optional[str],addr_da:typing.Optional[str],addr_vk:typing.Optional[str]) -> typing.Any:
+    r"""
+    verifies an evm compatible proof, you will need solc installed in your environment to run this
+    
+    Arguments
+    ---------
+    addr_verifier: str
+        The verifier contract's address as a hex string
+    
+    proof_path: str
+        The path to the proof file (generated using the prove command)
+    
+    rpc_url: str
+        RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
+    
+    addr_da: str
+        does the verifier use data attestation ?
+    
+    addr_vk: str
+        The addess of the separate VK contract (if the verifier key is rendered as a separate contract)
+    Returns
+    -------
+    bool
+    """
+    ...
+

in-browser-evm-verifier/src/index.ts

@@ -9,7 +9,6 @@ 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,
@@ -66,7 +65,7 @@ async function verify(
     vkAddress = new Uint8Array(uint8Array.buffer);
 
     // convert uitn8array of length
-    error('vkAddress', vkAddress)
+    console.error('vkAddress', vkAddress)
   }
   const data = encodeVerifierCalldata(proof, vkAddress)
 

rust-toolchain

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2024-02-06"
+channel = "nightly-2024-07-18"
 components = ["rustfmt", "clippy"]

src/bin/ezkl.rs

@@ -1,25 +1,28 @@
 // ignore file if compiling for wasm
+#[global_allocator]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use clap::{CommandFactory, Parser};
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use colored_json::ToColoredJson;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use ezkl::commands::Cli;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use ezkl::execute::run;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use ezkl::logger::init_logger;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use log::{error, info};
 #[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
 use rand::prelude::SliceRandom;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 #[cfg(feature = "icicle")]
 use std::env;
 
 #[tokio::main(flavor = "current_thread")]
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 pub async fn main() {
     let args = Cli::parse();
 
@@ -56,7 +59,7 @@ pub async fn main() {
     }
 }
 
-#[cfg(target_arch = "wasm32")]
+#[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
 pub fn main() {}
 
 #[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]

src/bin/ios_gen_bindings.rs

@@ -0,0 +1,269 @@
+use camino::Utf8Path;
+use std::fs;
+use std::fs::remove_dir_all;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use uniffi_bindgen::bindings::SwiftBindingGenerator;
+use uniffi_bindgen::library_mode::generate_bindings;
+use uuid::Uuid;
+
+fn main() {
+    let library_name = std::env::var("CARGO_PKG_NAME").expect("CARGO_PKG_NAME is not set");
+    let mode = determine_build_mode();
+    build_bindings(&library_name, mode);
+}
+
+/// Determines the build mode based on the CONFIGURATION environment variable.
+/// Defaults to "release" if not set or unrecognized.
+/// "release" mode takes longer to build but produces optimized code, which has smaller size and is faster.
+fn determine_build_mode() -> &'static str {
+    match std::env::var("CONFIGURATION").map(|s| s.to_lowercase()) {
+        Ok(ref config) if config == "debug" => "debug",
+        _ => "release",
+    }
+}
+
+/// Builds the Swift bindings and XCFramework for the specified library and build mode.
+fn build_bindings(library_name: &str, mode: &str) {
+    // Get the root directory of this Cargo project
+    let manifest_dir = std::env::var_os("CARGO_MANIFEST_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|| std::env::current_dir().unwrap());
+
+    // Define the build directory inside the manifest directory
+    let build_dir = manifest_dir.join("build");
+
+    // Create a temporary directory to store the bindings and combined library
+    let tmp_dir = mktemp_local(&build_dir);
+
+    // Define directories for Swift bindings and output bindings
+    let swift_bindings_dir = tmp_dir.join("SwiftBindings");
+    let bindings_out = create_bindings_out_dir(&tmp_dir);
+    let framework_out = bindings_out.join("EzklCore.xcframework");
+
+    // Define target architectures for building
+    // We currently only support iOS devices and simulators running on ARM Macs
+    // This is due to limiting the library size to under 100MB for GitHub Commit Size Limit
+    // To support older Macs (Intel), follow the instructions in the comments below
+    #[allow(clippy::useless_vec)]
+    let target_archs = vec![
+        vec!["aarch64-apple-ios"], // iOS device
+        vec!["aarch64-apple-ios-sim"], // iOS simulator ARM Mac
+                                   // vec!["aarch64-apple-ios-sim", "x86_64-apple-ios"], // TODO - replace the above line with this line to allow running on older Macs (Intel)
+    ];
+
+    // Build the library for each architecture and combine them
+    let out_lib_paths: Vec<PathBuf> = target_archs
+        .iter()
+        .map(|archs| build_combined_archs(library_name, archs, &build_dir, mode))
+        .collect();
+
+    // Generate the path to the built dynamic library (.dylib)
+    let out_dylib_path = build_dir.join(format!(
+        "{}/{}/lib{}.dylib",
+        target_archs[0][0], mode, library_name
+    ));
+
+    // Generate Swift bindings using uniffi_bindgen
+    generate_ios_bindings(&out_dylib_path, &swift_bindings_dir)
+        .expect("Failed to generate iOS bindings");
+
+    // Move the generated Swift file to the bindings output directory
+    fs::rename(
+        swift_bindings_dir.join(format!("{}.swift", library_name)),
+        bindings_out.join("EzklCore.swift"),
+    )
+    .expect("Failed to copy swift bindings file");
+
+    // Rename the `ios_ezklFFI.modulemap` file to `module.modulemap`
+    fs::rename(
+        swift_bindings_dir.join(format!("{}FFI.modulemap", library_name)),
+        swift_bindings_dir.join("module.modulemap"),
+    )
+    .expect("Failed to rename modulemap file");
+
+    // Create the XCFramework from the combined libraries and Swift bindings
+    create_xcframework(&out_lib_paths, &swift_bindings_dir, &framework_out);
+
+    // Define the destination directory for the bindings
+    let bindings_dest = build_dir.join("EzklCoreBindings");
+    if bindings_dest.exists() {
+        fs::remove_dir_all(&bindings_dest).expect("Failed to remove existing bindings directory");
+    }
+
+    // Move the bindings output to the destination directory
+    fs::rename(&bindings_out, &bindings_dest).expect("Failed to move framework into place");
+
+    // Clean up temporary directories
+    cleanup_temp_dirs(&build_dir);
+}
+
+/// Creates the output directory for the bindings.
+/// Returns the path to the bindings output directory.
+fn create_bindings_out_dir(base_dir: &Path) -> PathBuf {
+    let bindings_out = base_dir.join("EzklCoreBindings");
+    fs::create_dir_all(&bindings_out).expect("Failed to create bindings output directory");
+    bindings_out
+}
+
+/// Builds the library for each architecture and combines them into a single library using lipo.
+/// Returns the path to the combined library.
+fn build_combined_archs(
+    library_name: &str,
+    archs: &[&str],
+    build_dir: &Path,
+    mode: &str,
+) -> PathBuf {
+    // Build the library for each architecture
+    let out_lib_paths: Vec<PathBuf> = archs
+        .iter()
+        .map(|&arch| {
+            build_for_arch(arch, build_dir, mode);
+            build_dir
+                .join(arch)
+                .join(mode)
+                .join(format!("lib{}.a", library_name))
+        })
+        .collect();
+
+    // Create a unique temporary directory for the combined library
+    let lib_out = mktemp_local(build_dir).join(format!("lib{}.a", library_name));
+
+    // Combine the libraries using lipo
+    let mut lipo_cmd = Command::new("lipo");
+    lipo_cmd
+        .arg("-create")
+        .arg("-output")
+        .arg(lib_out.to_str().unwrap());
+    for lib_path in &out_lib_paths {
+        lipo_cmd.arg(lib_path.to_str().unwrap());
+    }
+
+    let status = lipo_cmd.status().expect("Failed to run lipo command");
+    if !status.success() {
+        panic!("lipo command failed with status: {}", status);
+    }
+
+    lib_out
+}
+
+/// Builds the library for a specific architecture.
+fn build_for_arch(arch: &str, build_dir: &Path, mode: &str) {
+    // Ensure the target architecture is installed
+    install_arch(arch);
+
+    // Run cargo build for the specified architecture and mode
+    let mut build_cmd = Command::new("cargo");
+    build_cmd
+        .arg("build")
+        .arg("--no-default-features")
+        .arg("--features")
+        .arg("ios-bindings");
+
+    if mode == "release" {
+        build_cmd.arg("--release");
+    }
+    build_cmd
+        .arg("--lib")
+        .env("CARGO_BUILD_TARGET_DIR", build_dir)
+        .env("CARGO_BUILD_TARGET", arch);
+
+    let status = build_cmd.status().expect("Failed to run cargo build");
+    if !status.success() {
+        panic!("cargo build failed for architecture: {}", arch);
+    }
+}
+
+/// Installs the specified target architecture using rustup.
+fn install_arch(arch: &str) {
+    let status = Command::new("rustup")
+        .arg("target")
+        .arg("add")
+        .arg(arch)
+        .status()
+        .expect("Failed to run rustup command");
+
+    if !status.success() {
+        panic!("Failed to install target architecture: {}", arch);
+    }
+}
+
+/// Generates Swift bindings for the iOS library using uniffi_bindgen.
+fn generate_ios_bindings(dylib_path: &Path, binding_dir: &Path) -> Result<(), std::io::Error> {
+    // Remove existing binding directory if it exists
+    if binding_dir.exists() {
+        remove_dir_all(binding_dir)?;
+    }
+
+    // Generate the Swift bindings using uniffi_bindgen
+    generate_bindings(
+        Utf8Path::from_path(dylib_path).ok_or_else(|| {
+            std::io::Error::new(std::io::ErrorKind::InvalidInput, "Invalid dylib path")
+        })?,
+        None,
+        &SwiftBindingGenerator,
+        None,
+        Utf8Path::from_path(binding_dir).ok_or_else(|| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "Invalid Swift bindings directory",
+            )
+        })?,
+        true,
+    )
+    .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e.to_string()))?;
+
+    Ok(())
+}
+
+/// Creates an XCFramework from the combined libraries and Swift bindings.
+fn create_xcframework(lib_paths: &[PathBuf], swift_bindings_dir: &Path, framework_out: &Path) {
+    let mut xcbuild_cmd = Command::new("xcodebuild");
+    xcbuild_cmd.arg("-create-xcframework");
+
+    // Add each library and its corresponding headers to the xcodebuild command
+    for lib_path in lib_paths {
+        println!("Including library: {:?}", lib_path);
+        xcbuild_cmd.arg("-library");
+        xcbuild_cmd.arg(lib_path.to_str().unwrap());
+        xcbuild_cmd.arg("-headers");
+        xcbuild_cmd.arg(swift_bindings_dir.to_str().unwrap());
+    }
+
+    xcbuild_cmd.arg("-output");
+    xcbuild_cmd.arg(framework_out.to_str().unwrap());
+
+    let status = xcbuild_cmd.status().expect("Failed to run xcodebuild");
+    if !status.success() {
+        panic!("xcodebuild failed with status: {}", status);
+    }
+}
+
+/// Creates a temporary directory inside the build path with a unique UUID.
+/// This ensures unique build artifacts for concurrent builds.
+fn mktemp_local(build_path: &Path) -> PathBuf {
+    let dir = tmp_local(build_path).join(Uuid::new_v4().to_string());
+    fs::create_dir(&dir).expect("Failed to create temporary directory");
+    dir
+}
+
+/// Gets the path to the local temporary directory inside the build path.
+fn tmp_local(build_path: &Path) -> PathBuf {
+    let tmp_path = build_path.join("tmp");
+    if let Ok(metadata) = fs::metadata(&tmp_path) {
+        if !metadata.is_dir() {
+            panic!("Expected 'tmp' to be a directory");
+        }
+    } else {
+        fs::create_dir_all(&tmp_path).expect("Failed to create local temporary directory");
+    }
+    tmp_path
+}
+
+/// Cleans up temporary directories inside the build path.
+fn cleanup_temp_dirs(build_dir: &Path) {
+    let tmp_dir = build_dir.join("tmp");
+    if tmp_dir.exists() {
+        fs::remove_dir_all(tmp_dir).expect("Failed to remove temporary directories");
+    }
+}

src/bin/py_stub_gen.rs

@@ -0,0 +1,9 @@
+use pyo3_stub_gen::Result;
+
+fn main() -> Result<()> {
+    // `stub_info` is a function defined by `define_stub_info_gatherer!` macro.
+    env_logger::Builder::from_env(env_logger::Env::default().filter_or("RUST_LOG", "info")).init();
+    let stub = ezkl::bindings::python::stub_info()?;
+    stub.generate()?;
+    Ok(())
+}

src/bindings/mod.rs

@@ -0,0 +1,12 @@
+/// Python bindings
+#[cfg(feature = "python-bindings")]
+pub mod python;
+/// Universal bindings for all platforms
+#[cfg(any(
+    feature = "ios-bindings",
+    all(target_arch = "wasm32", target_os = "unknown")
+))]
+pub mod universal;
+/// wasm prover and verifier
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+pub mod wasm;

src/bindings/python.rs

@@ -4,9 +4,10 @@ use crate::circuit::modules::poseidon::{
     PoseidonChip,
 };
 use crate::circuit::modules::Module;
+use crate::circuit::InputType;
 use crate::circuit::{CheckMode, Tolerance};
 use crate::commands::*;
-use crate::fieldutils::{felt_to_i64, i64_to_felt};
+use crate::fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep};
 use crate::graph::modules::POSEIDON_LEN_GRAPH;
 use crate::graph::TestDataSource;
 use crate::graph::{
@@ -26,7 +27,12 @@ use pyo3::exceptions::{PyIOError, PyRuntimeError};
 use pyo3::prelude::*;
 use pyo3::wrap_pyfunction;
 use pyo3_log;
+use pyo3_stub_gen::{
+    define_stub_info_gatherer, derive::gen_stub_pyclass, derive::gen_stub_pyclass_enum,
+    derive::gen_stub_pyfunction, TypeInfo,
+};
 use snark_verifier::util::arithmetic::PrimeField;
+use std::collections::HashSet;
 use std::str::FromStr;
 use std::{fs::File, path::PathBuf};
 
@@ -35,6 +41,7 @@ type PyFelt = String;
 /// pyclass representing an enum
 #[pyclass]
 #[derive(Debug, Clone)]
+#[gen_stub_pyclass_enum]
 enum PyTestDataSource {
     /// The data is loaded from a file
     File,
@@ -54,6 +61,7 @@ impl From<PyTestDataSource> for TestDataSource {
 /// pyclass containing the struct used for G1, this is mostly a helper class
 #[pyclass]
 #[derive(Debug, Clone)]
+#[gen_stub_pyclass]
 struct PyG1 {
     #[pyo3(get, set)]
     /// Field Element representing x
@@ -100,6 +108,7 @@ impl pyo3::ToPyObject for PyG1 {
 /// pyclass containing the struct used for G1
 #[pyclass]
 #[derive(Debug, Clone)]
+#[gen_stub_pyclass]
 pub struct PyG1Affine {
     #[pyo3(get, set)]
     ///
@@ -145,6 +154,7 @@ impl pyo3::ToPyObject for PyG1Affine {
 ///
 #[pyclass]
 #[derive(Clone)]
+#[gen_stub_pyclass]
 struct PyRunArgs {
     #[pyo3(get, set)]
     /// float: The tolerance for error on model outputs
@@ -180,9 +190,6 @@ struct PyRunArgs {
     /// list[tuple[str, int]]: Hand-written parser for graph variables, eg. batch_size=1
     pub variables: Vec<(String, usize)>,
     #[pyo3(get, set)]
-    /// bool: Rebase the scale using lookup table for division instead of using a range check
-    pub div_rebasing: bool,
-    #[pyo3(get, set)]
     /// bool: Should constants with 0.0 fraction be rebased to scale 0
     pub rebase_frac_zero_constants: bool,
     #[pyo3(get, set)]
@@ -191,6 +198,15 @@ struct PyRunArgs {
     #[pyo3(get, set)]
     /// str: commitment type, accepts `kzg`, `ipa`
     pub commitment: PyCommitments,
+    /// int: The base used for decomposition
+    #[pyo3(get, set)]
+    pub decomp_base: usize,
+    /// int: The number of legs used for decomposition
+    #[pyo3(get, set)]
+    pub decomp_legs: usize,
+    /// bool: Should the circuit use unbounded lookups for log
+    #[pyo3(get, set)]
+    pub bounded_log_lookup: bool,
 }
 
 /// default instantiation of PyRunArgs
@@ -206,6 +222,7 @@ impl PyRunArgs {
 impl From<PyRunArgs> for RunArgs {
     fn from(py_run_args: PyRunArgs) -> Self {
         RunArgs {
+            bounded_log_lookup: py_run_args.bounded_log_lookup,
             tolerance: Tolerance::from(py_run_args.tolerance),
             input_scale: py_run_args.input_scale,
             param_scale: py_run_args.param_scale,
@@ -217,10 +234,11 @@ impl From<PyRunArgs> for RunArgs {
             output_visibility: py_run_args.output_visibility,
             param_visibility: py_run_args.param_visibility,
             variables: py_run_args.variables,
-            div_rebasing: py_run_args.div_rebasing,
             rebase_frac_zero_constants: py_run_args.rebase_frac_zero_constants,
             check_mode: py_run_args.check_mode,
             commitment: Some(py_run_args.commitment.into()),
+            decomp_base: py_run_args.decomp_base,
+            decomp_legs: py_run_args.decomp_legs,
         }
     }
 }
@@ -228,6 +246,7 @@ impl From<PyRunArgs> for RunArgs {
 impl Into<PyRunArgs> for RunArgs {
     fn into(self) -> PyRunArgs {
         PyRunArgs {
+            bounded_log_lookup: self.bounded_log_lookup,
             tolerance: self.tolerance.val,
             input_scale: self.input_scale,
             param_scale: self.param_scale,
@@ -239,16 +258,18 @@ impl Into<PyRunArgs> for RunArgs {
             output_visibility: self.output_visibility,
             param_visibility: self.param_visibility,
             variables: self.variables,
-            div_rebasing: self.div_rebasing,
             rebase_frac_zero_constants: self.rebase_frac_zero_constants,
             check_mode: self.check_mode,
             commitment: self.commitment.into(),
+            decomp_base: self.decomp_base,
+            decomp_legs: self.decomp_legs,
         }
     }
 }
 
 #[pyclass]
 #[derive(Debug, Clone)]
+#[gen_stub_pyclass_enum]
 /// pyclass representing an enum, denoting the type of commitment
 pub enum PyCommitments {
     /// KZG commitment
@@ -296,6 +317,65 @@ impl FromStr for PyCommitments {
     }
 }
 
+#[pyclass]
+#[derive(Debug, Clone)]
+#[gen_stub_pyclass_enum]
+enum PyInputType {
+    ///
+    Bool,
+    ///
+    F16,
+    ///
+    F32,
+    ///
+    F64,
+    ///
+    Int,
+    ///
+    TDim,
+}
+
+impl From<InputType> for PyInputType {
+    fn from(input_type: InputType) -> Self {
+        match input_type {
+            InputType::Bool => PyInputType::Bool,
+            InputType::F16 => PyInputType::F16,
+            InputType::F32 => PyInputType::F32,
+            InputType::F64 => PyInputType::F64,
+            InputType::Int => PyInputType::Int,
+            InputType::TDim => PyInputType::TDim,
+        }
+    }
+}
+
+impl From<PyInputType> for InputType {
+    fn from(py_input_type: PyInputType) -> Self {
+        match py_input_type {
+            PyInputType::Bool => InputType::Bool,
+            PyInputType::F16 => InputType::F16,
+            PyInputType::F32 => InputType::F32,
+            PyInputType::F64 => InputType::F64,
+            PyInputType::Int => InputType::Int,
+            PyInputType::TDim => InputType::TDim,
+        }
+    }
+}
+
+impl FromStr for PyInputType {
+    type Err = String;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "bool" => Ok(PyInputType::Bool),
+            "f16" => Ok(PyInputType::F16),
+            "f32" => Ok(PyInputType::F32),
+            "f64" => Ok(PyInputType::F64),
+            "int" => Ok(PyInputType::Int),
+            "tdim" => Ok(PyInputType::TDim),
+            _ => Err("Invalid value for InputType".to_string()),
+        }
+    }
+}
+
 /// Converts a field element hex string to big endian
 ///
 /// Arguments
@@ -312,6 +392,7 @@ impl FromStr for PyCommitments {
 #[pyfunction(signature = (
     felt,
 ))]
+#[gen_stub_pyfunction]
 fn felt_to_big_endian(felt: PyFelt) -> PyResult<String> {
     let felt = crate::pfsys::string_to_field::<Fr>(&felt);
     Ok(format!("{:?}", felt))
@@ -331,9 +412,10 @@ fn felt_to_big_endian(felt: PyFelt) -> PyResult<String> {
 #[pyfunction(signature = (
     felt,
 ))]
-fn felt_to_int(felt: PyFelt) -> PyResult<i64> {
+#[gen_stub_pyfunction]
+fn felt_to_int(felt: PyFelt) -> PyResult<IntegerRep> {
     let felt = crate::pfsys::string_to_field::<Fr>(&felt);
-    let int_rep = felt_to_i64(felt);
+    let int_rep = felt_to_integer_rep(felt);
     Ok(int_rep)
 }
 
@@ -355,9 +437,10 @@ fn felt_to_int(felt: PyFelt) -> PyResult<i64> {
     felt,
     scale
 ))]
+#[gen_stub_pyfunction]
 fn felt_to_float(felt: PyFelt, scale: crate::Scale) -> PyResult<f64> {
     let felt = crate::pfsys::string_to_field::<Fr>(&felt);
-    let int_rep = felt_to_i64(felt);
+    let int_rep = felt_to_integer_rep(felt);
     let multiplier = scale_to_multiplier(scale);
     let float_rep = int_rep as f64 / multiplier;
     Ok(float_rep)
@@ -373,6 +456,9 @@ fn felt_to_float(felt: PyFelt, scale: crate::Scale) -> PyResult<f64> {
 /// scale: float
 ///     The scaling factor used to quantize the float into a field element
 ///
+/// input_type: PyInputType
+///     The type of the input
+///
 /// Returns
 /// -------
 /// str
@@ -380,12 +466,15 @@ fn felt_to_float(felt: PyFelt, scale: crate::Scale) -> PyResult<f64> {
 ///
 #[pyfunction(signature = (
     input,
-    scale
+    scale,
+    input_type=PyInputType::F64
 ))]
-fn float_to_felt(input: f64, scale: crate::Scale) -> PyResult<PyFelt> {
+#[gen_stub_pyfunction]
+fn float_to_felt(mut input: f64, scale: crate::Scale, input_type: PyInputType) -> PyResult<PyFelt> {
+    InputType::roundtrip(&input_type.into(), &mut input);
     let int_rep = quantize_float(&input, 0.0, scale)
         .map_err(|_| PyIOError::new_err("Failed to quantize input"))?;
-    let felt = i64_to_felt(int_rep);
+    let felt = integer_rep_to_felt(int_rep);
     Ok(crate::pfsys::field_to_string::<Fr>(&felt))
 }
 
@@ -404,6 +493,7 @@ fn float_to_felt(input: f64, scale: crate::Scale) -> PyResult<PyFelt> {
 #[pyfunction(signature = (
     buffer
 ))]
+#[gen_stub_pyfunction]
 fn buffer_to_felts(buffer: Vec<u8>) -> PyResult<Vec<String>> {
     fn u8_array_to_u128_le(arr: [u8; 16]) -> u128 {
         let mut n: u128 = 0;
@@ -476,6 +566,7 @@ fn buffer_to_felts(buffer: Vec<u8>) -> PyResult<Vec<String>> {
 #[pyfunction(signature = (
     message,
 ))]
+#[gen_stub_pyfunction]
 fn poseidon_hash(message: Vec<PyFelt>) -> PyResult<Vec<PyFelt>> {
     let message: Vec<Fr> = message
         .iter()
@@ -521,6 +612,7 @@ fn poseidon_hash(message: Vec<PyFelt>) -> PyResult<Vec<PyFelt>> {
     settings_path=PathBuf::from(DEFAULT_SETTINGS),
     srs_path=None
 ))]
+#[gen_stub_pyfunction]
 fn kzg_commit(
     message: Vec<PyFelt>,
     vk_path: PathBuf,
@@ -579,6 +671,7 @@ fn kzg_commit(
     settings_path=PathBuf::from(DEFAULT_SETTINGS),
     srs_path=None
 ))]
+#[gen_stub_pyfunction]
 fn ipa_commit(
     message: Vec<PyFelt>,
     vk_path: PathBuf,
@@ -625,6 +718,7 @@ fn ipa_commit(
     proof_path=PathBuf::from(DEFAULT_PROOF),
     witness_path=PathBuf::from(DEFAULT_WITNESS),
 ))]
+#[gen_stub_pyfunction]
 fn swap_proof_commitments(proof_path: PathBuf, witness_path: PathBuf) -> PyResult<()> {
     crate::execute::swap_proof_commitments_cmd(proof_path, witness_path)
         .map_err(|_| PyIOError::new_err("Failed to swap commitments"))?;
@@ -654,6 +748,7 @@ fn swap_proof_commitments(proof_path: PathBuf, witness_path: PathBuf) -> PyResul
     circuit_settings_path=PathBuf::from(DEFAULT_SETTINGS),
     vk_output_path=PathBuf::from(DEFAULT_VK),
 ))]
+#[gen_stub_pyfunction]
 fn gen_vk_from_pk_single(
     path_to_pk: PathBuf,
     circuit_settings_path: PathBuf,
@@ -691,6 +786,7 @@ fn gen_vk_from_pk_single(
     path_to_pk=PathBuf::from(DEFAULT_PK_AGGREGATED),
     vk_output_path=PathBuf::from(DEFAULT_VK_AGGREGATED),
 ))]
+#[gen_stub_pyfunction]
 fn gen_vk_from_pk_aggr(path_to_pk: PathBuf, vk_output_path: PathBuf) -> PyResult<bool> {
     let pk = load_pk::<KZGCommitmentScheme<Bn256>, AggregationCircuit>(path_to_pk, ())
         .map_err(|_| PyIOError::new_err("Failed to load pk"))?;
@@ -720,6 +816,7 @@ fn gen_vk_from_pk_aggr(path_to_pk: PathBuf, vk_output_path: PathBuf) -> PyResult
     model = PathBuf::from(DEFAULT_MODEL),
     py_run_args = None
 ))]
+#[gen_stub_pyfunction]
 fn table(model: PathBuf, py_run_args: Option<PyRunArgs>) -> PyResult<String> {
     let run_args: RunArgs = py_run_args.unwrap_or_else(PyRunArgs::new).into();
     let mut reader = File::open(model).map_err(|_| PyIOError::new_err("Failed to open model"))?;
@@ -745,6 +842,7 @@ fn table(model: PathBuf, py_run_args: Option<PyRunArgs>) -> PyResult<String> {
     srs_path,
     logrows,
 ))]
+#[gen_stub_pyfunction]
 fn gen_srs(srs_path: PathBuf, logrows: usize) -> PyResult<()> {
     let params = ezkl_gen_srs::<KZGCommitmentScheme<Bn256>>(logrows as u32);
     save_params::<KZGCommitmentScheme<Bn256>>(&srs_path, &params)?;
@@ -777,6 +875,7 @@ fn gen_srs(srs_path: PathBuf, logrows: usize) -> PyResult<()> {
     srs_path=None,
     commitment=None,
 ))]
+#[gen_stub_pyfunction]
 fn get_srs(
     py: Python,
     settings_path: Option<PathBuf>,
@@ -789,7 +888,7 @@ fn get_srs(
         None => None,
     };
 
-    pyo3_asyncio::tokio::future_into_py(py, async move {
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
         crate::execute::get_srs_cmd(srs_path, settings_path, logrows, commitment)
             .await
             .map_err(|e| {
@@ -823,6 +922,7 @@ fn get_srs(
     output=PathBuf::from(DEFAULT_SETTINGS),
     py_run_args = None,
 ))]
+#[gen_stub_pyfunction]
 fn gen_settings(
     model: PathBuf,
     output: PathBuf,
@@ -863,8 +963,6 @@ fn gen_settings(
 /// max_logrows: int
 ///     Optional max logrows to use for calibration
 ///
-/// only_range_check_rebase: bool
-///     Check ranges when rebasing
 ///
 /// Returns
 /// -------
@@ -879,8 +977,8 @@ fn gen_settings(
     scales = None,
     scale_rebase_multiplier = DEFAULT_SCALE_REBASE_MULTIPLIERS.split(",").map(|x| x.parse().unwrap()).collect(),
     max_logrows = None,
-    only_range_check_rebase = DEFAULT_ONLY_RANGE_CHECK_REBASE.parse().unwrap(),
 ))]
+#[gen_stub_pyfunction]
 fn calibrate_settings(
     py: Python,
     data: PathBuf,
@@ -891,9 +989,8 @@ fn calibrate_settings(
     scales: Option<Vec<crate::Scale>>,
     scale_rebase_multiplier: Vec<u32>,
     max_logrows: Option<u32>,
-    only_range_check_rebase: bool,
 ) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_asyncio::tokio::future_into_py(py, async move {
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
         crate::execute::calibrate(
             model,
             data,
@@ -902,7 +999,6 @@ fn calibrate_settings(
             lookup_safety_margin,
             scales,
             scale_rebase_multiplier,
-            only_range_check_rebase,
             max_logrows,
         )
         .await
@@ -946,6 +1042,7 @@ fn calibrate_settings(
     vk_path=None,
     srs_path=None,
 ))]
+#[gen_stub_pyfunction]
 fn gen_witness(
     py: Python,
     data: PathBuf,
@@ -954,7 +1051,7 @@ fn gen_witness(
     vk_path: Option<PathBuf>,
     srs_path: Option<PathBuf>,
 ) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_asyncio::tokio::future_into_py(py, async move {
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
         let output = crate::execute::gen_witness(model, data, output, vk_path, srs_path)
             .await
             .map_err(|e| {
@@ -983,6 +1080,7 @@ fn gen_witness(
     witness=PathBuf::from(DEFAULT_WITNESS),
     model=PathBuf::from(DEFAULT_COMPILED_CIRCUIT),
 ))]
+#[gen_stub_pyfunction]
 fn mock(witness: PathBuf, model: PathBuf) -> PyResult<bool> {
     crate::execute::mock(model, witness).map_err(|e| {
         let err_str = format!("Failed to run mock: {}", e);
@@ -1013,6 +1111,7 @@ fn mock(witness: PathBuf, model: PathBuf) -> PyResult<bool> {
     logrows=DEFAULT_AGGREGATED_LOGROWS.parse().unwrap(),
     split_proofs = false,
 ))]
+#[gen_stub_pyfunction]
 fn mock_aggregate(
     aggregation_snarks: Vec<PathBuf>,
     logrows: u32,
@@ -1060,6 +1159,7 @@ fn mock_aggregate(
     witness_path = None,
     disable_selector_compression=DEFAULT_DISABLE_SELECTOR_COMPRESSION.parse().unwrap(),
 ))]
+#[gen_stub_pyfunction]
 fn setup(
     model: PathBuf,
     vk_path: PathBuf,
@@ -1118,6 +1218,7 @@ fn setup(
     proof_type=ProofType::default(),
     srs_path=None,
 ))]
+#[gen_stub_pyfunction]
 fn prove(
     witness: PathBuf,
     model: PathBuf,
@@ -1173,6 +1274,7 @@ fn prove(
     srs_path=None,
     reduced_srs=DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION.parse::<bool>().unwrap(),
 ))]
+#[gen_stub_pyfunction]
 fn verify(
     proof_path: PathBuf,
     settings_path: PathBuf,
@@ -1232,6 +1334,7 @@ fn verify(
     disable_selector_compression=DEFAULT_DISABLE_SELECTOR_COMPRESSION.parse().unwrap(),
     commitment=DEFAULT_COMMITMENT.parse().unwrap(),
 ))]
+#[gen_stub_pyfunction]
 fn setup_aggregate(
     sample_snarks: Vec<PathBuf>,
     vk_path: PathBuf,
@@ -1282,6 +1385,7 @@ fn setup_aggregate(
     compiled_circuit=PathBuf::from(DEFAULT_COMPILED_CIRCUIT),
     settings_path=PathBuf::from(DEFAULT_SETTINGS),
 ))]
+#[gen_stub_pyfunction]
 fn compile_circuit(
     model: PathBuf,
     compiled_circuit: PathBuf,
@@ -1341,6 +1445,7 @@ fn compile_circuit(
     srs_path=None,
     commitment=DEFAULT_COMMITMENT.parse().unwrap(),
 ))]
+#[gen_stub_pyfunction]
 fn aggregate(
     aggregation_snarks: Vec<PathBuf>,
     proof_path: PathBuf,
@@ -1406,6 +1511,7 @@ fn aggregate(
     reduced_srs=DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION.parse().unwrap(),
     srs_path=None,
 ))]
+#[gen_stub_pyfunction]
 fn verify_aggr(
     proof_path: PathBuf,
     vk_path: PathBuf,
@@ -1453,6 +1559,7 @@ fn verify_aggr(
     calldata=PathBuf::from(DEFAULT_CALLDATA),
     addr_vk=None,
 ))]
+#[gen_stub_pyfunction]
 fn encode_evm_calldata<'a>(
     proof: PathBuf,
     calldata: PathBuf,
@@ -1490,8 +1597,8 @@ fn encode_evm_calldata<'a>(
 /// srs_path: str
 ///     The path to the SRS file
 ///
-/// render_vk_separately: bool
-///     Whether the verifier key should be rendered as a separate contract. We recommend disabling selector compression if this is enabled. To save the verifier key as a separate contract, set this to true and then call the create_evm_vk command
+/// reusable: bool
+///     Whether the verifier should be rendered as a reusable contract. If so, then you will need to deploy the VK artifact separately which you can generate using the create_evm_vka command
 ///
 /// Returns
 /// -------
@@ -1503,8 +1610,9 @@ fn encode_evm_calldata<'a>(
     sol_code_path=PathBuf::from(DEFAULT_SOL_CODE),
     abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
     srs_path=None,
-    render_vk_seperately = DEFAULT_RENDER_VK_SEPERATELY.parse().unwrap(),
+    reusable = DEFAULT_RENDER_REUSABLE.parse().unwrap(),
 ))]
+#[gen_stub_pyfunction]
 fn create_evm_verifier(
     py: Python,
     vk_path: PathBuf,
@@ -1512,16 +1620,16 @@ fn create_evm_verifier(
     sol_code_path: PathBuf,
     abi_path: PathBuf,
     srs_path: Option<PathBuf>,
-    render_vk_seperately: bool,
+    reusable: bool,
 ) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_asyncio::tokio::future_into_py(py, async move {
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
         crate::execute::create_evm_verifier(
             vk_path,
             srs_path,
             settings_path,
             sol_code_path,
             abi_path,
-            render_vk_seperately,
+            reusable,
         )
         .await
         .map_err(|e| {
@@ -1533,7 +1641,8 @@ fn create_evm_verifier(
     })
 }
 
-/// Creates an Evm verifer key. This command should be called after create_evm_verifier with the render_vk_separately arg set to true. By rendering a verification key separately you can reuse the same verifier for similar circuit setups with different verifying keys, helping to reduce the amount of state our verifiers store on the blockchain.
+/// Creates an Evm VK artifact. This command generated a VK with circuit specific meta data encoding in memory for use by the reusable H2 verifier.
+/// This is useful for deploying verifier that were otherwise too big to fit on chain and required aggregation.
 ///
 /// Arguments
 /// ---------
@@ -1563,7 +1672,8 @@ fn create_evm_verifier(
     abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
     srs_path=None
 ))]
-fn create_evm_vk(
+#[gen_stub_pyfunction]
+fn create_evm_vka(
     py: Python,
     vk_path: PathBuf,
     settings_path: PathBuf,
@@ -1571,8 +1681,8 @@ fn create_evm_vk(
     abi_path: PathBuf,
     srs_path: Option<PathBuf>,
 ) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_asyncio::tokio::future_into_py(py, async move {
-        crate::execute::create_evm_vk(vk_path, srs_path, settings_path, sol_code_path, abi_path)
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
+        crate::execute::create_evm_vka(vk_path, srs_path, settings_path, sol_code_path, abi_path)
             .await
             .map_err(|e| {
                 let err_str = format!("Failed to run create_evm_verifier: {}", e);
@@ -1610,6 +1720,7 @@ fn create_evm_vk(
     abi_path=PathBuf::from(DEFAULT_VERIFIER_DA_ABI),
     witness_path=None,
 ))]
+#[gen_stub_pyfunction]
 fn create_evm_data_attestation(
     py: Python,
     input_data: PathBuf,
@@ -1618,7 +1729,7 @@ fn create_evm_data_attestation(
     abi_path: PathBuf,
     witness_path: Option<PathBuf>,
 ) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_asyncio::tokio::future_into_py(py, async move {
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
         crate::execute::create_evm_data_attestation(
             settings_path,
             sol_code_path,
@@ -1670,6 +1781,7 @@ fn create_evm_data_attestation(
     output_source,
     rpc_url=None,
 ))]
+#[gen_stub_pyfunction]
 fn setup_test_evm_witness(
     py: Python,
     data_path: PathBuf,
@@ -1679,7 +1791,7 @@ fn setup_test_evm_witness(
     output_source: PyTestDataSource,
     rpc_url: Option<String>,
 ) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_asyncio::tokio::future_into_py(py, async move {
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
         crate::execute::setup_test_evm_witness(
             data_path,
             compiled_circuit_path,
@@ -1703,60 +1815,28 @@ fn setup_test_evm_witness(
     addr_path,
     sol_code_path=PathBuf::from(DEFAULT_SOL_CODE),
     rpc_url=None,
+    contract_type=ContractType::default(),
     optimizer_runs=DEFAULT_OPTIMIZER_RUNS.parse().unwrap(),
     private_key=None,
 ))]
+#[gen_stub_pyfunction]
 fn deploy_evm(
     py: Python,
     addr_path: PathBuf,
     sol_code_path: PathBuf,
     rpc_url: Option<String>,
+    contract_type: ContractType,
     optimizer_runs: usize,
     private_key: Option<String>,
 ) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_asyncio::tokio::future_into_py(py, async move {
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
         crate::execute::deploy_evm(
             sol_code_path,
             rpc_url,
             addr_path,
             optimizer_runs,
             private_key,
-            "Halo2Verifier",
-        )
-        .await
-        .map_err(|e| {
-            let err_str = format!("Failed to run deploy_evm: {}", e);
-            PyRuntimeError::new_err(err_str)
-        })?;
-
-        Ok(true)
-    })
-}
-
-/// deploys the solidity vk verifier
-#[pyfunction(signature = (
-    addr_path,
-    sol_code_path=PathBuf::from(DEFAULT_VK_SOL),
-    rpc_url=None,
-    optimizer_runs=DEFAULT_OPTIMIZER_RUNS.parse().unwrap(),
-    private_key=None,
-))]
-fn deploy_vk_evm(
-    py: Python,
-    addr_path: PathBuf,
-    sol_code_path: PathBuf,
-    rpc_url: Option<String>,
-    optimizer_runs: usize,
-    private_key: Option<String>,
-) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_asyncio::tokio::future_into_py(py, async move {
-        crate::execute::deploy_evm(
-            sol_code_path,
-            rpc_url,
-            addr_path,
-            optimizer_runs,
-            private_key,
-            "Halo2VerifyingKey",
+            contract_type,
         )
         .await
         .map_err(|e| {
@@ -1778,6 +1858,7 @@ fn deploy_vk_evm(
     optimizer_runs=DEFAULT_OPTIMIZER_RUNS.parse().unwrap(),
     private_key=None
 ))]
+#[gen_stub_pyfunction]
 fn deploy_da_evm(
     py: Python,
     addr_path: PathBuf,
@@ -1788,7 +1869,7 @@ fn deploy_da_evm(
     optimizer_runs: usize,
     private_key: Option<String>,
 ) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_asyncio::tokio::future_into_py(py, async move {
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
         crate::execute::deploy_da_evm(
             input_data,
             settings_path,
@@ -1836,6 +1917,7 @@ fn deploy_da_evm(
     addr_da = None,
     addr_vk = None,
 ))]
+#[gen_stub_pyfunction]
 fn verify_evm<'a>(
     py: Python<'a>,
     addr_verifier: &'a str,
@@ -1858,7 +1940,7 @@ fn verify_evm<'a>(
         None
     };
 
-    pyo3_asyncio::tokio::future_into_py(py, async move {
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
         crate::execute::verify_evm(proof_path, addr_verifier, rpc_url, addr_da, addr_vk)
             .await
             .map_err(|e| {
@@ -1892,8 +1974,8 @@ fn verify_evm<'a>(
 /// srs_path: str
 ///     The path to the SRS file
 ///
-/// render_vk_separately: bool
-///     Whether the verifier key should be rendered as a separate contract. We recommend disabling selector compression if this is enabled. To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command
+/// reusable: bool
+///     Whether the verifier should be rendered as a reusable contract. If so, then you will need to deploy the VK artifact separately which you can generate using the create_evm_vka command
 ///
 /// Returns
 /// -------
@@ -1906,8 +1988,9 @@ fn verify_evm<'a>(
     abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
     logrows=DEFAULT_AGGREGATED_LOGROWS.parse().unwrap(),
     srs_path=None,
-    render_vk_seperately = DEFAULT_RENDER_VK_SEPERATELY.parse().unwrap(),
+    reusable = DEFAULT_RENDER_REUSABLE.parse().unwrap(),
 ))]
+#[gen_stub_pyfunction]
 fn create_evm_verifier_aggr(
     py: Python,
     aggregation_settings: Vec<PathBuf>,
@@ -1916,9 +1999,9 @@ fn create_evm_verifier_aggr(
     abi_path: PathBuf,
     logrows: u32,
     srs_path: Option<PathBuf>,
-    render_vk_seperately: bool,
+    reusable: bool,
 ) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_asyncio::tokio::future_into_py(py, async move {
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
         crate::execute::create_evm_aggregate_verifier(
             vk_path,
             srs_path,
@@ -1926,7 +2009,7 @@ fn create_evm_verifier_aggr(
             abi_path,
             aggregation_settings,
             logrows,
-            render_vk_seperately,
+            reusable,
         )
         .await
         .map_err(|e| {
@@ -1938,15 +2021,19 @@ fn create_evm_verifier_aggr(
     })
 }
 
+// Define a function to gather stub information.
+define_stub_info_gatherer!(stub_info);
+
 // Python Module
 #[pymodule]
-fn ezkl(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+fn ezkl(m: &Bound<'_, PyModule>) -> PyResult<()> {
     pyo3_log::init();
     m.add_class::<PyRunArgs>()?;
     m.add_class::<PyG1Affine>()?;
     m.add_class::<PyG1>()?;
     m.add_class::<PyTestDataSource>()?;
     m.add_class::<PyCommitments>()?;
+    m.add_class::<PyInputType>()?;
     m.add("__version__", env!("CARGO_PKG_VERSION"))?;
     m.add_function(wrap_pyfunction!(felt_to_big_endian, m)?)?;
     m.add_function(wrap_pyfunction!(felt_to_int, m)?)?;
@@ -1975,9 +2062,8 @@ fn ezkl(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(compile_circuit, m)?)?;
     m.add_function(wrap_pyfunction!(verify_aggr, m)?)?;
     m.add_function(wrap_pyfunction!(create_evm_verifier, m)?)?;
-    m.add_function(wrap_pyfunction!(create_evm_vk, m)?)?;
+    m.add_function(wrap_pyfunction!(create_evm_vka, m)?)?;
     m.add_function(wrap_pyfunction!(deploy_evm, m)?)?;
-    m.add_function(wrap_pyfunction!(deploy_vk_evm, m)?)?;
     m.add_function(wrap_pyfunction!(deploy_da_evm, m)?)?;
     m.add_function(wrap_pyfunction!(verify_evm, m)?)?;
     m.add_function(wrap_pyfunction!(setup_test_evm_witness, m)?)?;
@@ -1986,3 +2072,48 @@ fn ezkl(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(encode_evm_calldata, m)?)?;
     Ok(())
 }
+
+impl pyo3_stub_gen::PyStubType for CalibrationTarget {
+    fn type_output() -> TypeInfo {
+        TypeInfo {
+            name: "str".to_string(),
+            import: HashSet::new(),
+        }
+    }
+}
+
+impl pyo3_stub_gen::PyStubType for ProofType {
+    fn type_output() -> TypeInfo {
+        TypeInfo {
+            name: "str".to_string(),
+            import: HashSet::new(),
+        }
+    }
+}
+
+impl pyo3_stub_gen::PyStubType for TranscriptType {
+    fn type_output() -> TypeInfo {
+        TypeInfo {
+            name: "str".to_string(),
+            import: HashSet::new(),
+        }
+    }
+}
+
+impl pyo3_stub_gen::PyStubType for CheckMode {
+    fn type_output() -> TypeInfo {
+        TypeInfo {
+            name: "str".to_string(),
+            import: HashSet::new(),
+        }
+    }
+}
+
+impl pyo3_stub_gen::PyStubType for ContractType {
+    fn type_output() -> TypeInfo {
+        TypeInfo {
+            name: "str".to_string(),
+            import: HashSet::new(),
+        }
+    }
+}

src/bindings/universal.rs

@@ -0,0 +1,579 @@
+use halo2_proofs::{
+    plonk::*,
+    poly::{
+        commitment::{CommitmentScheme, ParamsProver},
+        ipa::{
+            commitment::{IPACommitmentScheme, ParamsIPA},
+            multiopen::{ProverIPA, VerifierIPA},
+            strategy::SingleStrategy as IPASingleStrategy,
+        },
+        kzg::{
+            commitment::{KZGCommitmentScheme, ParamsKZG},
+            multiopen::{ProverSHPLONK, VerifierSHPLONK},
+            strategy::SingleStrategy as KZGSingleStrategy,
+        },
+        VerificationStrategy,
+    },
+};
+use std::fmt::Display;
+use std::io::BufReader;
+use std::str::FromStr;
+
+use crate::{
+    circuit::region::RegionSettings,
+    graph::GraphSettings,
+    pfsys::{
+        create_proof_circuit,
+        evm::aggregation_kzg::{AggregationCircuit, PoseidonTranscript},
+        verify_proof_circuit, TranscriptType,
+    },
+    tensor::TensorType,
+    CheckMode, Commitments, EZKLError as InnerEZKLError,
+};
+
+use crate::graph::{GraphCircuit, GraphWitness};
+use halo2_solidity_verifier::encode_calldata;
+use halo2curves::{
+    bn256::{Bn256, Fr, G1Affine},
+    ff::{FromUniformBytes, PrimeField},
+};
+use snark_verifier::{loader::native::NativeLoader, system::halo2::transcript::evm::EvmTranscript};
+
+/// Wrapper around the Error Message
+#[cfg_attr(feature = "ios-bindings", derive(uniffi::Error))]
+#[derive(Debug)]
+pub enum EZKLError {
+    /// Some Comment
+    InternalError(String),
+}
+
+impl Display for EZKLError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            EZKLError::InternalError(e) => write!(f, "Internal error: {}", e),
+        }
+    }
+}
+
+impl From<InnerEZKLError> for EZKLError {
+    fn from(e: InnerEZKLError) -> Self {
+        EZKLError::InternalError(e.to_string())
+    }
+}
+
+/// Encode verifier calldata from proof and ethereum vk_address
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn encode_verifier_calldata(
+    // TODO - shuold it be pub(crate) or pub or pub(super)?
+    proof: Vec<u8>,
+    vk_address: Option<Vec<u8>>,
+) -> Result<Vec<u8>, EZKLError> {
+    let snark: crate::pfsys::Snark<Fr, G1Affine> =
+        serde_json::from_slice(&proof[..]).map_err(InnerEZKLError::from)?;
+
+    let vk_address: Option<[u8; 20]> = if let Some(vk_address) = vk_address {
+        let array: [u8; 20] =
+            serde_json::from_slice(&vk_address[..]).map_err(InnerEZKLError::from)?;
+        Some(array)
+    } else {
+        None
+    };
+
+    let flattened_instances = snark.instances.into_iter().flatten();
+
+    let encoded = encode_calldata(
+        vk_address,
+        &snark.proof,
+        &flattened_instances.collect::<Vec<_>>(),
+    );
+
+    Ok(encoded)
+}
+
+/// Generate witness from compiled circuit and input json
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn gen_witness(compiled_circuit: Vec<u8>, input: Vec<u8>) -> Result<Vec<u8>, EZKLError> {
+    let mut circuit: crate::graph::GraphCircuit = bincode::deserialize(&compiled_circuit[..])
+        .map_err(|e| {
+            EZKLError::InternalError(format!("Failed to deserialize compiled model: {}", e))
+        })?;
+    let input: crate::graph::input::GraphData = serde_json::from_slice(&input[..])
+        .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize input: {}", e)))?;
+
+    let mut input = circuit
+        .load_graph_input(&input)
+        .map_err(|e| EZKLError::InternalError(format!("{}", e)))?;
+
+    let witness = circuit
+        .forward::<KZGCommitmentScheme<Bn256>>(
+            &mut input,
+            None,
+            None,
+            RegionSettings::all_true(
+                circuit.settings().run_args.decomp_base,
+                circuit.settings().run_args.decomp_legs,
+            ),
+        )
+        .map_err(|e| EZKLError::InternalError(format!("{}", e)))?;
+
+    serde_json::to_vec(&witness)
+        .map_err(|e| EZKLError::InternalError(format!("Failed to serialize witness: {}", e)))
+}
+
+/// Generate verifying key from compiled circuit, and parameters srs
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn gen_vk(
+    compiled_circuit: Vec<u8>,
+    srs: Vec<u8>,
+    compress_selectors: bool,
+) -> Result<Vec<u8>, EZKLError> {
+    let mut reader = BufReader::new(&srs[..]);
+    let params: ParamsKZG<Bn256> = get_params(&mut reader)?;
+
+    let circuit: GraphCircuit = bincode::deserialize(&compiled_circuit[..])
+        .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize circuit: {}", e)))?;
+
+    let vk = create_vk_lean::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(
+        &circuit,
+        &params,
+        compress_selectors,
+    )
+    .map_err(|e| EZKLError::InternalError(format!("Failed to create verifying key: {}", e)))?;
+
+    let mut serialized_vk = Vec::new();
+    vk.write(&mut serialized_vk, halo2_proofs::SerdeFormat::RawBytes)
+        .map_err(|e| {
+            EZKLError::InternalError(format!("Failed to serialize verifying key: {}", e))
+        })?;
+
+    Ok(serialized_vk)
+}
+
+/// Generate proving key from vk, compiled circuit and parameters srs
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn gen_pk(
+    vk: Vec<u8>,
+    compiled_circuit: Vec<u8>,
+    srs: Vec<u8>,
+) -> Result<Vec<u8>, EZKLError> {
+    let mut reader = BufReader::new(&srs[..]);
+    let params: ParamsKZG<Bn256> = get_params(&mut reader)?;
+
+    let circuit: GraphCircuit = bincode::deserialize(&compiled_circuit[..])
+        .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize circuit: {}", e)))?;
+
+    let mut reader = BufReader::new(&vk[..]);
+    let vk = VerifyingKey::<G1Affine>::read::<_, GraphCircuit>(
+        &mut reader,
+        halo2_proofs::SerdeFormat::RawBytes,
+        circuit.settings().clone(),
+    )
+    .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize verifying key: {}", e)))?;
+
+    let pk = create_pk_lean::<KZGCommitmentScheme<Bn256>, Fr, GraphCircuit>(vk, &circuit, &params)
+        .map_err(|e| EZKLError::InternalError(format!("Failed to create proving key: {}", e)))?;
+
+    let mut serialized_pk = Vec::new();
+    pk.write(&mut serialized_pk, halo2_proofs::SerdeFormat::RawBytes)
+        .map_err(|e| EZKLError::InternalError(format!("Failed to serialize proving key: {}", e)))?;
+
+    Ok(serialized_pk)
+}
+
+/// Verify proof with vk, proof json, circuit settings json and srs
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn verify(
+    proof: Vec<u8>,
+    vk: Vec<u8>,
+    settings: Vec<u8>,
+    srs: Vec<u8>,
+) -> Result<bool, EZKLError> {
+    let circuit_settings: GraphSettings = serde_json::from_slice(&settings[..])
+        .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize settings: {}", e)))?;
+
+    let proof: crate::pfsys::Snark<Fr, G1Affine> = serde_json::from_slice(&proof[..])
+        .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize proof: {}", e)))?;
+
+    let mut reader = BufReader::new(&vk[..]);
+    let vk = VerifyingKey::<G1Affine>::read::<_, GraphCircuit>(
+        &mut reader,
+        halo2_proofs::SerdeFormat::RawBytes,
+        circuit_settings.clone(),
+    )
+    .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize vk: {}", e)))?;
+
+    let orig_n = 1 << circuit_settings.run_args.logrows;
+    let commitment = circuit_settings.run_args.commitment.into();
+
+    let mut reader = BufReader::new(&srs[..]);
+    let result = match commitment {
+        Commitments::KZG => {
+            let params: ParamsKZG<Bn256> = get_params(&mut reader)?;
+            let strategy = KZGSingleStrategy::new(params.verifier_params());
+            match proof.transcript_type {
+                TranscriptType::EVM => verify_proof_circuit::<
+                    VerifierSHPLONK<'_, Bn256>,
+                    KZGCommitmentScheme<Bn256>,
+                    KZGSingleStrategy<_>,
+                    _,
+                    EvmTranscript<G1Affine, _, _, _>,
+                >(&proof, &params, &vk, strategy, orig_n),
+                TranscriptType::Poseidon => {
+                    verify_proof_circuit::<
+                        VerifierSHPLONK<'_, Bn256>,
+                        KZGCommitmentScheme<Bn256>,
+                        KZGSingleStrategy<_>,
+                        _,
+                        PoseidonTranscript<NativeLoader, _>,
+                    >(&proof, &params, &vk, strategy, orig_n)
+                }
+            }
+        }
+        Commitments::IPA => {
+            let params: ParamsIPA<_> = get_params(&mut reader)?;
+            let strategy = IPASingleStrategy::new(params.verifier_params());
+            match proof.transcript_type {
+                TranscriptType::EVM => verify_proof_circuit::<
+                    VerifierIPA<_>,
+                    IPACommitmentScheme<G1Affine>,
+                    IPASingleStrategy<_>,
+                    _,
+                    EvmTranscript<G1Affine, _, _, _>,
+                >(&proof, &params, &vk, strategy, orig_n),
+                TranscriptType::Poseidon => {
+                    verify_proof_circuit::<
+                        VerifierIPA<_>,
+                        IPACommitmentScheme<G1Affine>,
+                        IPASingleStrategy<_>,
+                        _,
+                        PoseidonTranscript<NativeLoader, _>,
+                    >(&proof, &params, &vk, strategy, orig_n)
+                }
+            }
+        }
+    };
+
+    match result {
+        Ok(_) => Ok(true),
+        Err(e) => Err(EZKLError::InternalError(format!(
+            "Verification failed: {}",
+            e
+        ))),
+    }
+}
+
+/// Verify aggregate proof with vk, proof, circuit settings and srs
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn verify_aggr(
+    proof: Vec<u8>,
+    vk: Vec<u8>,
+    logrows: u64,
+    srs: Vec<u8>,
+    commitment: &str,
+) -> Result<bool, EZKLError> {
+    let proof: crate::pfsys::Snark<Fr, G1Affine> = serde_json::from_slice(&proof[..])
+        .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize proof: {}", e)))?;
+
+    let mut reader = BufReader::new(&vk[..]);
+    let vk = VerifyingKey::<G1Affine>::read::<_, AggregationCircuit>(
+        &mut reader,
+        halo2_proofs::SerdeFormat::RawBytes,
+        (),
+    )
+    .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize vk: {}", e)))?;
+
+    let commit = Commitments::from_str(commitment)
+        .map_err(|e| EZKLError::InternalError(format!("Invalid commitment: {}", e)))?;
+
+    let orig_n = 1 << logrows;
+
+    let mut reader = BufReader::new(&srs[..]);
+    let result = match commit {
+        Commitments::KZG => {
+            let params: ParamsKZG<Bn256> = get_params(&mut reader)?;
+            let strategy = KZGSingleStrategy::new(params.verifier_params());
+            match proof.transcript_type {
+                TranscriptType::EVM => verify_proof_circuit::<
+                    VerifierSHPLONK<'_, Bn256>,
+                    KZGCommitmentScheme<Bn256>,
+                    KZGSingleStrategy<_>,
+                    _,
+                    EvmTranscript<G1Affine, _, _, _>,
+                >(&proof, &params, &vk, strategy, orig_n),
+
+                TranscriptType::Poseidon => {
+                    verify_proof_circuit::<
+                        VerifierSHPLONK<'_, Bn256>,
+                        KZGCommitmentScheme<Bn256>,
+                        KZGSingleStrategy<_>,
+                        _,
+                        PoseidonTranscript<NativeLoader, _>,
+                    >(&proof, &params, &vk, strategy, orig_n)
+                }
+            }
+        }
+        Commitments::IPA => {
+            let params: ParamsIPA<_> =
+                halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader).map_err(
+                    |e| EZKLError::InternalError(format!("Failed to deserialize params: {}", e)),
+                )?;
+            let strategy = IPASingleStrategy::new(params.verifier_params());
+            match proof.transcript_type {
+                TranscriptType::EVM => verify_proof_circuit::<
+                    VerifierIPA<_>,
+                    IPACommitmentScheme<G1Affine>,
+                    IPASingleStrategy<_>,
+                    _,
+                    EvmTranscript<G1Affine, _, _, _>,
+                >(&proof, &params, &vk, strategy, orig_n),
+                TranscriptType::Poseidon => {
+                    verify_proof_circuit::<
+                        VerifierIPA<_>,
+                        IPACommitmentScheme<G1Affine>,
+                        IPASingleStrategy<_>,
+                        _,
+                        PoseidonTranscript<NativeLoader, _>,
+                    >(&proof, &params, &vk, strategy, orig_n)
+                }
+            }
+        }
+    };
+
+    result
+        .map(|_| true)
+        .map_err(|e| EZKLError::InternalError(format!("{}", e)))
+}
+
+/// Prove in browser with compiled circuit, witness json, proving key, and srs
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn prove(
+    witness: Vec<u8>,
+    pk: Vec<u8>,
+    compiled_circuit: Vec<u8>,
+    srs: Vec<u8>,
+) -> Result<Vec<u8>, EZKLError> {
+    #[cfg(feature = "det-prove")]
+    log::set_max_level(log::LevelFilter::Debug);
+    #[cfg(not(feature = "det-prove"))]
+    log::set_max_level(log::LevelFilter::Info);
+
+    let mut circuit: GraphCircuit = bincode::deserialize(&compiled_circuit[..])
+        .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize circuit: {}", e)))?;
+
+    let data: GraphWitness = serde_json::from_slice(&witness[..]).map_err(InnerEZKLError::from)?;
+
+    let mut reader = BufReader::new(&pk[..]);
+    let pk = ProvingKey::<G1Affine>::read::<_, GraphCircuit>(
+        &mut reader,
+        halo2_proofs::SerdeFormat::RawBytes,
+        circuit.settings().clone(),
+    )
+    .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize proving key: {}", e)))?;
+
+    circuit
+        .load_graph_witness(&data)
+        .map_err(InnerEZKLError::from)?;
+    let public_inputs = circuit
+        .prepare_public_inputs(&data)
+        .map_err(InnerEZKLError::from)?;
+    let proof_split_commits: Option<crate::pfsys::ProofSplitCommit> = data.into();
+
+    let mut reader = BufReader::new(&srs[..]);
+    let commitment = circuit.settings().run_args.commitment.into();
+
+    let proof = match commitment {
+        Commitments::KZG => {
+            let params: ParamsKZG<Bn256> =
+                halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader).map_err(
+                    |e| EZKLError::InternalError(format!("Failed to deserialize srs: {}", e)),
+                )?;
+
+            create_proof_circuit::<
+                KZGCommitmentScheme<Bn256>,
+                _,
+                ProverSHPLONK<_>,
+                VerifierSHPLONK<_>,
+                KZGSingleStrategy<_>,
+                _,
+                EvmTranscript<_, _, _, _>,
+                EvmTranscript<_, _, _, _>,
+            >(
+                circuit,
+                vec![public_inputs],
+                &params,
+                &pk,
+                CheckMode::UNSAFE,
+                Commitments::KZG,
+                TranscriptType::EVM,
+                proof_split_commits,
+                None,
+            )
+        }
+        Commitments::IPA => {
+            let params: ParamsIPA<_> =
+                halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader).map_err(
+                    |e| EZKLError::InternalError(format!("Failed to deserialize srs: {}", e)),
+                )?;
+
+            create_proof_circuit::<
+                IPACommitmentScheme<G1Affine>,
+                _,
+                ProverIPA<_>,
+                VerifierIPA<_>,
+                IPASingleStrategy<_>,
+                _,
+                EvmTranscript<_, _, _, _>,
+                EvmTranscript<_, _, _, _>,
+            >(
+                circuit,
+                vec![public_inputs],
+                &params,
+                &pk,
+                CheckMode::UNSAFE,
+                Commitments::IPA,
+                TranscriptType::EVM,
+                proof_split_commits,
+                None,
+            )
+        }
+    }
+    .map_err(InnerEZKLError::from)?;
+
+    Ok(serde_json::to_vec(&proof).map_err(InnerEZKLError::from)?)
+}
+
+/// Validate the witness json
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn witness_validation(witness: Vec<u8>) -> Result<bool, EZKLError> {
+    let _: GraphWitness = serde_json::from_slice(&witness[..]).map_err(InnerEZKLError::from)?;
+
+    Ok(true)
+}
+
+/// Validate the compiled circuit
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn compiled_circuit_validation(compiled_circuit: Vec<u8>) -> Result<bool, EZKLError> {
+    let _: GraphCircuit = bincode::deserialize(&compiled_circuit[..]).map_err(|e| {
+        EZKLError::InternalError(format!("Failed to deserialize compiled circuit: {}", e))
+    })?;
+
+    Ok(true)
+}
+
+/// Validate the input json
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn input_validation(input: Vec<u8>) -> Result<bool, EZKLError> {
+    let _: crate::graph::input::GraphData =
+        serde_json::from_slice(&input[..]).map_err(InnerEZKLError::from)?;
+
+    Ok(true)
+}
+
+/// Validate the proof json
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn proof_validation(proof: Vec<u8>) -> Result<bool, EZKLError> {
+    let _: crate::pfsys::Snark<Fr, G1Affine> =
+        serde_json::from_slice(&proof[..]).map_err(InnerEZKLError::from)?;
+
+    Ok(true)
+}
+
+/// Validate the verifying key given the settings json
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn vk_validation(vk: Vec<u8>, settings: Vec<u8>) -> Result<bool, EZKLError> {
+    let circuit_settings: GraphSettings =
+        serde_json::from_slice(&settings[..]).map_err(InnerEZKLError::from)?;
+
+    let mut reader = BufReader::new(&vk[..]);
+    let _ = VerifyingKey::<G1Affine>::read::<_, GraphCircuit>(
+        &mut reader,
+        halo2_proofs::SerdeFormat::RawBytes,
+        circuit_settings,
+    )
+    .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize verifying key: {}", e)))?;
+
+    Ok(true)
+}
+
+/// Validate the proving key given the settings json
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn pk_validation(pk: Vec<u8>, settings: Vec<u8>) -> Result<bool, EZKLError> {
+    let circuit_settings: GraphSettings =
+        serde_json::from_slice(&settings[..]).map_err(InnerEZKLError::from)?;
+
+    let mut reader = BufReader::new(&pk[..]);
+    let _ = ProvingKey::<G1Affine>::read::<_, GraphCircuit>(
+        &mut reader,
+        halo2_proofs::SerdeFormat::RawBytes,
+        circuit_settings,
+    )
+    .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize proving key: {}", e)))?;
+
+    Ok(true)
+}
+
+/// Validate the settings json
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn settings_validation(settings: Vec<u8>) -> Result<bool, EZKLError> {
+    let _: GraphSettings = serde_json::from_slice(&settings[..]).map_err(InnerEZKLError::from)?;
+
+    Ok(true)
+}
+
+/// Validate the srs
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub(crate) fn srs_validation(srs: Vec<u8>) -> Result<bool, EZKLError> {
+    let mut reader = BufReader::new(&srs[..]);
+    let _: ParamsKZG<Bn256> =
+        halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader).map_err(|e| {
+            EZKLError::InternalError(format!("Failed to deserialize params: {}", e))
+        })?;
+
+    Ok(true)
+}
+
+// HELPER FUNCTIONS
+
+fn get_params<
+    Scheme: for<'a> halo2_proofs::poly::commitment::Params<'a, halo2curves::bn256::G1Affine>,
+>(
+    mut reader: &mut BufReader<&[u8]>,
+) -> Result<Scheme, EZKLError> {
+    halo2_proofs::poly::commitment::Params::<G1Affine>::read(&mut reader)
+        .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize params: {}", e)))
+}
+
+/// Creates a [ProvingKey] for a [GraphCircuit] (`circuit`) with specific [CommitmentScheme] parameters (`params`) for the WASM target
+pub fn create_vk_lean<Scheme: CommitmentScheme, F: PrimeField + TensorType, C: Circuit<F>>(
+    circuit: &C,
+    params: &'_ Scheme::ParamsProver,
+    compress_selectors: bool,
+) -> Result<VerifyingKey<Scheme::Curve>, halo2_proofs::plonk::Error>
+where
+    C: Circuit<Scheme::Scalar>,
+    <Scheme as CommitmentScheme>::Scalar: FromUniformBytes<64>,
+{
+    //	Real proof
+    let empty_circuit = <C as Circuit<F>>::without_witnesses(circuit);
+
+    // Initialize the verifying key
+    let vk = keygen_vk_custom(params, &empty_circuit, compress_selectors)?;
+    Ok(vk)
+}
+/// Creates a [ProvingKey] from a [VerifyingKey] for a [GraphCircuit] (`circuit`) with specific [CommitmentScheme] parameters (`params`) for the WASM target
+pub fn create_pk_lean<Scheme: CommitmentScheme, F: PrimeField + TensorType, C: Circuit<F>>(
+    vk: VerifyingKey<Scheme::Curve>,
+    circuit: &C,
+    params: &'_ Scheme::ParamsProver,
+) -> Result<ProvingKey<Scheme::Curve>, halo2_proofs::plonk::Error>
+where
+    C: Circuit<Scheme::Scalar>,
+    <Scheme as CommitmentScheme>::Scalar: FromUniformBytes<64>,
+{
+    //	Real proof
+    let empty_circuit = <C as Circuit<F>>::without_witnesses(circuit);
+
+    // Initialize the proving key
+    let pk = keygen_pk(params, vk, &empty_circuit)?;
+    Ok(pk)
+}

src/bindings/wasm.rs

@@ -0,0 +1,379 @@
+use crate::{
+    circuit::modules::{
+        polycommit::PolyCommitChip,
+        poseidon::{
+            spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH},
+            PoseidonChip,
+        },
+        Module,
+    },
+    fieldutils::{felt_to_integer_rep, integer_rep_to_felt},
+    graph::{
+        modules::POSEIDON_LEN_GRAPH, quantize_float, scale_to_multiplier, GraphCircuit,
+        GraphSettings,
+    },
+};
+use console_error_panic_hook;
+use halo2_proofs::{
+    plonk::*,
+    poly::kzg::commitment::{KZGCommitmentScheme, ParamsKZG},
+};
+use halo2curves::{
+    bn256::{Bn256, Fr, G1Affine},
+    ff::PrimeField,
+};
+use std::str::FromStr;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_console_logger::DEFAULT_LOGGER;
+
+use crate::bindings::universal::{
+    compiled_circuit_validation, encode_verifier_calldata, gen_pk, gen_vk, gen_witness,
+    input_validation, pk_validation, proof_validation, settings_validation, srs_validation,
+    verify_aggr, vk_validation, witness_validation, EZKLError as ExternalEZKLError,
+};
+#[cfg(feature = "web")]
+pub use wasm_bindgen_rayon::init_thread_pool;
+
+impl From<ExternalEZKLError> for JsError {
+    fn from(e: ExternalEZKLError) -> Self {
+        JsError::new(&format!("{}", e))
+    }
+}
+
+#[wasm_bindgen]
+/// Initialize logger for wasm
+pub fn init_logger() {
+    log::set_logger(&DEFAULT_LOGGER).unwrap();
+}
+
+#[wasm_bindgen]
+/// Initialize panic hook for wasm
+pub fn init_panic_hook() {
+    console_error_panic_hook::set_once();
+}
+
+/// Wrapper around the halo2 encode call data method
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn encodeVerifierCalldata(
+    proof: wasm_bindgen::Clamped<Vec<u8>>,
+    vk_address: Option<Vec<u8>>,
+) -> Result<Vec<u8>, JsError> {
+    encode_verifier_calldata(proof.0, vk_address).map_err(JsError::from)
+}
+
+/// Converts a hex string to a byte array
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn feltToBigEndian(array: wasm_bindgen::Clamped<Vec<u8>>) -> Result<String, JsError> {
+    let felt: Fr = serde_json::from_slice(&array[..])
+        .map_err(|e| JsError::new(&format!("Failed to deserialize field element: {}", e)))?;
+    Ok(format!("{:?}", felt))
+}
+
+/// Converts a felt to a little endian string
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn feltToLittleEndian(array: wasm_bindgen::Clamped<Vec<u8>>) -> Result<String, JsError> {
+    let felt: Fr = serde_json::from_slice(&array[..])
+        .map_err(|e| JsError::new(&format!("Failed to deserialize field element: {}", e)))?;
+    let repr = serde_json::to_string(&felt).unwrap();
+    let b: String = serde_json::from_str(&repr).unwrap();
+    Ok(b)
+}
+
+/// Converts a hex string to a byte array
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn feltToInt(
+    array: wasm_bindgen::Clamped<Vec<u8>>,
+) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
+    let felt: Fr = serde_json::from_slice(&array[..])
+        .map_err(|e| JsError::new(&format!("Failed to deserialize field element: {}", e)))?;
+    Ok(wasm_bindgen::Clamped(
+        serde_json::to_vec(&felt_to_integer_rep(felt))
+            .map_err(|e| JsError::new(&format!("Failed to serialize integer: {}", e)))?,
+    ))
+}
+
+/// Converts felts to a floating point element
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn feltToFloat(
+    array: wasm_bindgen::Clamped<Vec<u8>>,
+    scale: crate::Scale,
+) -> Result<f64, JsError> {
+    let felt: Fr = serde_json::from_slice(&array[..])
+        .map_err(|e| JsError::new(&format!("Failed to deserialize field element: {}", e)))?;
+    let int_rep = felt_to_integer_rep(felt);
+    let multiplier = scale_to_multiplier(scale);
+    Ok(int_rep as f64 / multiplier)
+}
+
+/// Converts a floating point number to a hex string representing a fixed point field element
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn floatToFelt(
+    mut input: f64,
+    scale: crate::Scale,
+    input_type: &str,
+) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
+    crate::circuit::InputType::roundtrip(
+        &crate::circuit::InputType::from_str(input_type)
+            .map_err(|e| JsError::new(&format!("{}", e)))?,
+        &mut input,
+    );
+    let int_rep =
+        quantize_float(&input, 0.0, scale).map_err(|e| JsError::new(&format!("{}", e)))?;
+    let felt = integer_rep_to_felt(int_rep);
+    let vec = crate::pfsys::field_to_string::<halo2curves::bn256::Fr>(&felt);
+    Ok(wasm_bindgen::Clamped(serde_json::to_vec(&vec).map_err(
+        |e| JsError::new(&format!("Failed to serialize a float to felt{}", e)),
+    )?))
+}
+
+/// Generate a kzg commitment.
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn kzgCommit(
+    message: wasm_bindgen::Clamped<Vec<u8>>,
+    vk: wasm_bindgen::Clamped<Vec<u8>>,
+    settings: wasm_bindgen::Clamped<Vec<u8>>,
+    params_ser: wasm_bindgen::Clamped<Vec<u8>>,
+) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
+    let message: Vec<Fr> = serde_json::from_slice(&message[..])
+        .map_err(|e| JsError::new(&format!("Failed to deserialize message: {}", e)))?;
+
+    let mut reader = std::io::BufReader::new(&params_ser[..]);
+    let params: ParamsKZG<Bn256> =
+        halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader)
+            .map_err(|e| JsError::new(&format!("Failed to deserialize params: {}", e)))?;
+
+    let mut reader = std::io::BufReader::new(&vk[..]);
+    let circuit_settings: GraphSettings = serde_json::from_slice(&settings[..])
+        .map_err(|e| JsError::new(&format!("Failed to deserialize settings: {}", e)))?;
+    let vk = VerifyingKey::<G1Affine>::read::<_, GraphCircuit>(
+        &mut reader,
+        halo2_proofs::SerdeFormat::RawBytes,
+        circuit_settings,
+    )
+    .map_err(|e| JsError::new(&format!("Failed to deserialize vk: {}", e)))?;
+
+    let output = PolyCommitChip::commit::<KZGCommitmentScheme<Bn256>>(
+        message,
+        (vk.cs().blinding_factors() + 1) as u32,
+        &params,
+    );
+
+    Ok(wasm_bindgen::Clamped(
+        serde_json::to_vec(&output).map_err(|e| JsError::new(&format!("{}", e)))?,
+    ))
+}
+
+/// Converts a buffer to vector of 4 u64s representing a fixed point field element
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn bufferToVecOfFelt(
+    buffer: wasm_bindgen::Clamped<Vec<u8>>,
+) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
+    // Convert the buffer to a slice
+    let buffer: &[u8] = &buffer;
+
+    // Divide the buffer into chunks of 64 bytes
+    let chunks = buffer.chunks_exact(16);
+
+    // Get the remainder
+    let remainder = chunks.remainder();
+
+    // Add 0s to the remainder to make it 64 bytes
+    let mut remainder = remainder.to_vec();
+
+    // Collect chunks into a Vec<[u8; 16]>.
+    let chunks: Result<Vec<[u8; 16]>, JsError> = chunks
+        .map(|slice| {
+            let array: [u8; 16] = slice
+                .try_into()
+                .map_err(|_| JsError::new("failed to slice input chunks"))?;
+            Ok(array)
+        })
+        .collect();
+
+    let mut chunks = chunks?;
+
+    if remainder.len() != 0 {
+        remainder.resize(16, 0);
+        // Convert the Vec<u8> to [u8; 16]
+        let remainder_array: [u8; 16] = remainder
+            .try_into()
+            .map_err(|_| JsError::new("failed to slice remainder"))?;
+        // append the remainder to the chunks
+        chunks.push(remainder_array);
+    }
+
+    // Convert each chunk to a field element
+    let field_elements: Vec<Fr> = chunks
+        .iter()
+        .map(|x| PrimeField::from_u128(u8_array_to_u128_le(*x)))
+        .collect();
+
+    Ok(wasm_bindgen::Clamped(
+        serde_json::to_vec(&field_elements)
+            .map_err(|e| JsError::new(&format!("Failed to serialize field elements: {}", e)))?,
+    ))
+}
+
+/// Generate a poseidon hash in browser. Input message
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn poseidonHash(
+    message: wasm_bindgen::Clamped<Vec<u8>>,
+) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
+    let message: Vec<Fr> = serde_json::from_slice(&message[..])
+        .map_err(|e| JsError::new(&format!("Failed to deserialize message: {}", e)))?;
+
+    let output =
+        PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, POSEIDON_LEN_GRAPH>::run(
+            message.clone(),
+        )
+        .map_err(|e| JsError::new(&format!("{}", e)))?;
+
+    Ok(wasm_bindgen::Clamped(serde_json::to_vec(&output).map_err(
+        |e| JsError::new(&format!("Failed to serialize poseidon hash output: {}", e)),
+    )?))
+}
+
+/// Generate a witness file from input.json, compiled model and a settings.json file.
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn genWitness(
+    compiled_circuit: wasm_bindgen::Clamped<Vec<u8>>,
+    input: wasm_bindgen::Clamped<Vec<u8>>,
+) -> Result<Vec<u8>, JsError> {
+    gen_witness(compiled_circuit.0, input.0).map_err(JsError::from)
+}
+
+/// Generate verifying key in browser
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn genVk(
+    compiled_circuit: wasm_bindgen::Clamped<Vec<u8>>,
+    params_ser: wasm_bindgen::Clamped<Vec<u8>>,
+    compress_selectors: bool,
+) -> Result<Vec<u8>, JsError> {
+    gen_vk(compiled_circuit.0, params_ser.0, compress_selectors).map_err(JsError::from)
+}
+
+/// Generate proving key in browser
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn genPk(
+    vk: wasm_bindgen::Clamped<Vec<u8>>,
+    compiled_circuit: wasm_bindgen::Clamped<Vec<u8>>,
+    params_ser: wasm_bindgen::Clamped<Vec<u8>>,
+) -> Result<Vec<u8>, JsError> {
+    gen_pk(vk.0, compiled_circuit.0, params_ser.0).map_err(JsError::from)
+}
+
+/// Verify proof in browser using wasm
+#[wasm_bindgen]
+pub fn verify(
+    proof_js: wasm_bindgen::Clamped<Vec<u8>>,
+    vk: wasm_bindgen::Clamped<Vec<u8>>,
+    settings: wasm_bindgen::Clamped<Vec<u8>>,
+    srs: wasm_bindgen::Clamped<Vec<u8>>,
+) -> Result<bool, JsError> {
+    super::universal::verify(proof_js.0, vk.0, settings.0, srs.0).map_err(JsError::from)
+}
+
+/// Verify aggregate proof in browser using wasm
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn verifyAggr(
+    proof_js: wasm_bindgen::Clamped<Vec<u8>>,
+    vk: wasm_bindgen::Clamped<Vec<u8>>,
+    logrows: u64,
+    srs: wasm_bindgen::Clamped<Vec<u8>>,
+    commitment: &str,
+) -> Result<bool, JsError> {
+    verify_aggr(proof_js.0, vk.0, logrows, srs.0, commitment).map_err(JsError::from)
+}
+
+/// Prove in browser using wasm
+#[wasm_bindgen]
+pub fn prove(
+    witness: wasm_bindgen::Clamped<Vec<u8>>,
+    pk: wasm_bindgen::Clamped<Vec<u8>>,
+    compiled_circuit: wasm_bindgen::Clamped<Vec<u8>>,
+    srs: wasm_bindgen::Clamped<Vec<u8>>,
+) -> Result<Vec<u8>, JsError> {
+    super::universal::prove(witness.0, pk.0, compiled_circuit.0, srs.0).map_err(JsError::from)
+}
+
+// VALIDATION FUNCTIONS
+
+/// Witness file validation
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn witnessValidation(witness: wasm_bindgen::Clamped<Vec<u8>>) -> Result<bool, JsError> {
+    witness_validation(witness.0).map_err(JsError::from)
+}
+/// Compiled circuit validation
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn compiledCircuitValidation(
+    compiled_circuit: wasm_bindgen::Clamped<Vec<u8>>,
+) -> Result<bool, JsError> {
+    compiled_circuit_validation(compiled_circuit.0).map_err(JsError::from)
+}
+/// Input file validation
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn inputValidation(input: wasm_bindgen::Clamped<Vec<u8>>) -> Result<bool, JsError> {
+    input_validation(input.0).map_err(JsError::from)
+}
+/// Proof file validation
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn proofValidation(proof: wasm_bindgen::Clamped<Vec<u8>>) -> Result<bool, JsError> {
+    proof_validation(proof.0).map_err(JsError::from)
+}
+/// Vk file validation
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn vkValidation(
+    vk: wasm_bindgen::Clamped<Vec<u8>>,
+    settings: wasm_bindgen::Clamped<Vec<u8>>,
+) -> Result<bool, JsError> {
+    vk_validation(vk.0, settings.0).map_err(JsError::from)
+}
+/// Pk file validation
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn pkValidation(
+    pk: wasm_bindgen::Clamped<Vec<u8>>,
+    settings: wasm_bindgen::Clamped<Vec<u8>>,
+) -> Result<bool, JsError> {
+    pk_validation(pk.0, settings.0).map_err(JsError::from)
+}
+/// Settings file validation
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn settingsValidation(settings: wasm_bindgen::Clamped<Vec<u8>>) -> Result<bool, JsError> {
+    settings_validation(settings.0).map_err(JsError::from)
+}
+/// Srs file validation
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn srsValidation(srs: wasm_bindgen::Clamped<Vec<u8>>) -> Result<bool, JsError> {
+    srs_validation(srs.0).map_err(JsError::from)
+}
+
+/// HELPER FUNCTIONS
+pub fn u8_array_to_u128_le(arr: [u8; 16]) -> u128 {
+    let mut n: u128 = 0;
+    for &b in arr.iter().rev() {
+        n <<= 8;
+        n |= b as u128;
+    }
+    n
+}

src/circuit/modules/polycommit.rs

@@ -219,7 +219,7 @@ mod tests {
     fn polycommit_chip_for_a_range_of_input_sizes() {
         let rng = rand::rngs::OsRng;
 
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
         env_logger::init();
 
         {
@@ -247,7 +247,7 @@ mod tests {
     #[test]
     #[ignore]
     fn polycommit_chip_much_longer_input() {
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
         env_logger::init();
 
         let rng = rand::rngs::OsRng;

src/circuit/modules/poseidon.rs

@@ -560,7 +560,7 @@ mod tests {
     fn hash_for_a_range_of_input_sizes() {
         let rng = rand::rngs::OsRng;
 
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
         env_logger::init();
 
         {

src/circuit/ops/chip.rs

@@ -8,12 +8,12 @@ use halo2_proofs::{
 use log::debug;
 #[cfg(feature = "python-bindings")]
 use pyo3::{
-    conversion::{FromPyObject, PyTryFrom},
+    conversion::{FromPyObject, IntoPy},
     exceptions::PyValueError,
     prelude::*,
-    types::PyString,
 };
 use serde::{Deserialize, Serialize};
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tosubcommand::ToFlags;
 
 use crate::{
@@ -22,7 +22,7 @@ use crate::{
         table::{Range, RangeCheck, Table},
         utils,
     },
-    tensor::{IntoI64, Tensor, TensorType, ValTensor, VarTensor},
+    tensor::{Tensor, TensorType, ValTensor, VarTensor},
 };
 use std::{collections::BTreeMap, marker::PhantomData};
 
@@ -49,6 +49,7 @@ impl std::fmt::Display for CheckMode {
     }
 }
 
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 impl ToFlags for CheckMode {
     /// Convert the struct to a subcommand string
     fn to_flags(&self) -> Vec<String> {
@@ -88,6 +89,7 @@ impl std::fmt::Display for Tolerance {
     }
 }
 
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 impl ToFlags for Tolerance {
     /// Convert the struct to a subcommand string
     fn to_flags(&self) -> Vec<String> {
@@ -136,10 +138,9 @@ impl IntoPy<PyObject> for CheckMode {
 #[cfg(feature = "python-bindings")]
 /// Obtains CheckMode from PyObject (Required for CheckMode to be compatible with Python)
 impl<'source> FromPyObject<'source> for CheckMode {
-    fn extract(ob: &'source PyAny) -> PyResult<Self> {
-        let trystr = <PyString as PyTryFrom>::try_from(ob)?;
-        let strval = trystr.to_string();
-        match strval.to_lowercase().as_str() {
+    fn extract_bound(ob: &pyo3::Bound<'source, pyo3::PyAny>) -> PyResult<Self> {
+        let trystr = String::extract_bound(ob)?;
+        match trystr.to_lowercase().as_str() {
             "safe" => Ok(CheckMode::SAFE),
             "unsafe" => Ok(CheckMode::UNSAFE),
             _ => Err(PyValueError::new_err("Invalid value for CheckMode")),
@@ -158,8 +159,8 @@ impl IntoPy<PyObject> for Tolerance {
 #[cfg(feature = "python-bindings")]
 /// Obtains Tolerance from PyObject (Required for Tolerance to be compatible with Python)
 impl<'source> FromPyObject<'source> for Tolerance {
-    fn extract(ob: &'source PyAny) -> PyResult<Self> {
-        if let Ok((val, scale)) = ob.extract::<(f32, f32)>() {
+    fn extract_bound(ob: &pyo3::Bound<'source, pyo3::PyAny>) -> PyResult<Self> {
+        if let Ok((val, scale)) = <(f32, f32)>::extract_bound(ob) {
             Ok(Tolerance {
                 val,
                 scale: utils::F32(scale),
@@ -174,7 +175,7 @@ impl<'source> FromPyObject<'source> for Tolerance {
 #[derive(Clone, Debug, Default)]
 pub struct DynamicLookups {
     /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many dynamic lookup ops.
-    pub lookup_selectors: BTreeMap<(usize, usize), Selector>,
+    pub lookup_selectors: BTreeMap<(usize, (usize, usize)), Selector>,
     /// Selectors for the dynamic lookup tables
     pub table_selectors: Vec<Selector>,
     /// Inputs:
@@ -206,7 +207,7 @@ impl DynamicLookups {
 #[derive(Clone, Debug, Default)]
 pub struct Shuffles {
     /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many dynamic lookup ops.
-    pub input_selectors: BTreeMap<(usize, usize), Selector>,
+    pub input_selectors: BTreeMap<(usize, (usize, usize)), Selector>,
     /// Selectors for the dynamic lookup tables
     pub reference_selectors: Vec<Selector>,
     /// Inputs:
@@ -327,7 +328,7 @@ pub struct BaseConfig<F: PrimeField + TensorType + PartialOrd> {
     _marker: PhantomData<F>,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> BaseConfig<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
     /// Returns a new [BaseConfig] with no inputs, no selectors, and no tables.
     pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
         Self {
@@ -643,57 +644,73 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> BaseCo
         }
 
         for t in tables.iter() {
-            if !t.is_advice() || t.num_blocks() > 1 || t.num_inner_cols() > 1 {
+            if !t.is_advice() || t.num_inner_cols() > 1 {
                 return Err(CircuitError::WrongDynamicColumnType(t.name().to_string()));
             }
         }
 
+        // assert all tables have the same number of inner columns
+        if tables
+            .iter()
+            .map(|t| t.num_blocks())
+            .collect::<Vec<_>>()
+            .windows(2)
+            .any(|w| w[0] != w[1])
+        {
+            return Err(CircuitError::WrongDynamicColumnType(
+                "tables inner cols".to_string(),
+            ));
+        }
+
         let one = Expression::Constant(F::ONE);
 
-        let s_ltable = cs.complex_selector();
+        for q in 0..tables[0].num_blocks() {
+            let s_ltable = cs.complex_selector();
 
-        for x in 0..lookups[0].num_blocks() {
-            for y in 0..lookups[0].num_inner_cols() {
-                let s_lookup = cs.complex_selector();
+            for x in 0..lookups[0].num_blocks() {
+                for y in 0..lookups[0].num_inner_cols() {
+                    let s_lookup = cs.complex_selector();
 
-                cs.lookup_any("lookup", |cs| {
-                    let s_lookupq = cs.query_selector(s_lookup);
-                    let mut expression = vec![];
-                    let s_ltableq = cs.query_selector(s_ltable);
-                    let mut lookup_queries = vec![one.clone()];
+                    cs.lookup_any("lookup", |cs| {
+                        let s_lookupq = cs.query_selector(s_lookup);
+                        let mut expression = vec![];
+                        let s_ltableq = cs.query_selector(s_ltable);
+                        let mut lookup_queries = vec![one.clone()];
 
-                    for lookup in lookups {
-                        lookup_queries.push(match lookup {
-                            VarTensor::Advice { inner: advices, .. } => {
-                                cs.query_advice(advices[x][y], Rotation(0))
-                            }
-                            _ => unreachable!(),
-                        });
-                    }
+                        for lookup in lookups {
+                            lookup_queries.push(match lookup {
+                                VarTensor::Advice { inner: advices, .. } => {
+                                    cs.query_advice(advices[x][y], Rotation(0))
+                                }
+                                _ => unreachable!(),
+                            });
+                        }
 
-                    let mut table_queries = vec![one.clone()];
-                    for table in tables {
-                        table_queries.push(match table {
-                            VarTensor::Advice { inner: advices, .. } => {
-                                cs.query_advice(advices[0][0], Rotation(0))
-                            }
-                            _ => unreachable!(),
-                        });
-                    }
+                        let mut table_queries = vec![one.clone()];
+                        for table in tables {
+                            table_queries.push(match table {
+                                VarTensor::Advice { inner: advices, .. } => {
+                                    cs.query_advice(advices[q][0], Rotation(0))
+                                }
+                                _ => unreachable!(),
+                            });
+                        }
 
-                    let lhs = lookup_queries.into_iter().map(|c| c * s_lookupq.clone());
-                    let rhs = table_queries.into_iter().map(|c| c * s_ltableq.clone());
-                    expression.extend(lhs.zip(rhs));
+                        let lhs = lookup_queries.into_iter().map(|c| c * s_lookupq.clone());
+                        let rhs = table_queries.into_iter().map(|c| c * s_ltableq.clone());
+                        expression.extend(lhs.zip(rhs));
 
-                    expression
-                });
-                self.dynamic_lookups
-                    .lookup_selectors
-                    .entry((x, y))
-                    .or_insert(s_lookup);
+                        expression
+                    });
+                    self.dynamic_lookups
+                        .lookup_selectors
+                        .entry((q, (x, y)))
+                        .or_insert(s_lookup);
+                }
             }
+
+            self.dynamic_lookups.table_selectors.push(s_ltable);
         }
-        self.dynamic_lookups.table_selectors.push(s_ltable);
 
         // if we haven't previously initialized the input/output, do so now
         if self.dynamic_lookups.tables.is_empty() {
@@ -726,57 +743,72 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> BaseCo
         }
 
         for t in references.iter() {
-            if !t.is_advice() || t.num_blocks() > 1 || t.num_inner_cols() > 1 {
+            if !t.is_advice() || t.num_inner_cols() > 1 {
                 return Err(CircuitError::WrongDynamicColumnType(t.name().to_string()));
             }
         }
 
+        // assert all tables have the same number of blocks
+        if references
+            .iter()
+            .map(|t| t.num_blocks())
+            .collect::<Vec<_>>()
+            .windows(2)
+            .any(|w| w[0] != w[1])
+        {
+            return Err(CircuitError::WrongDynamicColumnType(
+                "references inner cols".to_string(),
+            ));
+        }
+
         let one = Expression::Constant(F::ONE);
 
-        let s_reference = cs.complex_selector();
+        for q in 0..references[0].num_blocks() {
+            let s_reference = cs.complex_selector();
 
-        for x in 0..inputs[0].num_blocks() {
-            for y in 0..inputs[0].num_inner_cols() {
-                let s_input = cs.complex_selector();
+            for x in 0..inputs[0].num_blocks() {
+                for y in 0..inputs[0].num_inner_cols() {
+                    let s_input = cs.complex_selector();
 
-                cs.lookup_any("lookup", |cs| {
-                    let s_inputq = cs.query_selector(s_input);
-                    let mut expression = vec![];
-                    let s_referenceq = cs.query_selector(s_reference);
-                    let mut input_queries = vec![one.clone()];
+                    cs.lookup_any("lookup", |cs| {
+                        let s_inputq = cs.query_selector(s_input);
+                        let mut expression = vec![];
+                        let s_referenceq = cs.query_selector(s_reference);
+                        let mut input_queries = vec![one.clone()];
 
-                    for input in inputs {
-                        input_queries.push(match input {
-                            VarTensor::Advice { inner: advices, .. } => {
-                                cs.query_advice(advices[x][y], Rotation(0))
-                            }
-                            _ => unreachable!(),
-                        });
-                    }
+                        for input in inputs {
+                            input_queries.push(match input {
+                                VarTensor::Advice { inner: advices, .. } => {
+                                    cs.query_advice(advices[x][y], Rotation(0))
+                                }
+                                _ => unreachable!(),
+                            });
+                        }
 
-                    let mut ref_queries = vec![one.clone()];
-                    for reference in references {
-                        ref_queries.push(match reference {
-                            VarTensor::Advice { inner: advices, .. } => {
-                                cs.query_advice(advices[0][0], Rotation(0))
-                            }
-                            _ => unreachable!(),
-                        });
-                    }
+                        let mut ref_queries = vec![one.clone()];
+                        for reference in references {
+                            ref_queries.push(match reference {
+                                VarTensor::Advice { inner: advices, .. } => {
+                                    cs.query_advice(advices[q][0], Rotation(0))
+                                }
+                                _ => unreachable!(),
+                            });
+                        }
 
-                    let lhs = input_queries.into_iter().map(|c| c * s_inputq.clone());
-                    let rhs = ref_queries.into_iter().map(|c| c * s_referenceq.clone());
-                    expression.extend(lhs.zip(rhs));
+                        let lhs = input_queries.into_iter().map(|c| c * s_inputq.clone());
+                        let rhs = ref_queries.into_iter().map(|c| c * s_referenceq.clone());
+                        expression.extend(lhs.zip(rhs));
 
-                    expression
-                });
-                self.shuffles
-                    .input_selectors
-                    .entry((x, y))
-                    .or_insert(s_input);
+                        expression
+                    });
+                    self.shuffles
+                        .input_selectors
+                        .entry((q, (x, y)))
+                        .or_insert(s_input);
+                }
             }
+            self.shuffles.reference_selectors.push(s_reference);
         }
-        self.shuffles.reference_selectors.push(s_reference);
 
         // if we haven't previously initialized the input/output, do so now
         if self.shuffles.references.is_empty() {

src/circuit/ops/errors.rs

@@ -1,6 +1,6 @@
 use std::convert::Infallible;
 
-use crate::tensor::TensorError;
+use crate::{fieldutils::IntegerRep, tensor::TensorError};
 use halo2_proofs::plonk::Error as PlonkError;
 use thiserror::Error;
 
@@ -57,7 +57,7 @@ pub enum CircuitError {
     InvalidConversion(#[from] Infallible),
     /// Invalid min/max lookup range
     #[error("invalid min/max lookup range: min: {0}, max: {1}")]
-    InvalidMinMaxRange(i64, i64),
+    InvalidMinMaxRange(IntegerRep, IntegerRep),
     /// Missing product in einsum
     #[error("missing product in einsum")]
     MissingEinsumProduct,
@@ -81,7 +81,7 @@ pub enum CircuitError {
     MissingSelectors(String),
     /// Table lookup error
     #[error("value ({0}) out of range: ({1}, {2})")]
-    TableOOR(i64, i64, i64),
+    TableOOR(IntegerRep, IntegerRep, IntegerRep),
     /// Loookup not configured
     #[error("lookup not configured: {0}")]
     LookupNotConfigured(String),
@@ -91,4 +91,13 @@ pub enum CircuitError {
     /// Missing layout
     #[error("missing layout for op: {0}")]
     MissingLayout(String),
+    #[error("[io] {0}")]
+    /// IO error
+    IoError(#[from] std::io::Error),
+    /// Invalid scale
+    #[error("negative scale for an op that requires positive inputs {0}")]
+    NegativeScale(String),
+    #[error("invalid input type {0}")]
+    /// Invalid input type
+    InvalidInputType(String),
 }

src/circuit/ops/hybrid.rs

@@ -1,7 +1,7 @@
 use super::*;
 use crate::{
     circuit::{layouts, utils, Tolerance},
-    fieldutils::i64_to_felt,
+    fieldutils::integer_rep_to_felt,
     graph::multiplier_to_scale,
     tensor::{self, Tensor, TensorType, ValTensor},
 };
@@ -13,14 +13,38 @@ use serde::{Deserialize, Serialize};
 /// An enum representing the operations that consist of both lookups and arithmetic operations.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum HybridOp {
+    Ln {
+        scale: utils::F32,
+    },
+    Rsqrt {
+        input_scale: utils::F32,
+        output_scale: utils::F32,
+    },
+    Sqrt {
+        scale: utils::F32,
+    },
+    RoundHalfToEven {
+        scale: utils::F32,
+        legs: usize,
+    },
+    Ceil {
+        scale: utils::F32,
+        legs: usize,
+    },
+    Floor {
+        scale: utils::F32,
+        legs: usize,
+    },
+    Round {
+        scale: utils::F32,
+        legs: usize,
+    },
     Recip {
         input_scale: utils::F32,
         output_scale: utils::F32,
-        use_range_check_for_int: bool,
     },
     Div {
         denom: utils::F32,
-        use_range_check_for_int: bool,
     },
     ReduceMax {
         axes: Vec<usize>,
@@ -45,6 +69,8 @@ pub enum HybridOp {
     ReduceArgMin {
         dim: usize,
     },
+    Max,
+    Min,
     Softmax {
         input_scale: utils::F32,
         output_scale: utils::F32,
@@ -71,12 +97,19 @@ pub enum HybridOp {
     },
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> 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 {
-            HybridOp::Greater | HybridOp::Less | HybridOp::Equals => vec![0, 1],
-            HybridOp::GreaterEqual | HybridOp::LessEqual => vec![0, 1],
+            HybridOp::Greater { .. }
+            | HybridOp::Less { .. }
+            | HybridOp::Equals { .. }
+            | HybridOp::GreaterEqual { .. }
+            | HybridOp::Max
+            | HybridOp::Min
+            | HybridOp::LessEqual { .. } => {
+                vec![0, 1]
+            }
             _ => vec![],
         }
     }
@@ -88,21 +121,32 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
 
     fn as_string(&self) -> String {
         match self {
+            HybridOp::Rsqrt {
+                input_scale,
+                output_scale,
+            } => format!(
+                "RSQRT (input_scale={}, output_scale={})",
+                input_scale, output_scale
+            ),
+            HybridOp::Sqrt { scale } => format!("SQRT(scale={})", scale),
+            HybridOp::Ln { scale } => format!("LN(scale={})", scale),
+            HybridOp::RoundHalfToEven { scale, legs } => {
+                format!("ROUND_HALF_TO_EVEN(scale={}, legs={})", scale, legs)
+            }
+            HybridOp::Ceil { scale, legs } => format!("CEIL(scale={}, legs={})", scale, legs),
+            HybridOp::Floor { scale, legs } => format!("FLOOR(scale={}, legs={})", scale, legs),
+            HybridOp::Round { scale, legs } => format!("ROUND(scale={}, legs={})", scale, legs),
+
+            HybridOp::Max => "MAX".to_string(),
+            HybridOp::Min => "MIN".to_string(),
             HybridOp::Recip {
                 input_scale,
                 output_scale,
-                use_range_check_for_int,
             } => format!(
-                "RECIP (input_scale={}, output_scale={}, use_range_check_for_int={})",
-                input_scale, output_scale, use_range_check_for_int
-            ),
-            HybridOp::Div {
-                denom,
-                use_range_check_for_int,
-            } => format!(
-                "DIV (denom={}, use_range_check_for_int={})",
-                denom, use_range_check_for_int
+                "RECIP (input_scale={}, output_scale={})",
+                input_scale, output_scale
             ),
+            HybridOp::Div { denom } => format!("DIV (denom={})", denom),
             HybridOp::SumPool {
                 padding,
                 stride,
@@ -135,10 +179,10 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
                 )
             }
             HybridOp::RangeCheck(p) => format!("RANGECHECK (tol={:?})", p),
-            HybridOp::Greater => "GREATER".into(),
-            HybridOp::GreaterEqual => "GREATEREQUAL".into(),
-            HybridOp::Less => "LESS".into(),
-            HybridOp::LessEqual => "LESSEQUAL".into(),
+            HybridOp::Greater => "GREATER".to_string(),
+            HybridOp::GreaterEqual => "GREATEREQUAL".to_string(),
+            HybridOp::Less => "LESS".to_string(),
+            HybridOp::LessEqual => "LESSEQUAL".to_string(),
             HybridOp::Equals => "EQUALS".into(),
             HybridOp::Gather { dim, .. } => format!("GATHER (dim={})", dim),
             HybridOp::TopK { k, dim, largest } => {
@@ -157,6 +201,34 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
         values: &[ValTensor<F>],
     ) -> Result<Option<ValTensor<F>>, CircuitError> {
         Ok(Some(match self {
+            HybridOp::Rsqrt {
+                input_scale,
+                output_scale,
+            } => layouts::rsqrt(
+                config,
+                region,
+                values[..].try_into()?,
+                *input_scale,
+                *output_scale,
+            )?,
+            HybridOp::Sqrt { scale } => {
+                layouts::sqrt(config, region, values[..].try_into()?, *scale)?
+            }
+            HybridOp::Ln { scale } => layouts::ln(config, region, values[..].try_into()?, *scale)?,
+            HybridOp::RoundHalfToEven { scale, legs } => {
+                layouts::round_half_to_even(config, region, values[..].try_into()?, *scale, *legs)?
+            }
+            HybridOp::Ceil { scale, legs } => {
+                layouts::ceil(config, region, values[..].try_into()?, *scale, *legs)?
+            }
+            HybridOp::Floor { scale, legs } => {
+                layouts::floor(config, region, values[..].try_into()?, *scale, *legs)?
+            }
+            HybridOp::Round { scale, legs } => {
+                layouts::round(config, region, values[..].try_into()?, *scale, *legs)?
+            }
+            HybridOp::Max => layouts::max_comp(config, region, values[..].try_into()?)?,
+            HybridOp::Min => layouts::min_comp(config, region, values[..].try_into()?)?,
             HybridOp::SumPool {
                 padding,
                 stride,
@@ -174,42 +246,20 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
             HybridOp::Recip {
                 input_scale,
                 output_scale,
-                use_range_check_for_int,
-            } => {
-                if input_scale.0.fract() == 0.0
-                    && output_scale.0.fract() == 0.0
-                    && *use_range_check_for_int
-                {
-                    layouts::recip(
+            } => layouts::recip(
+                config,
+                region,
+                values[..].try_into()?,
+                integer_rep_to_felt(input_scale.0 as i128),
+                integer_rep_to_felt(output_scale.0 as i128),
+            )?,
+            HybridOp::Div { denom, .. } => {
+                if denom.0.fract() == 0.0 {
+                    layouts::div(
                         config,
                         region,
                         values[..].try_into()?,
-                        i64_to_felt(input_scale.0 as i64),
-                        i64_to_felt(output_scale.0 as i64),
-                    )?
-                } else {
-                    layouts::nonlinearity(
-                        config,
-                        region,
-                        values.try_into()?,
-                        &LookupOp::Recip {
-                            input_scale: *input_scale,
-                            output_scale: *output_scale,
-                        },
-                    )?
-                }
-            }
-            HybridOp::Div {
-                denom,
-                use_range_check_for_int,
-                ..
-            } => {
-                if denom.0.fract() == 0.0 && *use_range_check_for_int {
-                    layouts::loop_div(
-                        config,
-                        region,
-                        values[..].try_into()?,
-                        i64_to_felt(denom.0 as i64),
+                        integer_rep_to_felt(denom.0 as i128),
                     )?
                 } else {
                     layouts::nonlinearity(
@@ -296,9 +346,18 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
             | HybridOp::ReduceArgMax { .. }
             | HybridOp::OneHot { .. }
             | HybridOp::ReduceArgMin { .. } => 0,
-            HybridOp::Softmax { output_scale, .. } | HybridOp::Recip { output_scale, .. } => {
+
+            HybridOp::Recip { output_scale, .. } | HybridOp::Rsqrt { output_scale, .. } => {
                 multiplier_to_scale(output_scale.0 as f64)
             }
+            HybridOp::Softmax {
+                output_scale,
+                input_scale,
+                ..
+            } => multiplier_to_scale((output_scale.0 * input_scale.0) as f64),
+            HybridOp::Ln {
+                scale: output_scale,
+            } => 4 * multiplier_to_scale(output_scale.0 as f64),
             _ => in_scales[0],
         };
         Ok(scale)

src/circuit/ops/lookup.rs

@@ -3,9 +3,8 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     circuit::{layouts, table::Range, utils},
-    fieldutils::{felt_to_i64, i64_to_felt},
-    graph::multiplier_to_scale,
-    tensor::{self, IntoI64, Tensor, TensorError, TensorType},
+    fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep},
+    tensor::{self, Tensor, TensorError, TensorType},
 };
 
 use super::Op;
@@ -15,225 +14,142 @@ use halo2curves::ff::PrimeField;
 /// An enum representing the operations that can be used to express more complex operations via accumulation
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Deserialize, Serialize)]
 pub enum LookupOp {
-    Abs,
-    Div {
-        denom: utils::F32,
-    },
-    Cast {
-        scale: utils::F32,
-    },
-    ReLU,
-    Max {
-        scale: utils::F32,
-        a: utils::F32,
-    },
-    Min {
-        scale: utils::F32,
-        a: utils::F32,
-    },
-    Ceil {
-        scale: utils::F32,
-    },
-    Floor {
-        scale: utils::F32,
-    },
-    Round {
-        scale: utils::F32,
-    },
-    RoundHalfToEven {
-        scale: utils::F32,
-    },
-    Sqrt {
-        scale: utils::F32,
-    },
-    Rsqrt {
-        scale: utils::F32,
-    },
-    Recip {
-        input_scale: utils::F32,
-        output_scale: utils::F32,
-    },
-    LeakyReLU {
-        slope: utils::F32,
-    },
-    Sigmoid {
-        scale: utils::F32,
-    },
-    Ln {
-        scale: utils::F32,
-    },
-    Exp {
-        scale: utils::F32,
-    },
-    Cos {
-        scale: utils::F32,
-    },
-    ACos {
-        scale: utils::F32,
-    },
-    Cosh {
-        scale: utils::F32,
-    },
-    ACosh {
-        scale: utils::F32,
-    },
-    Sin {
-        scale: utils::F32,
-    },
-    ASin {
-        scale: utils::F32,
-    },
-    Sinh {
-        scale: utils::F32,
-    },
-    ASinh {
-        scale: utils::F32,
-    },
-    Tan {
-        scale: utils::F32,
-    },
-    ATan {
-        scale: utils::F32,
-    },
-    Tanh {
-        scale: utils::F32,
-    },
-    ATanh {
-        scale: utils::F32,
-    },
-    Erf {
-        scale: utils::F32,
-    },
-    GreaterThan {
-        a: utils::F32,
-    },
-    LessThan {
-        a: utils::F32,
-    },
-    GreaterThanEqual {
-        a: utils::F32,
-    },
-    LessThanEqual {
-        a: utils::F32,
-    },
-    Sign,
-    KroneckerDelta,
-    Pow {
-        scale: utils::F32,
-        a: utils::F32,
-    },
-    HardSwish {
-        scale: utils::F32,
-    },
+    Div { denom: utils::F32 },
+    IsOdd,
+    PowersOfTwo { scale: utils::F32 },
+    Ln { scale: utils::F32 },
+    Sigmoid { scale: utils::F32 },
+    Exp { scale: utils::F32, base: utils::F32 },
+    Cos { scale: utils::F32 },
+    ACos { scale: utils::F32 },
+    Cosh { scale: utils::F32 },
+    ACosh { scale: utils::F32 },
+    Sin { scale: utils::F32 },
+    ASin { scale: utils::F32 },
+    Sinh { scale: utils::F32 },
+    ASinh { scale: utils::F32 },
+    Tan { scale: utils::F32 },
+    ATan { scale: utils::F32 },
+    Tanh { scale: utils::F32 },
+    ATanh { scale: utils::F32 },
+    Erf { scale: utils::F32 },
+    Pow { scale: utils::F32, a: utils::F32 },
+    HardSwish { scale: utils::F32 },
 }
 
 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 i64;
+        let range = range as IntegerRep;
         (-range, range)
     }
 
+    /// as path
+    pub fn as_path(&self) -> String {
+        match self {
+            LookupOp::Pow { scale, a } => format!("pow_{}_{}", scale, a),
+            LookupOp::Ln { scale } => format!("ln_{}", scale),
+            LookupOp::PowersOfTwo { scale } => format!("pow2_{}", scale),
+            LookupOp::IsOdd => "is_odd".to_string(),
+            LookupOp::Div { denom } => format!("div_{}", denom),
+            LookupOp::Sigmoid { scale } => format!("sigmoid_{}", scale),
+            LookupOp::Erf { scale } => format!("erf_{}", scale),
+            LookupOp::Exp { scale, base } => format!("exp_{}_{}", scale, base),
+            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 + IntoI64>(
+    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_i64(x));
-        let res = match &self {
-            LookupOp::Abs => Ok(tensor::ops::abs(&x)?),
-            LookupOp::Ceil { scale } => Ok(tensor::ops::nonlinearities::ceil(&x, scale.into())),
-            LookupOp::Floor { scale } => Ok(tensor::ops::nonlinearities::floor(&x, scale.into())),
-            LookupOp::Round { scale } => Ok(tensor::ops::nonlinearities::round(&x, scale.into())),
-            LookupOp::RoundHalfToEven { scale } => Ok(
-                tensor::ops::nonlinearities::round_half_to_even(&x, scale.into()),
-            ),
-            LookupOp::Pow { scale, a } => Ok(tensor::ops::nonlinearities::pow(
-                &x,
-                scale.0.into(),
-                a.0.into(),
-            )),
-            LookupOp::KroneckerDelta => Ok(tensor::ops::nonlinearities::kronecker_delta(&x)),
-            LookupOp::Max { scale, a } => Ok(tensor::ops::nonlinearities::max(
-                &x,
-                scale.0.into(),
-                a.0.into(),
-            )),
-            LookupOp::Min { scale, a } => Ok(tensor::ops::nonlinearities::min(
-                &x,
-                scale.0.into(),
-                a.0.into(),
-            )),
-            LookupOp::Sign => Ok(tensor::ops::nonlinearities::sign(&x)),
-            LookupOp::LessThan { a } => Ok(tensor::ops::nonlinearities::less_than(
-                &x,
-                f32::from(*a).into(),
-            )),
-            LookupOp::LessThanEqual { a } => Ok(tensor::ops::nonlinearities::less_than_equal(
-                &x,
-                f32::from(*a).into(),
-            )),
-            LookupOp::GreaterThan { a } => Ok(tensor::ops::nonlinearities::greater_than(
-                &x,
-                f32::from(*a).into(),
-            )),
-            LookupOp::GreaterThanEqual { a } => Ok(
-                tensor::ops::nonlinearities::greater_than_equal(&x, f32::from(*a).into()),
-            ),
-            LookupOp::Div { denom } => Ok(tensor::ops::nonlinearities::const_div(
-                &x,
-                f32::from(*denom).into(),
-            )),
-            LookupOp::Cast { scale } => Ok(tensor::ops::nonlinearities::const_div(
-                &x,
-                f32::from(*scale).into(),
-            )),
-            LookupOp::Recip {
-                input_scale,
-                output_scale,
-            } => Ok(tensor::ops::nonlinearities::recip(
-                &x,
-                input_scale.into(),
-                output_scale.into(),
-            )),
-            LookupOp::ReLU => Ok(tensor::ops::nonlinearities::leakyrelu(&x, 0_f64)),
+        let x = x[0].clone().map(|x| felt_to_integer_rep(x));
+        let res =
+            match &self {
+                LookupOp::Ln { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::ln(&x, scale.into()))
+                }
+                LookupOp::PowersOfTwo { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::ipow2(&x, scale.0.into()))
+                }
+                LookupOp::IsOdd => Ok::<_, TensorError>(tensor::ops::nonlinearities::is_odd(&x)),
+                LookupOp::Pow { scale, a } => Ok::<_, TensorError>(
+                    tensor::ops::nonlinearities::pow(&x, scale.0.into(), a.0.into()),
+                ),
+                LookupOp::Div { denom } => Ok::<_, TensorError>(
+                    tensor::ops::nonlinearities::const_div(&x, f32::from(*denom).into()),
+                ),
+                LookupOp::Sigmoid { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::sigmoid(&x, scale.into()))
+                }
+                LookupOp::Erf { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::erffunc(&x, scale.into()))
+                }
+                LookupOp::Exp { scale, base } => Ok::<_, TensorError>(
+                    tensor::ops::nonlinearities::exp(&x, scale.into(), base.into()),
+                ),
+                LookupOp::Cos { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::cos(&x, scale.into()))
+                }
+                LookupOp::ACos { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::acos(&x, scale.into()))
+                }
+                LookupOp::Cosh { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::cosh(&x, scale.into()))
+                }
+                LookupOp::ACosh { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::acosh(&x, scale.into()))
+                }
+                LookupOp::Sin { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::sin(&x, scale.into()))
+                }
+                LookupOp::ASin { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::asin(&x, scale.into()))
+                }
+                LookupOp::Sinh { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::sinh(&x, scale.into()))
+                }
+                LookupOp::ASinh { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::asinh(&x, scale.into()))
+                }
+                LookupOp::Tan { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::tan(&x, scale.into()))
+                }
+                LookupOp::ATan { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::atan(&x, scale.into()))
+                }
+                LookupOp::ATanh { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::atanh(&x, scale.into()))
+                }
+                LookupOp::Tanh { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::tanh(&x, scale.into()))
+                }
+                LookupOp::HardSwish { scale } => {
+                    Ok::<_, TensorError>(tensor::ops::nonlinearities::hardswish(&x, scale.into()))
+                }
+            }?;
 
-            LookupOp::LeakyReLU { slope: a } => {
-                Ok(tensor::ops::nonlinearities::leakyrelu(&x, a.0.into()))
-            }
-            LookupOp::Sigmoid { scale } => {
-                Ok(tensor::ops::nonlinearities::sigmoid(&x, scale.into()))
-            }
-            LookupOp::Sqrt { scale } => Ok(tensor::ops::nonlinearities::sqrt(&x, scale.into())),
-            LookupOp::Rsqrt { scale } => Ok(tensor::ops::nonlinearities::rsqrt(&x, scale.into())),
-            LookupOp::Erf { scale } => Ok(tensor::ops::nonlinearities::erffunc(&x, scale.into())),
-            LookupOp::Exp { scale } => Ok(tensor::ops::nonlinearities::exp(&x, scale.into())),
-            LookupOp::Ln { scale } => Ok(tensor::ops::nonlinearities::ln(&x, scale.into())),
-            LookupOp::Cos { scale } => Ok(tensor::ops::nonlinearities::cos(&x, scale.into())),
-            LookupOp::ACos { scale } => Ok(tensor::ops::nonlinearities::acos(&x, scale.into())),
-            LookupOp::Cosh { scale } => Ok(tensor::ops::nonlinearities::cosh(&x, scale.into())),
-            LookupOp::ACosh { scale } => Ok(tensor::ops::nonlinearities::acosh(&x, scale.into())),
-            LookupOp::Sin { scale } => Ok(tensor::ops::nonlinearities::sin(&x, scale.into())),
-            LookupOp::ASin { scale } => Ok(tensor::ops::nonlinearities::asin(&x, scale.into())),
-            LookupOp::Sinh { scale } => Ok(tensor::ops::nonlinearities::sinh(&x, scale.into())),
-            LookupOp::ASinh { scale } => Ok(tensor::ops::nonlinearities::asinh(&x, scale.into())),
-            LookupOp::Tan { scale } => Ok(tensor::ops::nonlinearities::tan(&x, scale.into())),
-            LookupOp::ATan { scale } => Ok(tensor::ops::nonlinearities::atan(&x, scale.into())),
-            LookupOp::ATanh { scale } => Ok(tensor::ops::nonlinearities::atanh(&x, scale.into())),
-            LookupOp::Tanh { scale } => Ok(tensor::ops::nonlinearities::tanh(&x, scale.into())),
-            LookupOp::HardSwish { scale } => {
-                Ok(tensor::ops::nonlinearities::hardswish(&x, scale.into()))
-            }
-        }?;
-
-        let output = res.map(|x| i64_to_felt(x));
+        let output = res.map(|x| integer_rep_to_felt(x));
 
         Ok(ForwardResult { output })
     }
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for LookupOp {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for LookupOp {
     /// Returns a reference to the Any trait.
     fn as_any(&self) -> &dyn Any {
         self
@@ -242,37 +158,14 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
     /// Returns the name of the operation
     fn as_string(&self) -> String {
         match self {
-            LookupOp::Abs => "ABS".into(),
-            LookupOp::Ceil { scale } => format!("CEIL(scale={})", scale),
-            LookupOp::Floor { scale } => format!("FLOOR(scale={})", scale),
-            LookupOp::Round { scale } => format!("ROUND(scale={})", scale),
-            LookupOp::RoundHalfToEven { scale } => format!("ROUND_HALF_TO_EVEN(scale={})", scale),
-            LookupOp::Pow { a, scale } => format!("POW(scale={}, exponent={})", scale, a),
-            LookupOp::KroneckerDelta => "K_DELTA".into(),
-            LookupOp::Max { scale, a } => format!("MAX(scale={}, a={})", scale, a),
-            LookupOp::Min { scale, a } => format!("MIN(scale={}, a={})", scale, a),
-            LookupOp::Sign => "SIGN".into(),
-            LookupOp::GreaterThan { a } => format!("GREATER_THAN(a={})", a),
-            LookupOp::GreaterThanEqual { a } => format!("GREATER_THAN_EQUAL(a={})", a),
-            LookupOp::LessThan { a } => format!("LESS_THAN(a={})", a),
-            LookupOp::LessThanEqual { a } => format!("LESS_THAN_EQUAL(a={})", a),
-            LookupOp::Recip {
-                input_scale,
-                output_scale,
-            } => format!(
-                "RECIP(input_scale={}, output_scale={})",
-                input_scale, output_scale
-            ),
-            LookupOp::Div { denom, .. } => format!("DIV(denom={})", denom),
-            LookupOp::Cast { scale } => format!("CAST(scale={})", scale),
             LookupOp::Ln { scale } => format!("LN(scale={})", scale),
-            LookupOp::ReLU => "RELU".to_string(),
-            LookupOp::LeakyReLU { slope: a } => format!("L_RELU(slope={})", a),
+            LookupOp::PowersOfTwo { scale } => format!("POWERS_OF_TWO(scale={})", scale),
+            LookupOp::IsOdd => "IS_ODD".to_string(),
+            LookupOp::Pow { a, scale } => format!("POW(scale={}, exponent={})", scale, a),
+            LookupOp::Div { denom, .. } => format!("DIV(denom={})", denom),
             LookupOp::Sigmoid { scale } => format!("SIGMOID(scale={})", scale),
-            LookupOp::Sqrt { scale } => format!("SQRT(scale={})", scale),
             LookupOp::Erf { scale } => format!("ERF(scale={})", scale),
-            LookupOp::Rsqrt { scale } => format!("RSQRT(scale={})", scale),
-            LookupOp::Exp { scale } => format!("EXP(scale={})", scale),
+            LookupOp::Exp { scale, base } => format!("EXP(scale={}, base={})", scale, base),
             LookupOp::Tan { scale } => format!("TAN(scale={})", scale),
             LookupOp::ATan { scale } => format!("ATAN(scale={})", scale),
             LookupOp::Tanh { scale } => format!("TANH(scale={})", scale),
@@ -305,20 +198,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
 
     /// Returns the scale of the output of the operation.
     fn out_scale(&self, inputs_scale: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
-        let scale = match self {
-            LookupOp::Cast { scale } => {
-                let in_scale = inputs_scale[0];
-                in_scale + multiplier_to_scale(1. / scale.0 as f64)
-            }
-            LookupOp::Recip { output_scale, .. } => multiplier_to_scale(output_scale.into()),
-            LookupOp::Sign
-            | LookupOp::GreaterThan { .. }
-            | LookupOp::LessThan { .. }
-            | LookupOp::GreaterThanEqual { .. }
-            | LookupOp::LessThanEqual { .. }
-            | LookupOp::KroneckerDelta => 0,
-            _ => inputs_scale[0],
-        };
+        let scale = inputs_scale[0];
         Ok(scale)
     }
 

src/circuit/ops/mod.rs

@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     graph::quantize_tensor,
-    tensor::{self, IntoI64, Tensor, TensorType, ValTensor},
+    tensor::{self, Tensor, TensorType, ValTensor},
 };
 use halo2curves::ff::PrimeField;
 
@@ -31,12 +31,12 @@ 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 + IntoI64> {
+pub struct ForwardResult<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
     pub(crate) output: Tensor<F>,
 }
 
 /// A trait representing operations that can be represented as constraints in a circuit.
-pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64>:
+pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>:
     std::fmt::Debug + Send + Sync + Any
 {
     /// Returns a string representation of the operation.
@@ -75,7 +75,7 @@ pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64
     fn as_any(&self) -> &dyn Any;
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Clone for Box<dyn Op<F>> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Clone for Box<dyn Op<F>> {
     fn clone(&self) -> Self {
         self.clone_dyn()
     }
@@ -105,7 +105,10 @@ impl InputType {
     }
 
     ///
-    pub fn roundtrip<T: num::ToPrimitive + num::FromPrimitive + Clone>(&self, input: &mut T) {
+    pub fn roundtrip<T: num::ToPrimitive + num::FromPrimitive + Clone + std::fmt::Debug>(
+        &self,
+        input: &mut T,
+    ) {
         match self {
             InputType::Bool => {
                 let boolean_input = input.clone().to_i64().unwrap();
@@ -118,7 +121,7 @@ impl InputType {
                 *input = T::from_f32(f32_input).unwrap();
             }
             InputType::F32 => {
-                let f32_input = input.clone().to_f32().unwrap();
+                let f32_input: f32 = input.clone().to_f32().unwrap();
                 *input = T::from_f32(f32_input).unwrap();
             }
             InputType::F64 => {
@@ -133,6 +136,22 @@ impl InputType {
     }
 }
 
+impl std::str::FromStr for InputType {
+    type Err = CircuitError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "bool" => Ok(InputType::Bool),
+            "f16" => Ok(InputType::F16),
+            "f32" => Ok(InputType::F32),
+            "f64" => Ok(InputType::F64),
+            "int" => Ok(InputType::Int),
+            "tdim" => Ok(InputType::TDim),
+            e => Err(CircuitError::InvalidInputType(e.to_string())),
+        }
+    }
+}
+
 ///
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct Input {
@@ -142,7 +161,7 @@ pub struct Input {
     pub datum_type: InputType,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for Input {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input {
     fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
         Ok(self.scale)
     }
@@ -197,7 +216,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct Unknown;
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for Unknown {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Unknown {
     fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
         Ok(0)
     }
@@ -224,7 +243,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
 
 ///
 #[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> {
+pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
     ///
     pub quantized_values: Tensor<F>,
     ///
@@ -234,7 +253,7 @@ pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash +
     pub pre_assigned_val: Option<ValTensor<F>>,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Constant<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Constant<F> {
     ///
     pub fn new(quantized_values: Tensor<F>, raw_values: Tensor<f32>) -> Self {
         Self {
@@ -255,7 +274,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Consta
         self.raw_values = Tensor::new(None, &[0]).unwrap();
     }
 
-    ///
+    /// Pre-assign a value
     pub fn pre_assign(&mut self, val: ValTensor<F>) {
         self.pre_assigned_val = Some(val)
     }
@@ -267,8 +286,7 @@ impl<
             + PartialOrd
             + std::hash::Hash
             + Serialize
-            + for<'de> Deserialize<'de>
-            + IntoI64,
+            + for<'de> Deserialize<'de>,
     > Op<F> for Constant<F>
 {
     fn as_any(&self) -> &dyn Any {

src/circuit/ops/poly.rs

@@ -1,5 +1,8 @@
 use crate::{
-    circuit::layouts,
+    circuit::{
+        layouts,
+        utils::{self, F32},
+    },
     tensor::{self, Tensor, TensorError},
 };
 
@@ -9,6 +12,12 @@ use super::{base::BaseOp, *};
 /// An enum representing the operations that can be expressed as arithmetic (non lookup) operations.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum PolyOp {
+    Abs,
+    Sign,
+    LeakyReLU {
+        slope: utils::F32,
+        scale: i32,
+    },
     GatherElements {
         dim: usize,
         constant_idx: Option<Tensor<usize>>,
@@ -33,6 +42,7 @@ pub enum PolyOp {
     Conv {
         padding: Vec<(usize, usize)>,
         stride: Vec<usize>,
+        group: usize,
     },
     Downsample {
         axis: usize,
@@ -43,6 +53,7 @@ pub enum PolyOp {
         padding: Vec<(usize, usize)>,
         output_padding: Vec<usize>,
         stride: Vec<usize>,
+        group: usize,
     },
     Add,
     Sub,
@@ -97,8 +108,7 @@ impl<
             + PartialOrd
             + std::hash::Hash
             + Serialize
-            + for<'de> Deserialize<'de>
-            + IntoI64,
+            + for<'de> Deserialize<'de>,
     > Op<F> for PolyOp
 {
     /// Returns a reference to the Any trait.
@@ -108,6 +118,9 @@ impl<
 
     fn as_string(&self) -> String {
         match &self {
+            PolyOp::LeakyReLU { slope: a, .. } => format!("LEAKYRELU (slope={})", a),
+            PolyOp::Abs => "ABS".to_string(),
+            PolyOp::Sign => "SIGN".to_string(),
             PolyOp::GatherElements { dim, constant_idx } => format!(
                 "GATHERELEMENTS (dim={}, constant_idx{})",
                 dim,
@@ -148,17 +161,25 @@ impl<
             PolyOp::Sum { axes } => format!("SUM (axes={:?})", axes),
             PolyOp::Prod { .. } => "PROD".into(),
             PolyOp::Pow(_) => "POW".into(),
-            PolyOp::Conv { stride, padding } => {
-                format!("CONV (stride={:?}, padding={:?})", stride, padding)
+            PolyOp::Conv {
+                stride,
+                padding,
+                group,
+            } => {
+                format!(
+                    "CONV (stride={:?}, padding={:?}, group={})",
+                    stride, padding, group
+                )
             }
             PolyOp::DeConv {
                 stride,
                 padding,
                 output_padding,
+                group,
             } => {
                 format!(
-                    "DECONV (stride={:?}, padding={:?}, output_padding={:?})",
-                    stride, padding, output_padding
+                    "DECONV (stride={:?}, padding={:?}, output_padding={:?}, group={})",
+                    stride, padding, output_padding, group
                 )
             }
             PolyOp::Concat { axis } => format!("CONCAT (axis={})", axis),
@@ -181,6 +202,11 @@ impl<
         values: &[ValTensor<F>],
     ) -> Result<Option<ValTensor<F>>, CircuitError> {
         Ok(Some(match self {
+            PolyOp::Abs => layouts::abs(config, region, values[..].try_into()?)?,
+            PolyOp::Sign => layouts::sign(config, region, values[..].try_into()?)?,
+            PolyOp::LeakyReLU { slope, scale } => {
+                layouts::leaky_relu(config, region, values[..].try_into()?, slope, scale)?
+            }
             PolyOp::MultiBroadcastTo { shape } => {
                 layouts::expand(config, region, values[..].try_into()?, shape)?
             }
@@ -212,9 +238,18 @@ impl<
             PolyOp::Prod { axes, .. } => {
                 layouts::prod_axes(config, region, values[..].try_into()?, axes)?
             }
-            PolyOp::Conv { padding, stride } => {
-                layouts::conv(config, region, values[..].try_into()?, padding, stride)?
-            }
+            PolyOp::Conv {
+                padding,
+                stride,
+                group,
+            } => layouts::conv(
+                config,
+                region,
+                values[..].try_into()?,
+                padding,
+                stride,
+                *group,
+            )?,
             PolyOp::GatherElements { dim, constant_idx } => {
                 if let Some(idx) = constant_idx {
                     tensor::ops::gather_elements(values[0].get_inner_tensor()?, idx, *dim)?.into()
@@ -261,6 +296,7 @@ impl<
                 padding,
                 output_padding,
                 stride,
+                group,
             } => layouts::deconv(
                 config,
                 region,
@@ -268,6 +304,7 @@ 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)?,
@@ -300,6 +337,12 @@ impl<
 
     fn out_scale(&self, in_scales: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
         let scale = match self {
+            // this corresponds to the relu operation
+            PolyOp::LeakyReLU {
+                slope: F32(0.0), ..
+            } => in_scales[0],
+            // this corresponds to the leaky relu operation with a slope which induces a change in scale
+            PolyOp::LeakyReLU { scale, .. } => in_scales[0] + *scale,
             PolyOp::MeanOfSquares { .. } => 2 * in_scales[0],
             PolyOp::Xor | PolyOp::Or | PolyOp::And | PolyOp::Not => 0,
             PolyOp::Iff => in_scales[1],
@@ -347,6 +390,7 @@ impl<
             PolyOp::Reshape(_) | PolyOp::Flatten(_) => in_scales[0],
             PolyOp::Pow(pow) => in_scales[0] * (*pow as crate::Scale),
             PolyOp::Identity { out_scale } => out_scale.unwrap_or(in_scales[0]),
+            PolyOp::Sign { .. } => 0,
             _ => in_scales[0],
         };
         Ok(scale)

src/circuit/ops/region.rs

@@ -1,8 +1,9 @@
 use crate::{
     circuit::table::Range,
+    fieldutils::IntegerRep,
     tensor::{Tensor, TensorType, ValTensor, ValType, VarTensor},
 };
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use colored::Colorize;
 use halo2_proofs::{
     circuit::Region,
@@ -11,7 +12,6 @@ use halo2_proofs::{
 use halo2curves::ff::PrimeField;
 use itertools::Itertools;
 use maybe_rayon::iter::ParallelExtend;
-use portable_atomic::AtomicI64 as AtomicInt;
 use std::{
     cell::RefCell,
     collections::{HashMap, HashSet},
@@ -86,6 +86,88 @@ 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,
+    /// base for decompositions
+    pub base: usize,
+    /// number of legs for decompositions
+    pub legs: usize,
+}
+
+#[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, base: usize, legs: usize) -> RegionSettings {
+        RegionSettings {
+            witness_gen,
+            check_range,
+            base,
+            legs,
+        }
+    }
+
+    /// Create a new region settings with all true
+    pub fn all_true(base: usize, legs: usize) -> RegionSettings {
+        RegionSettings {
+            witness_gen: true,
+            check_range: true,
+            base,
+            legs,
+        }
+    }
+
+    /// Create a new region settings with all false
+    pub fn all_false(base: usize, legs: usize) -> RegionSettings {
+        RegionSettings {
+            witness_gen: false,
+            check_range: false,
+            base,
+            legs,
+        }
+    }
+}
+
+#[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());
+    }
+}
+
+#[allow(unsafe_code)]
+unsafe impl Sync for RegionStatistics {}
+#[allow(unsafe_code)]
+unsafe impl Send for RegionStatistics {}
+
 #[derive(Debug)]
 /// A context for a region
 pub struct RegionCtx<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
@@ -95,22 +177,33 @@ pub struct RegionCtx<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Ha
     num_inner_cols: usize,
     dynamic_lookup_index: DynamicLookupIndex,
     shuffle_index: ShuffleIndex,
-    used_lookups: HashSet<LookupOp>,
-    used_range_checks: HashSet<Range>,
-    max_lookup_inputs: i64,
-    min_lookup_inputs: i64,
-    max_range_size: i64,
-    witness_gen: bool,
-    check_lookup_range: bool,
+    statistics: RegionStatistics,
+    settings: RegionSettings,
     assigned_constants: ConstantsMap<F>,
+    max_dynamic_input_len: usize,
 }
 
 impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a, F> {
-    #[cfg(not(target_arch = "wasm32"))]
+    /// get the region's decomposition base
+    pub fn base(&self) -> usize {
+        self.settings.base
+    }
+
+    /// get the region's decomposition legs
+    pub fn legs(&self) -> usize {
+        self.settings.legs
+    }
+
+    /// get the max dynamic input len
+    pub fn max_dynamic_input_len(&self) -> usize {
+        self.max_dynamic_input_len
+    }
+
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     ///
     pub fn debug_report(&self) {
         log::debug!(
-            "(rows={}, coord={}, constants={}, max_lookup_inputs={}, min_lookup_inputs={}, max_range_size={}, dynamic_lookup_col_coord={}, shuffle_col_coord={})",
+            "(rows={}, coord={}, constants={}, max_lookup_inputs={}, min_lookup_inputs={}, max_range_size={}, dynamic_lookup_col_coord={}, shuffle_col_coord={}, max_dynamic_input_len={})",
             self.row().to_string().blue(),
             self.linear_coord().to_string().yellow(),
             self.total_constants().to_string().red(),
@@ -118,7 +211,9 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             self.min_lookup_inputs().to_string().green(),
             self.max_range_size().to_string().green(),
             self.dynamic_lookup_col_coord().to_string().green(),
-            self.shuffle_col_coord().to_string().green());
+            self.shuffle_col_coord().to_string().green(),
+            self.max_dynamic_input_len().to_string().green()
+        );
     }
 
     ///
@@ -136,6 +231,11 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         self.dynamic_lookup_index.index += n;
     }
 
+    /// increment the max dynamic input len
+    pub fn update_max_dynamic_input_len(&mut self, n: usize) {
+        self.max_dynamic_input_len = self.max_dynamic_input_len.max(n);
+    }
+
     ///
     pub fn increment_dynamic_lookup_col_coord(&mut self, n: usize) {
         self.dynamic_lookup_index.col_coord += n;
@@ -153,16 +253,27 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
 
     ///
     pub fn witness_gen(&self) -> bool {
-        self.witness_gen
+        self.settings.witness_gen
     }
 
     ///
-    pub fn check_lookup_range(&self) -> bool {
-        self.check_lookup_range
+    pub fn check_range(&self) -> bool {
+        self.settings.check_range
+    }
+
+    ///
+    pub fn statistics(&self) -> &RegionStatistics {
+        &self.statistics
     }
 
     /// Create a new region context
-    pub fn new(region: Region<'a, F>, row: usize, num_inner_cols: usize) -> RegionCtx<'a, F> {
+    pub fn new(
+        region: Region<'a, F>,
+        row: usize,
+        num_inner_cols: usize,
+        decomp_base: usize,
+        decomp_legs: usize,
+    ) -> RegionCtx<'a, F> {
         let region = Some(RefCell::new(region));
         let linear_coord = row * num_inner_cols;
 
@@ -173,14 +284,10 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             linear_coord,
             dynamic_lookup_index: DynamicLookupIndex::default(),
             shuffle_index: ShuffleIndex::default(),
-            used_lookups: HashSet::new(),
-            used_range_checks: HashSet::new(),
-            max_lookup_inputs: 0,
-            min_lookup_inputs: 0,
-            max_range_size: 0,
-            witness_gen: true,
-            check_lookup_range: true,
+            statistics: RegionStatistics::default(),
+            settings: RegionSettings::all_true(decomp_base, decomp_legs),
             assigned_constants: HashMap::new(),
+            max_dynamic_input_len: 0,
         }
     }
 
@@ -189,45 +296,20 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         region: Region<'a, F>,
         row: usize,
         num_inner_cols: usize,
+        decomp_base: usize,
+        decomp_legs: usize,
         constants: ConstantsMap<F>,
     ) -> RegionCtx<'a, F> {
-        let mut new_self = Self::new(region, row, num_inner_cols);
+        let mut new_self = Self::new(region, row, num_inner_cols, decomp_base, decomp_legs);
         new_self.assigned_constants = constants;
         new_self
     }
-    /// 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,
-        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,
-            check_lookup_range: false,
-            assigned_constants: HashMap::new(),
-        }
-    }
 
     /// Create a new region context
     pub fn new_dummy(
         row: usize,
         num_inner_cols: usize,
-        witness_gen: bool,
-        check_lookup_range: bool,
+        settings: RegionSettings,
     ) -> RegionCtx<'a, F> {
         let region = None;
         let linear_coord = row * num_inner_cols;
@@ -239,14 +321,10 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             row,
             dynamic_lookup_index: DynamicLookupIndex::default(),
             shuffle_index: ShuffleIndex::default(),
-            used_lookups: HashSet::new(),
-            used_range_checks: HashSet::new(),
-            max_lookup_inputs: 0,
-            min_lookup_inputs: 0,
-            max_range_size: 0,
-            witness_gen,
-            check_lookup_range,
+            statistics: RegionStatistics::default(),
+            settings,
             assigned_constants: HashMap::new(),
+            max_dynamic_input_len: 0,
         }
     }
 
@@ -255,8 +333,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         row: usize,
         linear_coord: usize,
         num_inner_cols: usize,
-        witness_gen: bool,
-        check_lookup_range: bool,
+        settings: RegionSettings,
     ) -> RegionCtx<'a, F> {
         let region = None;
         RegionCtx {
@@ -266,14 +343,10 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             row,
             dynamic_lookup_index: DynamicLookupIndex::default(),
             shuffle_index: ShuffleIndex::default(),
-            used_lookups: HashSet::new(),
-            used_range_checks: HashSet::new(),
-            max_lookup_inputs: 0,
-            min_lookup_inputs: 0,
-            max_range_size: 0,
-            witness_gen,
-            check_lookup_range,
+            statistics: RegionStatistics::default(),
+            settings,
             assigned_constants: HashMap::new(),
+            max_dynamic_input_len: 0,
         }
     }
 
@@ -323,12 +396,9 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
     ) -> Result<(), CircuitError> {
         let row = AtomicUsize::new(self.row());
         let linear_coord = AtomicUsize::new(self.linear_coord());
-        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 statistics = Arc::new(Mutex::new(self.statistics.clone()));
         let shuffle_index = Arc::new(Mutex::new(self.shuffle_index.clone()));
+        let dynamic_lookup_index = Arc::new(Mutex::new(self.dynamic_lookup_index.clone()));
         let constants = Arc::new(Mutex::new(self.assigned_constants.clone()));
 
         *output = output.par_enum_map(|idx, _| {
@@ -342,8 +412,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
                 starting_offset,
                 starting_linear_coord,
                 self.num_inner_cols,
-                self.witness_gen,
-                self.check_lookup_range,
+                self.settings.clone(),
             );
             let res = inner_loop_function(idx, &mut local_reg);
             // we update the offset and constants
@@ -353,14 +422,9 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
                 Ordering::SeqCst,
             );
 
-            max_lookup_inputs.fetch_max(local_reg.max_lookup_inputs(), Ordering::SeqCst);
-            min_lookup_inputs.fetch_min(local_reg.min_lookup_inputs(), Ordering::SeqCst);
             // update the lookups
-            let mut lookups = lookups.lock().unwrap();
-            lookups.extend(local_reg.used_lookups());
-            // update the range checks
-            let mut range_checks = range_checks.lock().unwrap();
-            range_checks.extend(local_reg.used_range_checks());
+            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);
@@ -374,20 +438,11 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             res
         })?;
         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.used_lookups = Arc::try_unwrap(lookups)
+        self.statistics = Arc::try_unwrap(statistics)
             .map_err(|e| CircuitError::GetLookupsError(format!("{:?}", e)))?
             .into_inner()
             .map_err(|e| CircuitError::GetLookupsError(format!("{:?}", e)))?;
-        self.used_range_checks = Arc::try_unwrap(range_checks)
-            .map_err(|e| CircuitError::GetRangeChecksError(format!("{:?}", e)))?
-            .into_inner()
-            .map_err(|e| CircuitError::GetRangeChecksError(format!("{:?}", e)))?;
         self.dynamic_lookup_index = Arc::try_unwrap(dynamic_lookup_index)
             .map_err(|e| CircuitError::GetDynamicLookupError(format!("{:?}", e)))?
             .into_inner()
@@ -411,11 +466,22 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
     ) -> Result<(), CircuitError> {
         let (mut min, mut max) = (0, 0);
         for i in inputs {
-            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());
+            max = max.max(i.int_evals()?.into_iter().max().unwrap_or_default());
+            min = min.min(i.int_evals()?.into_iter().min().unwrap_or_default());
         }
-        self.max_lookup_inputs = self.max_lookup_inputs.max(max);
-        self.min_lookup_inputs = self.min_lookup_inputs.min(min);
+        self.statistics.max_lookup_inputs = self.statistics.max_lookup_inputs.max(max);
+        self.statistics.min_lookup_inputs = self.statistics.min_lookup_inputs.min(min);
+        Ok(())
+    }
+
+    /// Update the max and min forcefully
+    pub fn update_max_min_lookup_inputs_force(
+        &mut self,
+        min: IntegerRep,
+        max: IntegerRep,
+    ) -> Result<(), CircuitError> {
+        self.statistics.max_lookup_inputs = self.statistics.max_lookup_inputs.max(max);
+        self.statistics.min_lookup_inputs = self.statistics.min_lookup_inputs.min(min);
         Ok(())
     }
 
@@ -427,7 +493,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
 
         let range_size = (range.1 - range.0).abs();
 
-        self.max_range_size = self.max_range_size.max(range_size);
+        self.statistics.max_range_size = self.statistics.max_range_size.max(range_size);
         Ok(())
     }
 
@@ -442,13 +508,13 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         lookup: LookupOp,
         inputs: &[ValTensor<F>],
     ) -> Result<(), CircuitError> {
-        self.used_lookups.insert(lookup);
+        self.statistics.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.used_range_checks.insert(range);
+        self.statistics.used_range_checks.insert(range);
         self.update_max_min_lookup_range(range)
     }
 
@@ -489,27 +555,27 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
 
     /// get used lookups
     pub fn used_lookups(&self) -> HashSet<LookupOp> {
-        self.used_lookups.clone()
+        self.statistics.used_lookups.clone()
     }
 
     /// get used range checks
     pub fn used_range_checks(&self) -> HashSet<Range> {
-        self.used_range_checks.clone()
+        self.statistics.used_range_checks.clone()
     }
 
     /// max lookup inputs
-    pub fn max_lookup_inputs(&self) -> i64 {
-        self.max_lookup_inputs
+    pub fn max_lookup_inputs(&self) -> IntegerRep {
+        self.statistics.max_lookup_inputs
     }
 
     /// min lookup inputs
-    pub fn min_lookup_inputs(&self) -> i64 {
-        self.min_lookup_inputs
+    pub fn min_lookup_inputs(&self) -> IntegerRep {
+        self.statistics.min_lookup_inputs
     }
 
     /// max range check
-    pub fn max_range_size(&self) -> i64 {
-        self.max_range_size
+    pub fn max_range_size(&self) -> IntegerRep {
+        self.statistics.max_range_size
     }
 
     /// Assign a valtensor to a vartensor
@@ -544,9 +610,11 @@ 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>, usize), CircuitError> {
+        self.update_max_dynamic_input_len(values.len());
+
         if let Some(region) = &self.region {
-            Ok(var.assign(
+            Ok(var.assign_exact_column(
                 &mut region.borrow_mut(),
                 self.combined_dynamic_shuffle_coord(),
                 values,
@@ -557,7 +625,11 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
                 let values_map = values.create_constants_map_iterator();
                 self.assigned_constants.par_extend(values_map);
             }
-            Ok(values.clone())
+
+            let flush_len = var.get_column_flush(self.combined_dynamic_shuffle_coord(), values)?;
+
+            // get the diff between the current column and the next row
+            Ok((values.clone(), flush_len))
         }
     }
 
@@ -566,7 +638,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>, usize), CircuitError> {
         self.assign_dynamic_lookup(var, values)
     }
 

src/circuit/table.rs

@@ -11,20 +11,33 @@ use maybe_rayon::prelude::{IntoParallelIterator, ParallelIterator};
 
 use crate::{
     circuit::CircuitError,
-    fieldutils::i64_to_felt,
-    tensor::{IntoI64, Tensor, TensorType},
+    fieldutils::{integer_rep_to_felt, IntegerRep},
+    tensor::{Tensor, TensorType},
 };
 
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
+use crate::execute::EZKL_REPO_PATH;
+
 use crate::circuit::lookup::LookupOp;
 
 /// The range of the lookup table.
-pub type Range = (i64, i64);
+pub type Range = (IntegerRep, IntegerRep);
 
 /// The safety factor for the range of the lookup table.
-pub const RANGE_MULTIPLIER: i64 = 2;
+pub const RANGE_MULTIPLIER: IntegerRep = 2;
 /// The safety factor offset for the number of rows in the lookup table.
 pub const RESERVED_BLINDING_ROWS_PAD: usize = 3;
 
+#[cfg(all(feature = "ezkl", 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(any(not(feature = "ezkl"), target_arch = "wasm32"))]
+pub const LOOKUP_CACHE: &str = "";
+
 #[derive(Debug, Clone)]
 ///
 pub struct SelectorConstructor<F: PrimeField> {
@@ -96,21 +109,22 @@ pub struct Table<F: PrimeField> {
     _marker: PhantomData<F>,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<F> {
+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_i64(input) - self.range.0).abs() / (self.col_size as i64);
+        let chunk = (crate::fieldutils::felt_to_integer_rep(input) - self.range.0).abs()
+            / (self.col_size as IntegerRep);
 
-        i64_to_felt(chunk)
+        integer_rep_to_felt(chunk)
     }
 
     /// get first_element of column
     pub fn get_first_element(&self, chunk: usize) -> (F, F) {
-        let chunk = chunk as i64;
+        let chunk = chunk as IntegerRep;
         // we index from 1 to prevent soundness issues
-        let first_element = i64_to_felt(chunk * (self.col_size as i64) + self.range.0);
+        let first_element =
+            integer_rep_to_felt(chunk * (self.col_size as IntegerRep) + self.range.0);
         let op_f = self
             .nonlinearity
             .f(&[Tensor::from(vec![first_element].into_iter())])
@@ -130,12 +144,24 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<
 }
 
 ///
-pub fn num_cols_required(range_len: i64, col_size: usize) -> usize {
+pub fn num_cols_required(range_len: IntegerRep, col_size: usize) -> usize {
     // number of cols needed to store the range
-    (range_len / (col_size as i64)) as usize + 1
+    (range_len / (col_size as IntegerRep)) as usize + 1
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
+    /// get largest element represented by the range
+    pub fn largest(&self) -> IntegerRep {
+        self.range.0 + (self.col_size * self.table_inputs.len() - 1) as IntegerRep
+    }
+    fn name(&self) -> String {
+        format!(
+            "{}_{}_{}",
+            self.nonlinearity.as_path(),
+            self.range.0,
+            self.largest()
+        )
+    }
     /// Configures the table.
     pub fn configure(
         cs: &mut ConstraintSystem<F>,
@@ -200,10 +226,53 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<
         }
 
         let smallest = self.range.0;
-        let largest = self.range.1;
+        let largest = self.largest();
+
+        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| i64_to_felt(x));
-        let evals = self.nonlinearity.f(&[inputs.clone()])?;
         let chunked_inputs = inputs.chunks(self.col_size);
 
         self.is_assigned = true;
@@ -226,6 +295,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<
 
                                 row_offset += chunk_idx * self.col_size;
                                 let (x, y) = self.cartesian_coord(row_offset);
+
                                 if !preassigned_input {
                                     table.assign_cell(
                                         || format!("nl_i_col row {}", row_offset),
@@ -235,7 +305,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<
                                     )?;
                                 }
 
-                                let output = evals.output[row_offset];
+                                let output = evals[row_offset];
 
                                 table.assign_cell(
                                     || format!("nl_o_col row {}", row_offset),
@@ -272,12 +342,17 @@ pub struct RangeCheck<F: PrimeField> {
     _marker: PhantomData<F>,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeCheck<F> {
+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 i64;
+        let chunk = chunk as IntegerRep;
         // we index from 1 to prevent soundness issues
-        i64_to_felt(chunk * (self.col_size as i64) + self.range.0)
+        integer_rep_to_felt(chunk * (self.col_size as IntegerRep) + self.range.0)
     }
 
     ///
@@ -293,14 +368,14 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeC
     /// 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_i64(input) - self.range.0).abs() / (self.col_size as i64);
+        let chunk = (crate::fieldutils::felt_to_integer_rep(input) - self.range.0).abs()
+            / (self.col_size as IntegerRep);
 
-        i64_to_felt(chunk)
+        integer_rep_to_felt(chunk)
     }
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeCheck<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RangeCheck<F> {
     /// Configures the table.
     pub fn configure(cs: &mut ConstraintSystem<F>, range: Range, logrows: usize) -> RangeCheck<F> {
         log::debug!("range check range: {:?}", range);
@@ -350,7 +425,32 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeC
         let smallest = self.range.0;
         let largest = self.range.1;
 
-        let inputs: Tensor<F> = Tensor::from(smallest..=largest).map(|x| i64_to_felt(x));
+        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 chunked_inputs = inputs.chunks(self.col_size);
 
         self.is_assigned = true;

src/circuit/tests.rs

@@ -8,6 +8,10 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::Fr as F;
 use halo2curves::ff::{Field, PrimeField};
+#[cfg(not(any(
+    all(target_arch = "wasm32", target_os = "unknown"),
+    not(feature = "ezkl")
+)))]
 use ops::lookup::LookupOp;
 use ops::region::RegionCtx;
 use rand::rngs::OsRng;
@@ -55,7 +59,7 @@ mod matmul {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -132,7 +136,7 @@ mod matmul_col_overflow_double_col {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS);
+                        let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -206,7 +210,7 @@ mod matmul_col_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -243,7 +247,10 @@ mod matmul_col_overflow {
 }
 
 #[cfg(test)]
-#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+#[cfg(all(
+    feature = "ezkl",
+    not(all(target_arch = "wasm32", target_os = "unknown"))
+))]
 mod matmul_col_ultra_overflow_double_col {
 
     use halo2_proofs::poly::kzg::{
@@ -256,7 +263,7 @@ mod matmul_col_ultra_overflow_double_col {
     use super::*;
 
     const K: usize = 4;
-    const LEN: usize = 20;
+    const LEN: usize = 10;
     const NUM_INNER_COLS: usize = 2;
 
     #[derive(Clone)]
@@ -290,7 +297,7 @@ mod matmul_col_ultra_overflow_double_col {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS);
+                        let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -361,7 +368,10 @@ mod matmul_col_ultra_overflow_double_col {
 }
 
 #[cfg(test)]
-#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+#[cfg(all(
+    feature = "ezkl",
+    not(all(target_arch = "wasm32", target_os = "unknown"))
+))]
 mod matmul_col_ultra_overflow {
 
     use halo2_proofs::poly::kzg::{
@@ -374,7 +384,7 @@ mod matmul_col_ultra_overflow {
     use super::*;
 
     const K: usize = 4;
-    const LEN: usize = 20;
+    const LEN: usize = 10;
 
     #[derive(Clone)]
     struct MatmulCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -407,7 +417,7 @@ mod matmul_col_ultra_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -518,7 +528,7 @@ mod dot {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -595,7 +605,7 @@ mod dot_col_overflow_triple_col {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 3);
+                        let mut region = RegionCtx::new(region, 0, 3, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -668,7 +678,7 @@ mod dot_col_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -741,7 +751,7 @@ mod sum {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -811,7 +821,7 @@ mod sum_col_overflow_double_col {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS);
+                        let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -880,7 +890,7 @@ mod sum_col_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -951,7 +961,7 @@ mod composition {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         let _ = config
                             .layout(
                                 &mut region,
@@ -1042,7 +1052,7 @@ mod conv {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -1050,6 +1060,7 @@ mod conv {
                                 Box::new(PolyOp::Conv {
                                     padding: vec![(1, 1); 2],
                                     stride: vec![2; 2],
+                                    group: 1,
                                 }),
                             )
                             .map_err(|_| Error::Synthesis)
@@ -1143,7 +1154,10 @@ mod conv {
 }
 
 #[cfg(test)]
-#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+#[cfg(all(
+    feature = "ezkl",
+    not(all(target_arch = "wasm32", target_os = "unknown"))
+))]
 mod conv_col_ultra_overflow {
 
     use halo2_proofs::poly::{
@@ -1158,7 +1172,7 @@ mod conv_col_ultra_overflow {
     use super::*;
 
     const K: usize = 4;
-    const LEN: usize = 28;
+    const LEN: usize = 10;
 
     #[derive(Clone)]
     struct ConvCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -1192,7 +1206,7 @@ mod conv_col_ultra_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(
                                 &mut region,
@@ -1200,6 +1214,7 @@ mod conv_col_ultra_overflow {
                                 Box::new(PolyOp::Conv {
                                     padding: vec![(1, 1); 2],
                                     stride: vec![2; 2],
+                                    group: 1,
                                 }),
                             )
                             .map_err(|_| Error::Synthesis)
@@ -1283,7 +1298,10 @@ mod conv_col_ultra_overflow {
 
 #[cfg(test)]
 // not wasm 32 unknown
-#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+#[cfg(all(
+    feature = "ezkl",
+    not(all(target_arch = "wasm32", target_os = "unknown"))
+))]
 mod conv_relu_col_ultra_overflow {
 
     use halo2_proofs::poly::kzg::{
@@ -1295,8 +1313,8 @@ mod conv_relu_col_ultra_overflow {
 
     use super::*;
 
-    const K: usize = 4;
-    const LEN: usize = 28;
+    const K: usize = 8;
+    const LEN: usize = 15;
 
     #[derive(Clone)]
     struct ConvCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -1315,15 +1333,23 @@ mod conv_relu_col_ultra_overflow {
         }
 
         fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
-            let a = VarTensor::new_advice(cs, K, 1, LEN * LEN * LEN);
-            let b = VarTensor::new_advice(cs, K, 1, LEN * LEN * LEN);
-            let output = VarTensor::new_advice(cs, K, 1, LEN * LEN * LEN);
+            let a = VarTensor::new_advice(cs, K, 1, LEN * LEN * LEN * 4);
+            let b = VarTensor::new_advice(cs, K, 1, LEN * LEN * LEN * 4);
+            let output = VarTensor::new_advice(cs, K, 1, LEN * LEN * LEN * 4);
             let mut base_config =
                 Self::Config::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::SAFE);
             // sets up a new relu table
+
             base_config
-                .configure_lookup(cs, &b, &output, &a, (-3, 3), K, &LookupOp::ReLU)
+                .configure_range_check(cs, &a, &b, (-1, 1), K)
                 .unwrap();
+
+            base_config
+                .configure_range_check(cs, &a, &b, (0, 1), K)
+                .unwrap();
+
+            let _constant = VarTensor::constant_cols(cs, K, 8, false);
+
             base_config.clone()
         }
 
@@ -1332,12 +1358,12 @@ mod conv_relu_col_ultra_overflow {
             mut config: Self::Config,
             mut layouter: impl Layouter<F>,
         ) -> Result<(), Error> {
-            config.layout_tables(&mut layouter).unwrap();
+            config.layout_range_checks(&mut layouter).unwrap();
             layouter
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 2, 2);
                         let output = config
                             .layout(
                                 &mut region,
@@ -1345,6 +1371,7 @@ 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);
@@ -1352,7 +1379,10 @@ mod conv_relu_col_ultra_overflow {
                             .layout(
                                 &mut region,
                                 &[output.unwrap().unwrap()],
-                                Box::new(LookupOp::ReLU),
+                                Box::new(PolyOp::LeakyReLU {
+                                    slope: 0.0.into(),
+                                    scale: 1,
+                                }),
                             )
                             .unwrap();
                         Ok(())
@@ -1473,7 +1503,7 @@ mod add_w_shape_casting {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Add))
                             .map_err(|_| Error::Synthesis)
@@ -1489,7 +1519,7 @@ mod add_w_shape_casting {
         // parameters
         let a = Tensor::from((0..LEN).map(|i| Value::known(F::from(i as u64 + 1))));
 
-        let b = Tensor::from((0..1).map(|i| Value::known(F::from(i as u64 + 1))));
+        let b = Tensor::from((0..1).map(|i| Value::known(F::from(i + 1))));
 
         let circuit = MyCircuit::<F> {
             inputs: [ValTensor::from(a), ValTensor::from(b)],
@@ -1540,7 +1570,7 @@ mod add {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Add))
                             .map_err(|_| Error::Synthesis)
@@ -1624,7 +1654,7 @@ mod dynamic_lookup {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         for i in 0..NUM_LOOP {
                             layouts::dynamic_lookup(
                                 &config,
@@ -1766,7 +1796,7 @@ mod shuffle {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         for i in 0..NUM_LOOP {
                             layouts::shuffles(
                                 &config,
@@ -1881,7 +1911,7 @@ mod add_with_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Add))
                             .map_err(|_| Error::Synthesis)
@@ -1983,7 +2013,7 @@ mod add_with_overflow_and_poseidon {
             layouter.assign_region(
                 || "model",
                 |region| {
-                    let mut region = RegionCtx::new(region, 0, 1);
+                    let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                     config
                         .base
                         .layout(&mut region, &inputs, Box::new(PolyOp::Add))
@@ -2089,7 +2119,7 @@ mod sub {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Sub))
                             .map_err(|_| Error::Synthesis)
@@ -2156,7 +2186,7 @@ mod mult {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Mult))
                             .map_err(|_| Error::Synthesis)
@@ -2223,7 +2253,7 @@ mod pow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
                             .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Pow(5)))
                             .map_err(|_| Error::Synthesis)
@@ -2255,7 +2285,6 @@ mod matmul_relu {
 
     const K: usize = 18;
     const LEN: usize = 32;
-    use crate::circuit::lookup::LookupOp;
 
     #[derive(Clone)]
     struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -2285,11 +2314,17 @@ mod matmul_relu {
 
             let mut base_config =
                 BaseConfig::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::SAFE);
-            // sets up a new relu table
+
             base_config
-                .configure_lookup(cs, &b, &output, &a, (-32768, 32768), K, &LookupOp::ReLU)
+                .configure_range_check(cs, &a, &b, (-1, 1), K)
                 .unwrap();
 
+            base_config
+                .configure_range_check(cs, &a, &b, (0, 1023), K)
+                .unwrap();
+
+            let _constant = VarTensor::constant_cols(cs, K, 8, false);
+
             MyConfig { base_config }
         }
 
@@ -2298,11 +2333,14 @@ mod matmul_relu {
             mut config: Self::Config,
             mut layouter: impl Layouter<F>,
         ) -> Result<(), Error> {
-            config.base_config.layout_tables(&mut layouter).unwrap();
+            config
+                .base_config
+                .layout_range_checks(&mut layouter)
+                .unwrap();
             layouter.assign_region(
                 || "",
                 |region| {
-                    let mut region = RegionCtx::new(region, 0, 1);
+                    let mut region = RegionCtx::new(region, 0, 1, 1024, 2);
                     let op = PolyOp::Einsum {
                         equation: "ij,jk->ik".to_string(),
                     };
@@ -2312,7 +2350,14 @@ mod matmul_relu {
                         .unwrap();
                     let _output = config
                         .base_config
-                        .layout(&mut region, &[output.unwrap()], Box::new(LookupOp::ReLU))
+                        .layout(
+                            &mut region,
+                            &[output.unwrap()],
+                            Box::new(PolyOp::LeakyReLU {
+                                slope: 0.0.into(),
+                                scale: 1,
+                            }),
+                        )
                         .unwrap();
                     Ok(())
                 },
@@ -2351,6 +2396,8 @@ mod relu {
         plonk::{Circuit, ConstraintSystem, Error},
     };
 
+    const K: u32 = 8;
+
     #[derive(Clone)]
     struct ReLUCircuit<F: PrimeField + TensorType + PartialOrd> {
         pub input: ValTensor<F>,
@@ -2367,16 +2414,26 @@ mod relu {
 
         fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
             let advices = (0..3)
-                .map(|_| VarTensor::new_advice(cs, 4, 1, 3))
+                .map(|_| VarTensor::new_advice(cs, 8, 1, 3))
                 .collect::<Vec<_>>();
 
-            let nl = LookupOp::ReLU;
-
-            let mut config = BaseConfig::default();
+            let mut config = BaseConfig::configure(
+                cs,
+                &[advices[0].clone(), advices[1].clone()],
+                &advices[2],
+                CheckMode::SAFE,
+            );
 
             config
-                .configure_lookup(cs, &advices[0], &advices[1], &advices[2], (-6, 6), 4, &nl)
+                .configure_range_check(cs, &advices[0], &advices[1], (-1, 1), K as usize)
                 .unwrap();
+
+            config
+                .configure_range_check(cs, &advices[0], &advices[1], (0, 1), K as usize)
+                .unwrap();
+
+            let _constant = VarTensor::constant_cols(cs, K as usize, 8, false);
+
             config
         }
 
@@ -2385,15 +2442,22 @@ mod relu {
             mut config: Self::Config,
             mut layouter: impl Layouter<F>, // layouter is our 'write buffer' for the circuit
         ) -> Result<(), Error> {
-            config.layout_tables(&mut layouter).unwrap();
+            config.layout_range_checks(&mut layouter).unwrap();
             layouter
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
-                        config
-                            .layout(&mut region, &[self.input.clone()], Box::new(LookupOp::ReLU))
-                            .map_err(|_| Error::Synthesis)
+                        let mut region = RegionCtx::new(region, 0, 1, 2, 2);
+                        Ok(config
+                            .layout(
+                                &mut region,
+                                &[self.input.clone()],
+                                Box::new(PolyOp::LeakyReLU {
+                                    slope: 0.0.into(),
+                                    scale: 1,
+                                }),
+                            )
+                            .unwrap())
                     },
                 )
                 .unwrap();
@@ -2411,13 +2475,16 @@ mod relu {
             input: ValTensor::from(input),
         };
 
-        let prover = MockProver::run(4_u32, &circuit, vec![]).unwrap();
+        let prover = MockProver::run(K, &circuit, vec![]).unwrap();
         prover.assert_satisfied();
     }
 }
 
 #[cfg(test)]
-#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+#[cfg(all(
+    feature = "ezkl",
+    not(all(target_arch = "wasm32", target_os = "unknown"))
+))]
 mod lookup_ultra_overflow {
     use super::*;
     use halo2_proofs::{
@@ -2432,11 +2499,11 @@ mod lookup_ultra_overflow {
     use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 
     #[derive(Clone)]
-    struct ReLUCircuit<F: PrimeField + TensorType + PartialOrd> {
+    struct SigmoidCircuit<F: PrimeField + TensorType + PartialOrd> {
         pub input: ValTensor<F>,
     }
 
-    impl Circuit<F> for ReLUCircuit<F> {
+    impl Circuit<F> for SigmoidCircuit<F> {
         type Config = BaseConfig<F>;
         type FloorPlanner = SimpleFloorPlanner;
         type Params = TestParams;
@@ -2450,7 +2517,7 @@ mod lookup_ultra_overflow {
                 .map(|_| VarTensor::new_advice(cs, 4, 1, 3))
                 .collect::<Vec<_>>();
 
-            let nl = LookupOp::ReLU;
+            let nl = LookupOp::Sigmoid { scale: 1.0.into() };
 
             let mut config = BaseConfig::default();
 
@@ -2478,9 +2545,13 @@ mod lookup_ultra_overflow {
                 .assign_region(
                     || "",
                     |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
+                        let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
-                            .layout(&mut region, &[self.input.clone()], Box::new(LookupOp::ReLU))
+                            .layout(
+                                &mut region,
+                                &[self.input.clone()],
+                                Box::new(LookupOp::Sigmoid { scale: 1.0.into() }),
+                            )
                             .map_err(|_| Error::Synthesis)
                     },
                 )
@@ -2492,13 +2563,13 @@ mod lookup_ultra_overflow {
 
     #[test]
     #[ignore]
-    fn relucircuit() {
+    fn sigmoidcircuit() {
         // get some logs fam
         crate::logger::init_logger();
         // parameters
         let a = Tensor::from((0..4).map(|i| Value::known(F::from(i + 1))));
 
-        let circuit = ReLUCircuit::<F> {
+        let circuit = SigmoidCircuit::<F> {
             input: ValTensor::from(a),
         };
 
@@ -2508,7 +2579,7 @@ mod lookup_ultra_overflow {
 
         let pk = crate::pfsys::create_keys::<
             halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme<halo2curves::bn256::Bn256>,
-            ReLUCircuit<F>,
+            SigmoidCircuit<F>,
         >(&circuit, &params, true)
         .unwrap();
 

src/circuit/utils.rs

@@ -141,23 +141,23 @@ mod tests {
 
     #[test]
     fn f32_eq() {
-        assert!(F32(std::f32::NAN) == F32(std::f32::NAN));
-        assert!(F32(std::f32::NAN) != F32(5.0));
-        assert!(F32(5.0) != F32(std::f32::NAN));
+        assert!(F32(f32::NAN) == F32(f32::NAN));
+        assert!(F32(f32::NAN) != F32(5.0));
+        assert!(F32(5.0) != F32(f32::NAN));
         assert!(F32(0.0) == F32(-0.0));
     }
 
     #[test]
     fn f32_cmp() {
-        assert!(F32(std::f32::NAN) == F32(std::f32::NAN));
-        assert!(F32(std::f32::NAN) < F32(5.0));
-        assert!(F32(5.0) > F32(std::f32::NAN));
+        assert!(F32(f32::NAN) == F32(f32::NAN));
+        assert!(F32(f32::NAN) < F32(5.0));
+        assert!(F32(5.0) > F32(f32::NAN));
         assert!(F32(0.0) == F32(-0.0));
     }
 
     #[test]
     fn f32_hash() {
         assert!(calculate_hash(&F32(0.0)) == calculate_hash(&F32(-0.0)));
-        assert!(calculate_hash(&F32(std::f32::NAN)) == calculate_hash(&F32(-std::f32::NAN)));
+        assert!(calculate_hash(&F32(f32::NAN)) == calculate_hash(&F32(-f32::NAN)));
     }
 }

src/commands.rs

@@ -1,14 +1,8 @@
-#[cfg(not(target_arch = "wasm32"))]
 use alloy::primitives::Address as H160;
 use clap::{Command, Parser, Subcommand};
 use clap_complete::{generate, Generator, Shell};
 #[cfg(feature = "python-bindings")]
-use pyo3::{
-    conversion::{FromPyObject, PyTryFrom},
-    exceptions::PyValueError,
-    prelude::*,
-    types::PyString,
-};
+use pyo3::{conversion::FromPyObject, exceptions::PyValueError, prelude::*};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 use std::str::FromStr;
@@ -17,7 +11,6 @@ use tosubcommand::{ToFlags, ToSubcommand};
 use crate::{pfsys::ProofType, Commitments, RunArgs};
 
 use crate::circuit::CheckMode;
-#[cfg(not(target_arch = "wasm32"))]
 use crate::graph::TestDataSource;
 use crate::pfsys::TranscriptType;
 
@@ -81,8 +74,10 @@ pub const DEFAULT_CALIBRATION_FILE: &str = "calibration.json";
 pub const DEFAULT_LOOKUP_SAFETY_MARGIN: &str = "2";
 /// Default Compress selectors
 pub const DEFAULT_DISABLE_SELECTOR_COMPRESSION: &str = "false";
-/// Default render vk separately
-pub const DEFAULT_RENDER_VK_SEPERATELY: &str = "false";
+/// Default render reusable verifier
+pub const DEFAULT_RENDER_REUSABLE: &str = "false";
+/// Default contract deployment type
+pub const DEFAULT_CONTRACT_DEPLOYMENT_TYPE: &str = "verifier";
 /// Default VK sol path
 pub const DEFAULT_VK_SOL: &str = "vk.sol";
 /// Default VK abi path
@@ -109,8 +104,8 @@ impl IntoPy<PyObject> for TranscriptType {
 #[cfg(feature = "python-bindings")]
 /// Obtains TranscriptType from PyObject (Required for TranscriptType to be compatible with Python)
 impl<'source> FromPyObject<'source> for TranscriptType {
-    fn extract(ob: &'source PyAny) -> PyResult<Self> {
-        let trystr = <PyString as PyTryFrom>::try_from(ob)?;
+    fn extract_bound(ob: &pyo3::Bound<'source, pyo3::PyAny>) -> PyResult<Self> {
+        let trystr = String::extract_bound(ob)?;
         let strval = trystr.to_string();
         match strval.to_lowercase().as_str() {
             "poseidon" => Ok(TranscriptType::Poseidon),
@@ -181,28 +176,80 @@ impl From<&str> for CalibrationTarget {
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, PartialOrd)]
+/// Determines what type of contract (verifier, verifier/reusable, vka) should be deployed
+pub enum ContractType {
+    /// Deploys a verifier contrat tailored to the circuit and not reusable
+    Verifier {
+        /// Whether to deploy a reusable verifier. This can reduce state bloat on-chain since you need only deploy a verifying key artifact (vka) for a given circuit which is significantly smaller than the verifier contract (up to 4 times smaller for large circuits)
+        /// Can also be used as an alternative to aggregation for verifiers that are otherwise too large to fit on-chain.
+        reusable: bool,
+    },
+    /// Deploys a verifying key artifact that the reusable verifier loads into memory during runtime. Encodes the circuit specific data that was otherwise hardcoded onto the stack.
+    VerifyingKeyArtifact,
+}
+
+impl Default for ContractType {
+    fn default() -> Self {
+        ContractType::Verifier { reusable: false }
+    }
+}
+
+impl std::fmt::Display for ContractType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                ContractType::Verifier { reusable: true } => {
+                    "verifier/reusable".to_string()
+                }
+                ContractType::Verifier { reusable: false } => "verifier".to_string(),
+                ContractType::VerifyingKeyArtifact => "vka".to_string(),
+            }
+        )
+    }
+}
+
+impl ToFlags for ContractType {
+    fn to_flags(&self) -> Vec<String> {
+        vec![format!("{}", self)]
+    }
+}
+
+impl From<&str> for ContractType {
+    fn from(s: &str) -> Self {
+        match s {
+            "verifier" => ContractType::Verifier { reusable: false },
+            "verifier/reusable" => ContractType::Verifier { reusable: true },
+            "vka" => ContractType::VerifyingKeyArtifact,
+            _ => {
+                log::error!("Invalid value for ContractType");
+                log::warn!("Defaulting to verifier");
+                ContractType::default()
+            }
+        }
+    }
+}
+
 #[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, PartialOrd)]
 /// wrapper for H160 to make it easy to parse into flag vals
 pub struct H160Flag {
     inner: H160,
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 impl From<H160Flag> for H160 {
     fn from(val: H160Flag) -> H160 {
         val.inner
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 impl ToFlags for H160Flag {
     fn to_flags(&self) -> Vec<String> {
         vec![format!("{:#x}", self.inner)]
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 impl From<&str> for H160Flag {
     fn from(s: &str) -> Self {
         Self {
@@ -230,9 +277,8 @@ impl IntoPy<PyObject> for CalibrationTarget {
 #[cfg(feature = "python-bindings")]
 /// Obtains CalibrationTarget from PyObject (Required for CalibrationTarget to be compatible with Python)
 impl<'source> FromPyObject<'source> for CalibrationTarget {
-    fn extract(ob: &'source PyAny) -> PyResult<Self> {
-        let trystr = <PyString as PyTryFrom>::try_from(ob)?;
-        let strval = trystr.to_string();
+    fn extract_bound(ob: &pyo3::Bound<'source, pyo3::PyAny>) -> PyResult<Self> {
+        let strval = String::extract_bound(ob)?;
         match strval.to_lowercase().as_str() {
             "resources" => Ok(CalibrationTarget::Resources {
                 col_overflow: false,
@@ -243,17 +289,31 @@ impl<'source> FromPyObject<'source> for CalibrationTarget {
         }
     }
 }
-// not wasm
-use lazy_static::lazy_static;
 
-// if CARGO VERSION is 0.0.0 replace with "source - no compatibility guaranteed"
-lazy_static! {
-    /// The version of the ezkl library
-    pub static ref VERSION: &'static str =  if env!("CARGO_PKG_VERSION") == "0.0.0" {
-       "source - no compatibility guaranteed"
-    } else {
-        env!("CARGO_PKG_VERSION")
-    };
+#[cfg(feature = "python-bindings")]
+/// Converts ContractType into a PyObject (Required for ContractType to be compatible with Python)
+impl IntoPy<PyObject> for ContractType {
+    fn into_py(self, py: Python) -> PyObject {
+        match self {
+            ContractType::Verifier { reusable: true } => "verifier/reusable".to_object(py),
+            ContractType::Verifier { reusable: false } => "verifier".to_object(py),
+            ContractType::VerifyingKeyArtifact => "vka".to_object(py),
+        }
+    }
+}
+
+#[cfg(feature = "python-bindings")]
+/// Obtains ContractType from PyObject (Required for ContractType to be compatible with Python)
+impl<'source> FromPyObject<'source> for ContractType {
+    fn extract_bound(ob: &pyo3::Bound<'source, pyo3::PyAny>) -> PyResult<Self> {
+        let strval = String::extract_bound(ob)?;
+        match strval.to_lowercase().as_str() {
+            "verifier" => Ok(ContractType::Verifier { reusable: false }),
+            "verifier/reusable" => Ok(ContractType::Verifier { reusable: true }),
+            "vka" => Ok(ContractType::VerifyingKeyArtifact),
+            _ => Err(PyValueError::new_err("Invalid value for ContractType")),
+        }
+    }
 }
 
 /// Get the styles for the CLI
@@ -263,49 +323,49 @@ pub fn get_styles() -> clap::builder::Styles {
             clap::builder::styling::Style::new()
                 .bold()
                 .underline()
-                .fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Cyan))),
+                .fg_color(Some(clap::builder::styling::Color::Ansi(
+                    clap::builder::styling::AnsiColor::Cyan,
+                ))),
         )
         .header(
             clap::builder::styling::Style::new()
                 .bold()
                 .underline()
-                .fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Cyan))),
-        )
-        .literal(
-            clap::builder::styling::Style::new().fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Magenta))),
-        )
-        .invalid(
-            clap::builder::styling::Style::new()
-                .bold()
-                .fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Red))),
-        )
-        .error(
-            clap::builder::styling::Style::new()
-                .bold()
-                .fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Red))),
+                .fg_color(Some(clap::builder::styling::Color::Ansi(
+                    clap::builder::styling::AnsiColor::Cyan,
+                ))),
         )
+        .literal(clap::builder::styling::Style::new().fg_color(Some(
+            clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Magenta),
+        )))
+        .invalid(clap::builder::styling::Style::new().bold().fg_color(Some(
+            clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Red),
+        )))
+        .error(clap::builder::styling::Style::new().bold().fg_color(Some(
+            clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Red),
+        )))
         .valid(
             clap::builder::styling::Style::new()
                 .bold()
                 .underline()
-                .fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Green))),
-        )
-        .placeholder(
-            clap::builder::styling::Style::new().fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::White))),
+                .fg_color(Some(clap::builder::styling::Color::Ansi(
+                    clap::builder::styling::AnsiColor::Green,
+                ))),
         )
+        .placeholder(clap::builder::styling::Style::new().fg_color(Some(
+            clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::White),
+        )))
 }
 
-
 /// Print completions for the given generator
 pub fn print_completions<G: Generator>(gen: G, cmd: &mut Command) {
     generate(gen, cmd, cmd.get_name().to_string(), &mut std::io::stdout());
 }
 
-
 #[allow(missing_docs)]
 #[derive(Parser, Debug, Clone)]
 #[command(author, about, long_about = None)]
-#[clap(version = *VERSION, styles = get_styles(), trailing_var_arg = true)]
+#[clap(version = crate::version(), styles = get_styles(), trailing_var_arg = true)]
 pub struct Cli {
     /// If provided, outputs the completion file for given shell
     #[clap(long = "generate", value_parser)]
@@ -315,7 +375,6 @@ pub struct Cli {
     pub command: Option<Commands>,
 }
 
-
 #[allow(missing_docs)]
 #[derive(Debug, Subcommand, Clone, Deserialize, Serialize, PartialEq, PartialOrd, ToSubcommand)]
 pub enum Commands {
@@ -365,7 +424,6 @@ pub enum Commands {
     },
 
     /// Calibrates the proving scale, lookup bits and logrows from a circuit settings file.
-    #[cfg(not(target_arch = "wasm32"))]
     CalibrateSettings {
         /// The path to the .json calibration data file.
         #[arg(short = 'D', long, default_value = DEFAULT_CALIBRATION_FILE, value_hint = clap::ValueHint::FilePath)]
@@ -397,9 +455,6 @@ pub enum Commands {
         /// max logrows to use for calibration, 26 is the max public SRS size
         #[arg(long, value_hint = clap::ValueHint::Other)]
         max_logrows: Option<u32>,
-        // whether to only range check rebases (instead of trying both range check and lookup)
-        #[arg(long, default_value = DEFAULT_ONLY_RANGE_CHECK_REBASE, action = clap::ArgAction::SetTrue)]
-        only_range_check_rebase: Option<bool>,
     },
 
     /// Generates a dummy SRS
@@ -416,11 +471,10 @@ pub enum Commands {
         commitment: Option<Commitments>,
     },
 
-    #[cfg(not(target_arch = "wasm32"))]
     /// Gets an SRS from a circuit settings file.
     #[command(name = "get-srs")]
     GetSrs {
-        /// The path to output the desired srs file, if set to None will save to $EZKL_REPO_PATH/srs
+        /// The path to output the desired srs file, if set to None will save to ~/.ezkl/srs
         #[arg(long, default_value = None, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// Path to the circuit settings .json file to read in logrows from. Overriden by logrows if specified.
@@ -467,7 +521,7 @@ pub enum Commands {
         /// The path to save the proving key to
         #[arg(long, default_value = DEFAULT_PK_AGGREGATED, value_hint = clap::ValueHint::FilePath)]
         pk_path: Option<PathBuf>,
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// logrows used for aggregation circuit
@@ -494,7 +548,7 @@ pub enum Commands {
         /// The path to output the proof file to
         #[arg(long, default_value = DEFAULT_PROOF_AGGREGATED, value_hint = clap::ValueHint::FilePath)]
         proof_path: Option<PathBuf>,
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
         #[arg(
@@ -502,7 +556,7 @@ pub enum Commands {
             require_equals = true,
             num_args = 0..=1,
             default_value_t = TranscriptType::default(),
-            value_enum, 
+            value_enum,
             value_hint = clap::ValueHint::Other
         )]
         transcript: TranscriptType,
@@ -536,7 +590,7 @@ pub enum Commands {
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT, value_hint = clap::ValueHint::FilePath)]
         compiled_circuit: Option<PathBuf>,
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// The path to output the verification key file to
@@ -552,7 +606,6 @@ pub enum Commands {
         #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION, action = clap::ArgAction::SetTrue)]
         disable_selector_compression: Option<bool>,
     },
-    #[cfg(not(target_arch = "wasm32"))]
     /// Deploys a test contact that the data attester reads from and creates a data attestation formatted input.json file that contains call data information
     #[command(arg_required_else_help = true)]
     SetupTestEvmData {
@@ -577,7 +630,6 @@ pub enum Commands {
         #[arg(long, default_value = "on-chain", value_hint = clap::ValueHint::Other)]
         output_source: TestDataSource,
     },
-    #[cfg(not(target_arch = "wasm32"))]
     /// The Data Attestation Verifier contract stores the account calls to fetch data to feed into ezkl. This call data can be updated by an admin account. This tests that admin account is able to update this call data.
     #[command(arg_required_else_help = true)]
     TestUpdateAccountCalls {
@@ -591,7 +643,6 @@ pub enum Commands {
         #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
         rpc_url: Option<String>,
     },
-    #[cfg(not(target_arch = "wasm32"))]
     /// Swaps the positions in the transcript that correspond to commitments
     SwapProofCommitments {
         /// The path to the proof file
@@ -602,7 +653,6 @@ pub enum Commands {
         witness_path: Option<PathBuf>,
     },
 
-    #[cfg(not(target_arch = "wasm32"))]
     /// Loads model, data, and creates proof
     Prove {
         /// The path to the .json witness file (generated using the gen-witness command)
@@ -617,7 +667,7 @@ pub enum Commands {
         /// The path to output the proof file to
         #[arg(long, default_value = DEFAULT_PROOF, value_hint = clap::ValueHint::FilePath)]
         proof_path: Option<PathBuf>,
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         #[arg(
@@ -625,7 +675,7 @@ pub enum Commands {
             require_equals = true,
             num_args = 0..=1,
             default_value_t = ProofType::Single,
-            value_enum, 
+            value_enum,
             value_hint = clap::ValueHint::Other
         )]
         proof_type: ProofType,
@@ -633,7 +683,6 @@ pub enum Commands {
         #[arg(long, default_value = DEFAULT_CHECKMODE, value_hint = clap::ValueHint::Other)]
         check_mode: Option<CheckMode>,
     },
-    #[cfg(not(target_arch = "wasm32"))]
     /// Encodes a proof into evm calldata
     #[command(name = "encode-evm-calldata")]
     EncodeEvmCalldata {
@@ -647,11 +696,10 @@ pub enum Commands {
         #[arg(long, value_hint = clap::ValueHint::Other)]
         addr_vk: Option<H160Flag>,
     },
-    #[cfg(not(target_arch = "wasm32"))]
     /// Creates an Evm verifier for a single proof
     #[command(name = "create-evm-verifier")]
     CreateEvmVerifier {
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
@@ -666,17 +714,14 @@ pub enum Commands {
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VERIFIER_ABI, value_hint = clap::ValueHint::FilePath)]
         abi_path: Option<PathBuf>,
-        /// Whether the verifier key should be rendered as a separate contract.
-        /// We recommend disabling selector compression if this is enabled.
-        /// To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command.        
-        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY, action = clap::ArgAction::SetTrue)]
-        render_vk_seperately: Option<bool>,
+        /// Whether the to render the verifier as reusable or not. If true, you will need to deploy a VK artifact, passing it as part of the calldata to the verifier.
+        #[arg(long, default_value = DEFAULT_RENDER_REUSABLE, action = clap::ArgAction::SetTrue)]
+        reusable: Option<bool>,
     },
-    #[cfg(not(target_arch = "wasm32"))]
-    /// Creates an Evm verifier for a single proof
-    #[command(name = "create-evm-vk")]
-    CreateEvmVK {
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+    /// Creates an Evm verifier artifact for a single proof to be used by the reusable verifier
+    #[command(name = "create-evm-vka")]
+    CreateEvmVKArtifact {
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
@@ -692,7 +737,6 @@ pub enum Commands {
         #[arg(long, default_value = DEFAULT_VK_ABI, value_hint = clap::ValueHint::FilePath)]
         abi_path: Option<PathBuf>,
     },
-    #[cfg(not(target_arch = "wasm32"))]
     /// Creates an Evm verifier that attests to on-chain inputs for a single proof
     #[command(name = "create-evm-da")]
     CreateEvmDataAttestation {
@@ -717,11 +761,10 @@ pub enum Commands {
         witness: Option<PathBuf>,
     },
 
-    #[cfg(not(target_arch = "wasm32"))]
     /// Creates an Evm verifier for an aggregate proof
     #[command(name = "create-evm-verifier-aggr")]
     CreateEvmVerifierAggr {
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// The path to load the desired verification key file
@@ -739,11 +782,9 @@ pub enum Commands {
         // logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS, value_hint = clap::ValueHint::Other)]
         logrows: Option<u32>,
-        /// Whether the verifier key should be rendered as a separate contract.
-        /// We recommend disabling selector compression if this is enabled.
-        /// To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command.        
-        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY, action = clap::ArgAction::SetTrue)]
-        render_vk_seperately: Option<bool>,
+        /// Whether the to render the verifier as reusable or not. If true, you will need to deploy a VK artifact, passing it as part of the calldata to the verifier.
+        #[arg(long, default_value = DEFAULT_RENDER_REUSABLE, action = clap::ArgAction::SetTrue)]
+        reusable: Option<bool>,
     },
     /// Verifies a proof, returning accept or reject
     Verify {
@@ -756,7 +797,7 @@ pub enum Commands {
         /// The path to the verification key file (generated using the setup command)
         #[arg(long, default_value = DEFAULT_VK, value_hint = clap::ValueHint::FilePath)]
         vk_path: Option<PathBuf>,
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// Reduce SRS logrows to the number of instances rather than the number of logrows used for proofs (only works if the srs were generated in the same ceremony)
@@ -774,7 +815,7 @@ pub enum Commands {
         /// reduced srs
         #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION, action = clap::ArgAction::SetTrue)]
         reduced_srs: Option<bool>,
-        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
+        /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// logrows used for aggregation circuit
@@ -784,9 +825,8 @@ pub enum Commands {
         #[arg(long, default_value = DEFAULT_COMMITMENT, value_hint = clap::ValueHint::Other)]
         commitment: Option<Commitments>,
     },
-    #[cfg(not(target_arch = "wasm32"))]
-    /// Deploys an evm verifier that is generated by ezkl
-    DeployEvmVerifier {
+    /// Deploys an evm contract (verifier, reusable verifier, or vk artifact) that is generated by ezkl
+    DeployEvm {
         /// The path to the Solidity code (generated using the create-evm-verifier command)
         #[arg(long, default_value = DEFAULT_SOL_CODE, value_hint = clap::ValueHint::FilePath)]
         sol_code_path: Option<PathBuf>,
@@ -802,27 +842,10 @@ pub enum Commands {
         /// Private secp256K1 key in hex format, 64 chars, no 0x prefix, of the account signing transactions. If None the private key will be generated by Anvil
         #[arg(short = 'P', long, value_hint = clap::ValueHint::Other)]
         private_key: Option<String>,
+        /// Contract type to be deployed
+        #[arg(long = "contract-type", short = 'C', default_value = DEFAULT_CONTRACT_DEPLOYMENT_TYPE, value_hint = clap::ValueHint::Other)]
+        contract: ContractType,
     },
-    #[cfg(not(target_arch = "wasm32"))]
-    /// Deploys an evm verifier that is generated by ezkl
-    DeployEvmVK {
-        /// The path to the Solidity code (generated using the create-evm-verifier command)
-        #[arg(long, default_value = DEFAULT_VK_SOL, value_hint = clap::ValueHint::FilePath)]
-        sol_code_path: Option<PathBuf>,
-        /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
-        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
-        rpc_url: Option<String>,
-        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_VK, value_hint = clap::ValueHint::Other)]
-        /// The path to output the contract address
-        addr_path: Option<PathBuf>,
-        /// The optimizer runs to set on the verifier. Lower values optimize for deployment cost, while higher values optimize for gas cost.
-        #[arg(long, default_value = DEFAULT_OPTIMIZER_RUNS, value_hint = clap::ValueHint::Other)]
-        optimizer_runs: usize,
-        /// Private secp256K1 key in hex format, 64 chars, no 0x prefix, of the account signing transactions. If None the private key will be generated by Anvil
-        #[arg(short = 'P', long, value_hint = clap::ValueHint::Other)]
-        private_key: Option<String>,
-    },
-    #[cfg(not(target_arch = "wasm32"))]
     /// Deploys an evm verifier that allows for data attestation
     #[command(name = "deploy-evm-da")]
     DeployEvmDataAttestation {
@@ -848,7 +871,6 @@ pub enum Commands {
         #[arg(short = 'P', long, value_hint = clap::ValueHint::Other)]
         private_key: Option<String>,
     },
-    #[cfg(not(target_arch = "wasm32"))]
     /// Verifies a proof using a local Evm executor, returning accept or reject
     #[command(name = "verify-evm")]
     VerifyEvm {
@@ -877,7 +899,6 @@ pub enum Commands {
     },
 }
 
-
 impl Commands {
     /// Converts the commands to a json string
     pub fn as_json(&self) -> String {
@@ -888,4 +909,4 @@ impl Commands {
     pub fn from_json(json: &str) -> Self {
         serde_json::from_str(json).unwrap()
     }
-}
+}

src/execute.rs

@@ -1,17 +1,16 @@
+use crate::circuit::region::RegionSettings;
 use crate::circuit::CheckMode;
-#[cfg(not(target_arch = "wasm32"))]
 use crate::commands::CalibrationTarget;
-#[cfg(not(target_arch = "wasm32"))]
-use crate::eth::{deploy_contract_via_solidity, deploy_da_verifier_via_solidity};
-#[cfg(not(target_arch = "wasm32"))]
+use crate::eth::{
+    deploy_contract_via_solidity, deploy_da_verifier_via_solidity, fix_da_multi_sol,
+    fix_da_single_sol,
+};
 #[allow(unused_imports)]
-use crate::eth::{fix_da_sol, get_contract_artifacts, verify_proof_via_solidity};
-use crate::graph::input::GraphData;
+use crate::eth::{get_contract_artifacts, verify_proof_via_solidity};
+use crate::graph::input::{Calls, GraphData};
 use crate::graph::{GraphCircuit, GraphSettings, GraphWitness, Model};
-#[cfg(not(target_arch = "wasm32"))]
 use crate::graph::{TestDataSource, TestSources};
 use crate::pfsys::evm::aggregation_kzg::{AggregationCircuit, PoseidonTranscript};
-#[cfg(not(target_arch = "wasm32"))]
 use crate::pfsys::{
     create_keys, load_pk, load_vk, save_params, save_pk, Snark, StrategyType, TranscriptType,
 };
@@ -20,11 +19,9 @@ use crate::pfsys::{
 };
 use crate::pfsys::{save_vk, srs::*};
 use crate::tensor::TensorError;
-#[cfg(not(target_arch = "wasm32"))]
 use crate::EZKL_BUF_CAPACITY;
 use crate::{commands::*, EZKLError};
 use crate::{Commitments, RunArgs};
-#[cfg(not(target_arch = "wasm32"))]
 use colored::Colorize;
 #[cfg(unix)]
 use gag::Gag;
@@ -44,17 +41,13 @@ use halo2_proofs::poly::kzg::{
 };
 use halo2_proofs::poly::VerificationStrategy;
 use halo2_proofs::transcript::{EncodedChallenge, TranscriptReadBuffer};
-#[cfg(not(target_arch = "wasm32"))]
 use halo2_solidity_verifier;
 use halo2curves::bn256::{Bn256, Fr, G1Affine};
 use halo2curves::ff::{FromUniformBytes, WithSmallOrderMulGroup};
 use halo2curves::serde::SerdeObject;
-#[cfg(not(target_arch = "wasm32"))]
 use indicatif::{ProgressBar, ProgressStyle};
 use instant::Instant;
-#[cfg(not(target_arch = "wasm32"))]
 use itertools::Itertools;
-#[cfg(not(target_arch = "wasm32"))]
 use log::debug;
 use log::{info, trace, warn};
 use serde::de::DeserializeOwned;
@@ -64,9 +57,7 @@ use snark_verifier::system::halo2::compile;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use snark_verifier::system::halo2::Config;
 use std::fs::File;
-#[cfg(not(target_arch = "wasm32"))]
 use std::io::BufWriter;
-#[cfg(not(target_arch = "wasm32"))]
 use std::io::{Cursor, Write};
 use std::path::Path;
 use std::path::PathBuf;
@@ -127,7 +118,6 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             logrows as u32,
             commitment.unwrap_or(Commitments::from_str(DEFAULT_COMMITMENT).unwrap()),
         ),
-        #[cfg(not(target_arch = "wasm32"))]
         Commands::GetSrs {
             srs_path,
             settings_path,
@@ -144,7 +134,6 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
             args,
         ),
-        #[cfg(not(target_arch = "wasm32"))]
         Commands::CalibrateSettings {
             model,
             settings_path,
@@ -154,7 +143,6 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             scales,
             scale_rebase_multiplier,
             max_logrows,
-            only_range_check_rebase,
         } => calibrate(
             model.unwrap_or(DEFAULT_MODEL.into()),
             data.unwrap_or(DEFAULT_DATA.into()),
@@ -163,7 +151,6 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             lookup_safety_margin,
             scales,
             scale_rebase_multiplier,
-            only_range_check_rebase.unwrap_or(DEFAULT_ONLY_RANGE_CHECK_REBASE.parse().unwrap()),
             max_logrows,
         )
         .await
@@ -187,14 +174,13 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             model.unwrap_or(DEFAULT_MODEL.into()),
             witness.unwrap_or(DEFAULT_WITNESS.into()),
         ),
-        #[cfg(not(target_arch = "wasm32"))]
         Commands::CreateEvmVerifier {
             vk_path,
             srs_path,
             settings_path,
             sol_code_path,
             abi_path,
-            render_vk_seperately,
+            reusable,
         } => {
             create_evm_verifier(
                 vk_path.unwrap_or(DEFAULT_VK.into()),
@@ -202,11 +188,10 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
                 settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
                 sol_code_path.unwrap_or(DEFAULT_SOL_CODE.into()),
                 abi_path.unwrap_or(DEFAULT_VERIFIER_ABI.into()),
-                render_vk_seperately.unwrap_or(DEFAULT_RENDER_VK_SEPERATELY.parse().unwrap()),
+                reusable.unwrap_or(DEFAULT_RENDER_REUSABLE.parse().unwrap()),
             )
             .await
         }
-        #[cfg(not(target_arch = "wasm32"))]
         Commands::EncodeEvmCalldata {
             proof_path,
             calldata_path,
@@ -218,14 +203,14 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
 
-        Commands::CreateEvmVK {
+        Commands::CreateEvmVKArtifact {
             vk_path,
             srs_path,
             settings_path,
             sol_code_path,
             abi_path,
         } => {
-            create_evm_vk(
+            create_evm_vka(
                 vk_path.unwrap_or(DEFAULT_VK.into()),
                 srs_path,
                 settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
@@ -234,7 +219,6 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             )
             .await
         }
-        #[cfg(not(target_arch = "wasm32"))]
         Commands::CreateEvmDataAttestation {
             settings_path,
             sol_code_path,
@@ -251,7 +235,6 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             )
             .await
         }
-        #[cfg(not(target_arch = "wasm32"))]
         Commands::CreateEvmVerifierAggr {
             vk_path,
             srs_path,
@@ -259,7 +242,7 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             abi_path,
             aggregation_settings,
             logrows,
-            render_vk_seperately,
+            reusable,
         } => {
             create_evm_aggregate_verifier(
                 vk_path.unwrap_or(DEFAULT_VK.into()),
@@ -268,7 +251,7 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
                 abi_path.unwrap_or(DEFAULT_VERIFIER_AGGREGATED_ABI.into()),
                 aggregation_settings,
                 logrows.unwrap_or(DEFAULT_AGGREGATED_LOGROWS.parse().unwrap()),
-                render_vk_seperately.unwrap_or(DEFAULT_RENDER_VK_SEPERATELY.parse().unwrap()),
+                reusable.unwrap_or(DEFAULT_RENDER_REUSABLE.parse().unwrap()),
             )
             .await
         }
@@ -297,7 +280,6 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             disable_selector_compression
                 .unwrap_or(DEFAULT_DISABLE_SELECTOR_COMPRESSION.parse().unwrap()),
         ),
-        #[cfg(not(target_arch = "wasm32"))]
         Commands::SetupTestEvmData {
             data,
             compiled_circuit,
@@ -316,13 +298,11 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             )
             .await
         }
-        #[cfg(not(target_arch = "wasm32"))]
         Commands::TestUpdateAccountCalls {
             addr,
             data,
             rpc_url,
         } => test_update_account_calls(addr, data.unwrap_or(DEFAULT_DATA.into()), rpc_url).await,
-        #[cfg(not(target_arch = "wasm32"))]
         Commands::SwapProofCommitments {
             proof_path,
             witness_path,
@@ -332,7 +312,6 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
 
-        #[cfg(not(target_arch = "wasm32"))]
         Commands::Prove {
             witness,
             compiled_circuit,
@@ -432,13 +411,13 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             commitment.into(),
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
-        #[cfg(not(target_arch = "wasm32"))]
-        Commands::DeployEvmVerifier {
+        Commands::DeployEvm {
             sol_code_path,
             rpc_url,
             addr_path,
             optimizer_runs,
             private_key,
+            contract,
         } => {
             deploy_evm(
                 sol_code_path.unwrap_or(DEFAULT_SOL_CODE.into()),
@@ -446,29 +425,10 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
                 addr_path.unwrap_or(DEFAULT_CONTRACT_ADDRESS.into()),
                 optimizer_runs,
                 private_key,
-                "Halo2Verifier",
+                contract,
             )
             .await
         }
-        #[cfg(not(target_arch = "wasm32"))]
-        Commands::DeployEvmVK {
-            sol_code_path,
-            rpc_url,
-            addr_path,
-            optimizer_runs,
-            private_key,
-        } => {
-            deploy_evm(
-                sol_code_path.unwrap_or(DEFAULT_VK_SOL.into()),
-                rpc_url,
-                addr_path.unwrap_or(DEFAULT_CONTRACT_ADDRESS_VK.into()),
-                optimizer_runs,
-                private_key,
-                "Halo2VerifyingKey",
-            )
-            .await
-        }
-        #[cfg(not(target_arch = "wasm32"))]
         Commands::DeployEvmDataAttestation {
             data,
             settings_path,
@@ -489,7 +449,6 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             )
             .await
         }
-        #[cfg(not(target_arch = "wasm32"))]
         Commands::VerifyEvm {
             proof_path,
             addr_verifier,
@@ -609,7 +568,6 @@ pub(crate) fn gen_srs_cmd(
     Ok(String::new())
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 async fn fetch_srs(uri: &str) -> Result<Vec<u8>, EZKLError> {
     let pb = {
         let pb = init_spinner();
@@ -629,7 +587,6 @@ async fn fetch_srs(uri: &str) -> Result<Vec<u8>, EZKLError> {
     Ok(std::mem::take(&mut buf))
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn get_file_hash(path: &PathBuf) -> Result<String, EZKLError> {
     use std::io::Read;
     let file = std::fs::File::open(path)?;
@@ -648,7 +605,6 @@ pub(crate) fn get_file_hash(path: &PathBuf) -> Result<String, EZKLError> {
     Ok(hash)
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 fn check_srs_hash(
     logrows: u32,
     srs_path: Option<PathBuf>,
@@ -674,7 +630,6 @@ fn check_srs_hash(
     Ok(hash)
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn get_srs_cmd(
     srs_path: Option<PathBuf>,
     settings_path: Option<PathBuf>,
@@ -717,20 +672,21 @@ pub(crate) async fn get_srs_cmd(
             let srs_uri = format!("{}{}", PUBLIC_SRS_URL, k);
             let mut reader = Cursor::new(fetch_srs(&srs_uri).await?);
             // check the SRS
-            #[cfg(not(target_arch = "wasm32"))]
             let pb = init_spinner();
-            #[cfg(not(target_arch = "wasm32"))]
             pb.set_message("Validating SRS (this may take a while) ...");
             let params = ParamsKZG::<Bn256>::read(&mut reader)?;
-            #[cfg(not(target_arch = "wasm32"))]
             pb.finish_with_message("SRS validated.");
 
             info!("Saving SRS to disk...");
-            let mut file = std::fs::File::create(get_srs_path(k, srs_path.clone(), commitment))?;
+            let computed_srs_path = get_srs_path(k, srs_path.clone(), commitment);
+            let mut file = std::fs::File::create(&computed_srs_path)?;
             let mut buffer = BufWriter::with_capacity(*EZKL_BUF_CAPACITY, &mut file);
             params.write(&mut buffer)?;
 
-            info!("Saved SRS to disk.");
+            info!(
+                "Saved SRS to {}.",
+                computed_srs_path.as_os_str().to_str().unwrap_or("disk")
+            );
 
             info!("SRS downloaded");
         } else {
@@ -776,15 +732,17 @@ pub(crate) async fn gen_witness(
         None
     };
 
-    #[cfg(not(target_arch = "wasm32"))]
     let mut input = circuit.load_graph_input(&data).await?;
-    #[cfg(target_arch = "wasm32")]
+    #[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
     let mut input = circuit.load_graph_input(&data)?;
 
     // if any of the settings have kzg visibility then we need to load the srs
 
     let commitment: Commitments = settings.run_args.commitment.into();
 
+    let region_settings =
+        RegionSettings::all_true(settings.run_args.decomp_base, settings.run_args.decomp_legs);
+
     let start_time = Instant::now();
     let witness = if settings.module_requires_polycommit() {
         if get_srs_path(settings.run_args.logrows, srs_path.clone(), commitment).exists() {
@@ -799,8 +757,7 @@ pub(crate) async fn gen_witness(
                         &mut input,
                         vk.as_ref(),
                         Some(&srs),
-                        true,
-                        true,
+                        region_settings,
                     )?
                 }
                 Commitments::IPA => {
@@ -814,8 +771,7 @@ pub(crate) async fn gen_witness(
                         &mut input,
                         vk.as_ref(),
                         Some(&srs),
-                        true,
-                        true,
+                        region_settings,
                     )?
                 }
             }
@@ -825,12 +781,16 @@ pub(crate) async fn gen_witness(
                 &mut input,
                 vk.as_ref(),
                 None,
-                true,
-                true,
+                region_settings,
             )?
         }
     } else {
-        circuit.forward::<KZGCommitmentScheme<Bn256>>(&mut input, vk.as_ref(), None, true, true)?
+        circuit.forward::<KZGCommitmentScheme<Bn256>>(
+            &mut input,
+            vk.as_ref(),
+            None,
+            region_settings,
+        )?
     };
 
     // print each variable tuple (symbol, value) as symbol=value
@@ -869,7 +829,6 @@ pub(crate) fn gen_circuit_settings(
 }
 
 // not for wasm targets
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn init_spinner() -> ProgressBar {
     let pb = indicatif::ProgressBar::new_spinner();
     pb.set_draw_target(indicatif::ProgressDrawTarget::stdout());
@@ -891,7 +850,6 @@ pub(crate) fn init_spinner() -> ProgressBar {
 }
 
 // not for wasm targets
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn init_bar(len: u64) -> ProgressBar {
     let pb = ProgressBar::new(len);
     pb.set_draw_target(indicatif::ProgressDrawTarget::stdout());
@@ -905,7 +863,6 @@ pub(crate) fn init_bar(len: u64) -> ProgressBar {
     pb
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 use colored_json::ToColoredJson;
 
 #[derive(Debug, Clone, Tabled)]
@@ -1005,7 +962,6 @@ impl AccuracyResults {
 }
 
 /// Calibrate the circuit parameters to a given a dataset
-#[cfg(not(target_arch = "wasm32"))]
 #[allow(trivial_casts)]
 #[allow(clippy::too_many_arguments)]
 pub(crate) async fn calibrate(
@@ -1016,13 +972,14 @@ pub(crate) async fn calibrate(
     lookup_safety_margin: f64,
     scales: Option<Vec<crate::Scale>>,
     scale_rebase_multiplier: Vec<u32>,
-    only_range_check_rebase: bool,
     max_logrows: Option<u32>,
 ) -> Result<GraphSettings, EZKLError> {
     use log::error;
     use std::collections::HashMap;
     use tabled::Table;
 
+    use crate::fieldutils::IntegerRep;
+
     let data = GraphData::from_path(data)?;
     // load the pre-generated settings
     let settings = GraphSettings::load(&settings_path)?;
@@ -1050,12 +1007,6 @@ pub(crate) async fn calibrate(
         (11..14).collect::<Vec<crate::Scale>>()
     };
 
-    let div_rebasing = if only_range_check_rebase {
-        vec![false]
-    } else {
-        vec![true, false]
-    };
-
     let mut found_params: Vec<GraphSettings> = vec![];
 
     // 2 x 2 grid
@@ -1093,12 +1044,6 @@ pub(crate) async fn calibrate(
         .map(|(a, b)| (*a, *b))
         .collect::<Vec<((crate::Scale, crate::Scale), u32)>>();
 
-    let range_grid = range_grid
-        .iter()
-        .cartesian_product(div_rebasing.iter())
-        .map(|(a, b)| (*a, *b))
-        .collect::<Vec<(((crate::Scale, crate::Scale), u32), bool)>>();
-
     let mut forward_pass_res = HashMap::new();
 
     let pb = init_bar(range_grid.len() as u64);
@@ -1107,41 +1052,34 @@ pub(crate) async fn calibrate(
     let mut num_failed = 0;
     let mut num_passed = 0;
 
-    for (((input_scale, param_scale), scale_rebase_multiplier), div_rebasing) in range_grid {
+    for ((input_scale, param_scale), scale_rebase_multiplier) in range_grid {
         pb.set_message(format!(
-            "i-scale: {}, p-scale: {}, rebase-(x): {}, div-rebase: {}, fail: {}, pass: {}",
+            "i-scale: {}, p-scale: {}, rebase-(x): {}, fail: {}, pass: {}",
             input_scale.to_string().blue(),
             param_scale.to_string().blue(),
-            scale_rebase_multiplier.to_string().blue(),
-            div_rebasing.to_string().yellow(),
+            scale_rebase_multiplier.to_string().yellow(),
             num_failed.to_string().red(),
             num_passed.to_string().green()
         ));
 
-        let key = (
-            input_scale,
-            param_scale,
-            scale_rebase_multiplier,
-            div_rebasing,
-        );
+        let key = (input_scale, param_scale, scale_rebase_multiplier);
         forward_pass_res.insert(key, vec![]);
 
         let local_run_args = RunArgs {
             input_scale,
             param_scale,
             scale_rebase_multiplier,
-            div_rebasing,
-            lookup_range: (i64::MIN, i64::MAX),
+            lookup_range: (IntegerRep::MIN, IntegerRep::MAX),
             ..settings.run_args.clone()
         };
 
         // if unix get a gag
-        #[cfg(unix)]
+        #[cfg(all(not(not(feature = "ezkl")), unix))]
         let _r = match Gag::stdout() {
             Ok(g) => Some(g),
             _ => None,
         };
-        #[cfg(unix)]
+        #[cfg(all(not(not(feature = "ezkl")), unix))]
         let _g = match Gag::stderr() {
             Ok(g) => Some(g),
             _ => None,
@@ -1171,8 +1109,10 @@ pub(crate) async fn calibrate(
                         &mut data.clone(),
                         None,
                         None,
-                        true,
-                        false,
+                        RegionSettings::all_true(
+                            settings.run_args.decomp_base,
+                            settings.run_args.decomp_legs,
+                        ),
                     )
                     .map_err(|e| format!("failed to forward: {}", e))?;
 
@@ -1198,9 +1138,9 @@ pub(crate) async fn calibrate(
         }
 
         // drop the gag
-        #[cfg(unix)]
+        #[cfg(all(not(not(feature = "ezkl")), unix))]
         drop(_r);
-        #[cfg(unix)]
+        #[cfg(all(not(not(feature = "ezkl")), unix))]
         drop(_g);
 
         let result = forward_pass_res.get(&key).ok_or("key not found")?;
@@ -1232,7 +1172,6 @@ pub(crate) async fn calibrate(
             let found_run_args = RunArgs {
                 input_scale: new_settings.run_args.input_scale,
                 param_scale: new_settings.run_args.param_scale,
-                div_rebasing: new_settings.run_args.div_rebasing,
                 lookup_range: new_settings.run_args.lookup_range,
                 logrows: new_settings.run_args.logrows,
                 scale_rebase_multiplier: new_settings.run_args.scale_rebase_multiplier,
@@ -1248,6 +1187,7 @@ pub(crate) async fn calibrate(
                 num_rows: new_settings.num_rows,
                 total_assignments: new_settings.total_assignments,
                 total_const_size: new_settings.total_const_size,
+                total_dynamic_col_size: new_settings.total_dynamic_col_size,
                 ..settings.clone()
             };
 
@@ -1339,7 +1279,6 @@ pub(crate) async fn calibrate(
             best_params.run_args.input_scale,
             best_params.run_args.param_scale,
             best_params.run_args.scale_rebase_multiplier,
-            best_params.run_args.div_rebasing,
         ))
         .ok_or("no params found")?
         .iter()
@@ -1365,9 +1304,13 @@ pub(crate) async fn calibrate(
         let lookup_log_rows = best_params.lookup_log_rows_with_blinding();
         let module_log_row = best_params.module_constraint_logrows_with_blinding();
         let instance_logrows = best_params.log2_total_instances_with_blinding();
-        let dynamic_lookup_logrows = best_params.dynamic_lookup_and_shuffle_logrows_with_blinding();
+        let dynamic_lookup_logrows =
+            best_params.min_dynamic_lookup_and_shuffle_logrows_with_blinding();
+
+        let range_check_logrows = best_params.range_check_log_rows_with_blinding();
 
         let mut reduction = std::cmp::max(lookup_log_rows, module_log_row);
+        reduction = std::cmp::max(reduction, range_check_logrows);
         reduction = std::cmp::max(reduction, instance_logrows);
         reduction = std::cmp::max(reduction, dynamic_lookup_logrows);
         reduction = std::cmp::max(reduction, crate::graph::MIN_LOGROWS);
@@ -1413,14 +1356,13 @@ pub(crate) fn mock(
     Ok(String::new())
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn create_evm_verifier(
     vk_path: PathBuf,
     srs_path: Option<PathBuf>,
     settings_path: PathBuf,
     sol_code_path: PathBuf,
     abi_path: PathBuf,
-    render_vk_seperately: bool,
+    reusable: bool,
 ) -> Result<String, EZKLError> {
     let settings = GraphSettings::load(&settings_path)?;
     let commitment: Commitments = settings.run_args.commitment.into();
@@ -1442,24 +1384,23 @@ pub(crate) async fn create_evm_verifier(
         halo2_solidity_verifier::BatchOpenScheme::Bdfg21,
         num_instance,
     );
-    let verifier_solidity = if render_vk_seperately {
-        generator.render_separately()?.0 // ignore the rendered vk for now and generate it in create_evm_vk
+    let (verifier_solidity, name) = if reusable {
+        (generator.render_separately()?.0, "Halo2VerifierReusable") // ignore the rendered vk artifact for now and generate it in create_evm_vka
     } else {
-        generator.render()?
+        (generator.render()?, "Halo2Verifier")
     };
 
     File::create(sol_code_path.clone())?.write_all(verifier_solidity.as_bytes())?;
 
     // fetch abi of the contract
-    let (abi, _, _) = get_contract_artifacts(sol_code_path, "Halo2Verifier", 0).await?;
+    let (abi, _, _) = get_contract_artifacts(sol_code_path, name, 0).await?;
     // save abi to file
     serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
 
     Ok(String::new())
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) async fn create_evm_vk(
+pub(crate) async fn create_evm_vka(
     vk_path: PathBuf,
     srs_path: Option<PathBuf>,
     settings_path: PathBuf,
@@ -1492,14 +1433,13 @@ pub(crate) async fn create_evm_vk(
     File::create(sol_code_path.clone())?.write_all(vk_solidity.as_bytes())?;
 
     // fetch abi of the contract
-    let (abi, _, _) = get_contract_artifacts(sol_code_path, "Halo2VerifyingKey", 0).await?;
+    let (abi, _, _) = get_contract_artifacts(sol_code_path, "Halo2VerifyingArtifact", 0).await?;
     // save abi to file
     serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
 
     Ok(String::new())
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn create_evm_data_attestation(
     settings_path: PathBuf,
     sol_code_path: PathBuf,
@@ -1519,13 +1459,24 @@ pub(crate) async fn create_evm_data_attestation(
     // if input is not provided, we just instantiate dummy input data
     let data = GraphData::from_path(input).unwrap_or(GraphData::new(DataSource::File(vec![])));
 
+    // The number of input and output instances we attest to for the single call data attestation
+    let mut input_len = None;
+    let mut output_len = None;
+
     let output_data = if let Some(DataSource::OnChain(source)) = data.output_data {
         if visibility.output.is_private() {
             return Err("private output data on chain is not supported on chain".into());
         }
         let mut on_chain_output_data = vec![];
-        for call in source.calls {
-            on_chain_output_data.push(call);
+        match source.calls {
+            Calls::Multiple(calls) => {
+                for call in calls {
+                    on_chain_output_data.push(call);
+                }
+            }
+            Calls::Single(call) => {
+                output_len = Some(call.len);
+            }
         }
         Some(on_chain_output_data)
     } else {
@@ -1537,8 +1488,15 @@ pub(crate) async fn create_evm_data_attestation(
             return Err("private input data on chain is not supported on chain".into());
         }
         let mut on_chain_input_data = vec![];
-        for call in source.calls {
-            on_chain_input_data.push(call);
+        match source.calls {
+            Calls::Multiple(calls) => {
+                for call in calls {
+                    on_chain_input_data.push(call);
+                }
+            }
+            Calls::Single(call) => {
+                input_len = Some(call.len);
+            }
         }
         Some(on_chain_input_data)
     } else {
@@ -1565,18 +1523,28 @@ pub(crate) async fn create_evm_data_attestation(
         None
     };
 
-    let output = fix_da_sol(input_data, output_data, commitment_bytes)?;
-    let mut f = File::create(sol_code_path.clone())?;
-    let _ = f.write(output.as_bytes());
-    // fetch abi of the contract
-    let (abi, _, _) = get_contract_artifacts(sol_code_path, "DataAttestation", 0).await?;
-    // save abi to file
-    serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
+    // if either input_len or output_len is Some then we are in the single call data attestation mode
+    if input_len.is_some() || output_len.is_some() {
+        let output = fix_da_single_sol(input_len, output_len)?;
+        let mut f = File::create(sol_code_path.clone())?;
+        let _ = f.write(output.as_bytes());
+        // fetch abi of the contract
+        let (abi, _, _) = get_contract_artifacts(sol_code_path, "DataAttestationSingle", 0).await?;
+        // save abi to file
+        serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
+    } else {
+        let output = fix_da_multi_sol(input_data, output_data, commitment_bytes)?;
+        let mut f = File::create(sol_code_path.clone())?;
+        let _ = f.write(output.as_bytes());
+        // fetch abi of the contract
+        let (abi, _, _) = get_contract_artifacts(sol_code_path, "DataAttestationMulti", 0).await?;
+        // save abi to file
+        serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
+    }
 
     Ok(String::new())
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn deploy_da_evm(
     data: PathBuf,
     settings_path: PathBuf,
@@ -1603,15 +1571,19 @@ pub(crate) async fn deploy_da_evm(
     Ok(String::new())
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn deploy_evm(
     sol_code_path: PathBuf,
     rpc_url: Option<String>,
     addr_path: PathBuf,
     runs: usize,
     private_key: Option<String>,
-    contract_name: &str,
+    contract: ContractType,
 ) -> Result<String, EZKLError> {
+    let contract_name = match contract {
+        ContractType::Verifier { reusable: false } => "Halo2Verifier",
+        ContractType::Verifier { reusable: true } => "Halo2VerifierReusable",
+        ContractType::VerifyingKeyArtifact => "Halo2VerifyingArtifact",
+    };
     let contract_address = deploy_contract_via_solidity(
         sol_code_path,
         rpc_url.as_deref(),
@@ -1654,7 +1626,6 @@ pub(crate) fn encode_evm_calldata(
     Ok(encoded)
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn verify_evm(
     proof_path: PathBuf,
     addr_verifier: H160Flag,
@@ -1694,7 +1665,6 @@ pub(crate) async fn verify_evm(
     Ok(String::new())
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn create_evm_aggregate_verifier(
     vk_path: PathBuf,
     srs_path: Option<PathBuf>,
@@ -1702,7 +1672,7 @@ pub(crate) async fn create_evm_aggregate_verifier(
     abi_path: PathBuf,
     circuit_settings: Vec<PathBuf>,
     logrows: u32,
-    render_vk_seperately: bool,
+    reusable: bool,
 ) -> Result<String, EZKLError> {
     let srs_path = get_srs_path(logrows, srs_path, Commitments::KZG);
     let params: ParamsKZG<Bn256> = load_srs_verifier::<KZGCommitmentScheme<Bn256>>(srs_path)?;
@@ -1740,8 +1710,8 @@ pub(crate) async fn create_evm_aggregate_verifier(
 
     generator = generator.set_acc_encoding(Some(acc_encoding));
 
-    let verifier_solidity = if render_vk_seperately {
-        generator.render_separately()?.0 // ignore the rendered vk for now and generate it in create_evm_vk
+    let verifier_solidity = if reusable {
+        generator.render_separately()?.0 // ignore the rendered vk artifact for now and generate it in create_evm_vka
     } else {
         generator.render()?
     };
@@ -1818,7 +1788,6 @@ pub(crate) fn setup(
     Ok(String::new())
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn setup_test_evm_witness(
     data_path: PathBuf,
     compiled_circuit_path: PathBuf,
@@ -1854,9 +1823,7 @@ pub(crate) async fn setup_test_evm_witness(
     Ok(String::new())
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 use crate::pfsys::ProofType;
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn test_update_account_calls(
     addr: H160Flag,
     data: PathBuf,
@@ -1869,7 +1836,6 @@ pub(crate) async fn test_update_account_calls(
     Ok(String::new())
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn prove(
     data_path: PathBuf,
@@ -2067,7 +2033,6 @@ pub(crate) fn mock_aggregate(
         }
     }
     // proof aggregation
-    #[cfg(not(target_arch = "wasm32"))]
     let pb = {
         let pb = init_spinner();
         pb.set_message("Aggregating (may take a while)...");
@@ -2079,7 +2044,6 @@ pub(crate) fn mock_aggregate(
     let prover = halo2_proofs::dev::MockProver::run(logrows, &circuit, vec![circuit.instances()])
         .map_err(|e| ExecutionError::MockProverError(e.to_string()))?;
     prover.verify().map_err(ExecutionError::VerifyError)?;
-    #[cfg(not(target_arch = "wasm32"))]
     pb.finish_with_message("Done.");
     Ok(String::new())
 }
@@ -2174,7 +2138,6 @@ pub(crate) fn aggregate(
     }
 
     // proof aggregation
-    #[cfg(not(target_arch = "wasm32"))]
     let pb = {
         let pb = init_spinner();
         pb.set_message("Aggregating (may take a while)...");
@@ -2324,7 +2287,6 @@ pub(crate) fn aggregate(
     );
     snark.save(&proof_path)?;
 
-    #[cfg(not(target_arch = "wasm32"))]
     pb.finish_with_message("Done.");
 
     Ok(snark)

src/fieldutils.rs

@@ -2,17 +2,11 @@ use halo2_proofs::arithmetic::Field;
 /// Utilities for converting from Halo2 PrimeField types to integers (and vice-versa).
 use halo2curves::ff::PrimeField;
 
-/// Converts an i32 to a PrimeField element.
-pub fn i32_to_felt<F: PrimeField>(x: i32) -> F {
-    if x >= 0 {
-        F::from(x as u64)
-    } else {
-        -F::from(x.unsigned_abs() as u64)
-    }
-}
+/// Integer representation of a PrimeField element.
+pub type IntegerRep = i128;
 
 /// Converts an i64 to a PrimeField element.
-pub fn i64_to_felt<F: PrimeField>(x: i64) -> F {
+pub fn integer_rep_to_felt<F: PrimeField>(x: IntegerRep) -> F {
     if x >= 0 {
         F::from_u128(x as u128)
     } else {
@@ -20,24 +14,9 @@ pub fn i64_to_felt<F: PrimeField>(x: i64) -> F {
     }
 }
 
-/// Converts a PrimeField element to an i32.
-pub fn felt_to_i32<F: PrimeField + PartialOrd + Field>(x: F) -> i32 {
-    if x > F::from(i32::MAX as u64) {
-        let rep = (-x).to_repr();
-        let negtmp: &[u8] = rep.as_ref();
-        let lower_32 = u32::from_le_bytes(negtmp[..4].try_into().unwrap());
-        -(lower_32 as i32)
-    } else {
-        let rep = (x).to_repr();
-        let tmp: &[u8] = rep.as_ref();
-        let lower_32 = u32::from_le_bytes(tmp[..4].try_into().unwrap());
-        lower_32 as i32
-    }
-}
-
 /// Converts a PrimeField element to an f64.
 pub fn felt_to_f64<F: PrimeField + PartialOrd + Field>(x: F) -> f64 {
-    if x > F::from_u128(i64::MAX as u128) {
+    if x > F::from_u128(IntegerRep::MAX as u128) {
         let rep = (-x).to_repr();
         let negtmp: &[u8] = rep.as_ref();
         let lower_128: u128 = u128::from_le_bytes(negtmp[..16].try_into().unwrap());
@@ -51,17 +30,17 @@ pub fn felt_to_f64<F: PrimeField + PartialOrd + Field>(x: F) -> f64 {
 }
 
 /// Converts a PrimeField element to an i64.
-pub fn felt_to_i64<F: PrimeField + PartialOrd + Field>(x: F) -> i64 {
-    if x > F::from_u128(i64::MAX as u128) {
+pub fn felt_to_integer_rep<F: PrimeField + PartialOrd + Field>(x: F) -> IntegerRep {
+    if x > F::from_u128(IntegerRep::MAX as u128) {
         let rep = (-x).to_repr();
         let negtmp: &[u8] = rep.as_ref();
         let lower_128: u128 = u128::from_le_bytes(negtmp[..16].try_into().unwrap());
-        -(lower_128 as i64)
+        -(lower_128 as IntegerRep)
     } else {
         let rep = (x).to_repr();
         let tmp: &[u8] = rep.as_ref();
         let lower_128: u128 = u128::from_le_bytes(tmp[..16].try_into().unwrap());
-        lower_128 as i64
+        lower_128 as IntegerRep
     }
 }
 
@@ -73,33 +52,24 @@ mod test {
 
     #[test]
     fn test_conv() {
-        let res: F = i32_to_felt(-15i32);
+        let res: F = integer_rep_to_felt(-15);
         assert_eq!(res, -F::from(15));
 
-        let res: F = i32_to_felt(2_i32.pow(17));
+        let res: F = integer_rep_to_felt(2_i128.pow(17));
         assert_eq!(res, F::from(131072));
 
-        let res: F = i64_to_felt(-15i64);
+        let res: F = integer_rep_to_felt(-15);
         assert_eq!(res, -F::from(15));
 
-        let res: F = i64_to_felt(2_i64.pow(17));
+        let res: F = integer_rep_to_felt(2_i128.pow(17));
         assert_eq!(res, F::from(131072));
     }
 
     #[test]
-    fn felttoi32() {
-        for x in -(2i32.pow(16))..(2i32.pow(16)) {
-            let fieldx: F = i32_to_felt::<F>(x);
-            let xf: i32 = felt_to_i32::<F>(fieldx);
-            assert_eq!(x, xf);
-        }
-    }
-
-    #[test]
-    fn felttoi64() {
-        for x in -(2i64.pow(20))..(2i64.pow(20)) {
-            let fieldx: F = i64_to_felt::<F>(x);
-            let xf: i64 = felt_to_i64::<F>(fieldx);
+    fn felttointegerrep() {
+        for x in -(2_i128.pow(16))..(2_i128.pow(16)) {
+            let fieldx: F = integer_rep_to_felt::<F>(x);
+            let xf: i128 = felt_to_integer_rep::<F>(fieldx);
             assert_eq!(x, xf);
         }
     }

src/graph/errors.rs

@@ -48,7 +48,10 @@ pub enum GraphError {
     #[error("failed to ser/deser model: {0}")]
     ModelSerialize(#[from] bincode::Error),
     /// Tract error
-    #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+    #[cfg(all(
+        feature = "ezkl",
+        not(all(target_arch = "wasm32", target_os = "unknown"))
+    ))]
     #[error("[tract] {0}")]
     TractError(#[from] tract_onnx::prelude::TractError),
     /// Packing exponent is too large
@@ -85,11 +88,17 @@ pub enum GraphError {
     #[error("unknown dimension batch_size in model inputs, set batch_size in variables")]
     MissingBatchSize,
     /// Tokio postgres error
-    #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+    #[cfg(all(
+        feature = "ezkl",
+        not(all(target_arch = "wasm32", target_os = "unknown"))
+    ))]
     #[error("[tokio postgres] {0}")]
     TokioPostgresError(#[from] tokio_postgres::Error),
     /// Eth error
-    #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+    #[cfg(all(
+        feature = "ezkl",
+        not(all(target_arch = "wasm32", target_os = "unknown"))
+    ))]
     #[error("[eth] {0}")]
     EthError(#[from] crate::eth::EthError),
     /// Json error

src/graph/input.rs

@@ -1,10 +1,10 @@
 use super::errors::GraphError;
 use super::quantize_float;
 use crate::circuit::InputType;
-use crate::fieldutils::i64_to_felt;
-#[cfg(not(target_arch = "wasm32"))]
+use crate::fieldutils::integer_rep_to_felt;
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::graph::postgres::Client;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::tensor::Tensor;
 use crate::EZKL_BUF_CAPACITY;
 use halo2curves::bn256::Fr as Fp;
@@ -20,12 +20,12 @@ use std::io::BufReader;
 use std::io::BufWriter;
 use std::io::Read;
 use std::panic::UnwindSafe;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::tract_core::{
     tract_data::{prelude::Tensor as TractTensor, TVec},
     value::TValue,
 };
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::tract_hir::tract_num_traits::ToPrimitive;
 
 type Decimals = u8;
@@ -128,7 +128,9 @@ impl FileSourceInner {
     /// Convert to a field element
     pub fn to_field(&self, scale: crate::Scale) -> Fp {
         match self {
-            FileSourceInner::Float(f) => i64_to_felt(quantize_float(f, 0.0, scale).unwrap()),
+            FileSourceInner::Float(f) => {
+                integer_rep_to_felt(quantize_float(f, 0.0, scale).unwrap())
+            }
             FileSourceInner::Bool(f) => {
                 if *f {
                     Fp::one()
@@ -150,28 +152,89 @@ impl FileSourceInner {
                     0.0
                 }
             }
-            FileSourceInner::Field(f) => crate::fieldutils::felt_to_i64(*f) as f64,
+            FileSourceInner::Field(f) => crate::fieldutils::felt_to_integer_rep(*f) as f64,
         }
     }
 }
 
+/// Call type for attested inputs on-chain
+#[derive(Clone, Debug, PartialOrd, PartialEq)]
+pub enum Calls {
+    /// Vector of calls to accounts, each returning an attested data point
+    Multiple(Vec<CallsToAccount>),
+    /// Single call to account, returning an array of attested data points
+    Single(CallToAccount),
+}
+
+impl Default for Calls {
+    fn default() -> Self {
+        Calls::Multiple(Vec::new())
+    }
+}
 /// Inner elements of inputs/outputs coming from on-chain
 #[derive(Clone, Debug, Deserialize, Serialize, Default, PartialOrd, PartialEq)]
 pub struct OnChainSource {
-    /// Vector of calls to accounts
-    pub calls: Vec<CallsToAccount>,
+    /// Calls to accounts
+    pub calls: Calls,
     /// RPC url
     pub rpc: RPCUrl,
 }
 
 impl OnChainSource {
-    /// Create a new OnChainSource
-    pub fn new(calls: Vec<CallsToAccount>, rpc: RPCUrl) -> Self {
-        OnChainSource { calls, rpc }
+    /// Create a new OnChainSource with multiple calls
+    pub fn new_multiple(calls: Vec<CallsToAccount>, rpc: RPCUrl) -> Self {
+        OnChainSource {
+            calls: Calls::Multiple(calls),
+            rpc,
+        }
+    }
+
+    /// Create a new OnChainSource with a single call
+    pub fn new_single(call: CallToAccount, rpc: RPCUrl) -> Self {
+        OnChainSource {
+            calls: Calls::Single(call),
+            rpc,
+        }
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
+impl Serialize for Calls {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            Calls::Single(data) => data.serialize(serializer),
+            Calls::Multiple(data) => data.serialize(serializer),
+        }
+    }
+}
+
+// !!! ALWAYS USE JSON SERIALIZATION FOR GRAPH INPUT
+// UNTAGGED ENUMS WONT WORK :( as highlighted here:
+impl<'de> Deserialize<'de> for Calls {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let this_json: Box<serde_json::value::RawValue> = Deserialize::deserialize(deserializer)?;
+
+        let multiple_try: Result<Vec<CallsToAccount>, _> = serde_json::from_str(this_json.get());
+        if let Ok(t) = multiple_try {
+            return Ok(Calls::Multiple(t));
+        }
+        let single_try: Result<CallToAccount, _> = serde_json::from_str(this_json.get());
+        if let Ok(t) = single_try {
+            return Ok(Calls::Single(t));
+        }
+
+        Err(serde::de::Error::custom(
+            "failed to deserialize FileSourceInner",
+        ))
+    }
+}
+
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 /// Inner elements of inputs/outputs coming from postgres DB
 #[derive(Clone, Debug, Deserialize, Serialize, Default, PartialOrd, PartialEq)]
 pub struct PostgresSource {
@@ -189,7 +252,7 @@ pub struct PostgresSource {
     pub port: String,
 }
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 impl PostgresSource {
     /// Create a new PostgresSource
     pub fn new(
@@ -268,7 +331,7 @@ impl PostgresSource {
 }
 
 impl OnChainSource {
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     /// Create dummy local on-chain data to test the OnChain data source
     pub async fn test_from_file_data(
         data: &FileSource,
@@ -277,7 +340,8 @@ impl OnChainSource {
         rpc: Option<&str>,
     ) -> Result<(Vec<Tensor<Fp>>, Self), GraphError> {
         use crate::eth::{
-            evm_quantize, read_on_chain_inputs, test_on_chain_data, DEFAULT_ANVIL_ENDPOINT,
+            evm_quantize_multi, read_on_chain_inputs_multi, test_on_chain_data,
+            DEFAULT_ANVIL_ENDPOINT,
         };
         use log::debug;
 
@@ -296,7 +360,7 @@ impl OnChainSource {
         let calls_to_accounts = test_on_chain_data(client.clone(), data).await?;
         debug!("Calls to accounts: {:?}", calls_to_accounts);
         let inputs =
-            read_on_chain_inputs(client.clone(), client_address, &calls_to_accounts).await?;
+            read_on_chain_inputs_multi(client.clone(), client_address, &calls_to_accounts).await?;
         debug!("Inputs: {:?}", inputs);
 
         let mut quantized_evm_inputs = vec![];
@@ -304,7 +368,7 @@ impl OnChainSource {
         let mut prev = 0;
         for (idx, i) in data.iter().enumerate() {
             quantized_evm_inputs.extend(
-                evm_quantize(
+                evm_quantize_multi(
                     client.clone(),
                     vec![scales[idx]; i.len()],
                     &(
@@ -330,7 +394,7 @@ impl OnChainSource {
         // Fill the input_data field of the GraphData struct
         Ok((
             inputs,
-            OnChainSource::new(calls_to_accounts.clone(), used_rpc),
+            OnChainSource::new_multiple(calls_to_accounts.clone(), used_rpc),
         ))
     }
 }
@@ -350,6 +414,24 @@ pub struct CallsToAccount {
     /// Address of the contract to read the data from.
     pub address: String,
 }
+
+/// Defines a view only call to accounts to fetch the on-chain input data.
+/// This data will be included as part of the first elements in the publicInputs
+/// for the sol evm verifier and will be  verifyWithDataAttestation.sol
+#[derive(Clone, Debug, Deserialize, Serialize, Default, PartialOrd, PartialEq)]
+pub struct CallToAccount {
+    /// The call_data is a byte strings representing the ABI encoded function call to
+    /// read the data from the address. This call must return a single array of integers that can be
+    /// be safely cast to the int128 type in solidity.
+    pub call_data: Call,
+    /// The number of decimals for f32 conversion of all of the elements returned from the
+    /// call.
+    pub decimals: Decimals,
+    /// Address of the contract to read the data from.
+    pub address: String,
+    /// The number of elements returned from the call.
+    pub len: usize,
+}
 /// Enum that defines source of the inputs/outputs to the EZKL model
 #[derive(Clone, Debug, Serialize, PartialOrd, PartialEq)]
 #[serde(untagged)]
@@ -359,7 +441,7 @@ pub enum DataSource {
     /// On-chain data source. The first element is the calls to the account, and the second is the RPC url.
     OnChain(OnChainSource),
     /// Postgres DB
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     DB(PostgresSource),
 }
 
@@ -419,7 +501,7 @@ impl<'de> Deserialize<'de> for DataSource {
         if let Ok(t) = second_try {
             return Ok(DataSource::OnChain(t));
         }
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
         {
             let third_try: Result<PostgresSource, _> = serde_json::from_str(this_json.get());
             if let Ok(t) = third_try {
@@ -445,7 +527,7 @@ impl UnwindSafe for GraphData {}
 
 impl GraphData {
     // not wasm
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     /// Convert the input data to tract data
     pub fn to_tract_data(
         &self,
@@ -530,7 +612,7 @@ impl GraphData {
                     "on-chain data cannot be split into batches".to_string(),
                 ))
             }
-            #[cfg(not(target_arch = "wasm32"))]
+            #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
             GraphData {
                 input_data: DataSource::DB(data),
                 output_data: _,
@@ -600,6 +682,28 @@ impl ToPyObject for CallsToAccount {
     }
 }
 
+#[cfg(feature = "python-bindings")]
+impl ToPyObject for CallToAccount {
+    fn to_object(&self, py: Python) -> PyObject {
+        let dict = PyDict::new(py);
+        dict.set_item("account", &self.address).unwrap();
+        dict.set_item("call_data", &self.call_data).unwrap();
+        dict.set_item("decimals", &self.decimals).unwrap();
+        dict.set_item("len", &self.len).unwrap();
+        dict.to_object(py)
+    }
+}
+
+#[cfg(feature = "python-bindings")]
+impl ToPyObject for Calls {
+    fn to_object(&self, py: Python) -> PyObject {
+        match self {
+            Calls::Multiple(calls) => calls.to_object(py),
+            Calls::Single(call) => call.to_object(py),
+        }
+    }
+}
+
 #[cfg(feature = "python-bindings")]
 impl ToPyObject for DataSource {
     fn to_object(&self, py: Python) -> PyObject {
@@ -608,7 +712,8 @@ impl ToPyObject for DataSource {
             DataSource::OnChain(source) => {
                 let dict = PyDict::new(py);
                 dict.set_item("rpc_url", &source.rpc).unwrap();
-                dict.set_item("calls_to_accounts", &source.calls).unwrap();
+                dict.set_item("calls_to_accounts", &source.calls.to_object(py))
+                    .unwrap();
                 dict.to_object(py)
             }
             DataSource::DB(source) => {

src/graph/mod.rs

@@ -7,7 +7,7 @@ pub mod modules;
 /// Inner elements of a computational graph that represent a single operation / constraints.
 pub mod node;
 /// postgres helper functions
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 pub mod postgres;
 /// Helper functions
 pub mod utilities;
@@ -17,27 +17,28 @@ pub mod vars;
 /// errors for the graph
 pub mod errors;
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use colored_json::ToColoredJson;
-#[cfg(unix)]
+#[cfg(all(not(not(feature = "ezkl")), unix))]
 use gag::Gag;
 use halo2_proofs::plonk::VerifyingKey;
 use halo2_proofs::poly::commitment::CommitmentScheme;
 pub use input::DataSource;
 use itertools::Itertools;
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tosubcommand::ToFlags;
 
 use self::errors::GraphError;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use self::input::OnChainSource;
 use self::input::{FileSource, GraphData};
 use self::modules::{GraphModules, ModuleConfigs, ModuleForwardResult, ModuleSizes};
 use crate::circuit::lookup::LookupOp;
 use crate::circuit::modules::ModulePlanner;
-use crate::circuit::region::ConstantsMap;
+use crate::circuit::region::{ConstantsMap, RegionSettings};
 use crate::circuit::table::{num_cols_required, Range, Table, RESERVED_BLINDING_ROWS_PAD};
 use crate::circuit::{CheckMode, InputType};
-use crate::fieldutils::felt_to_f64;
+use crate::fieldutils::{felt_to_f64, IntegerRep};
 use crate::pfsys::PrettyElements;
 use crate::tensor::{Tensor, ValTensor};
 use crate::{RunArgs, EZKL_BUF_CAPACITY};
@@ -48,7 +49,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{self, Fr as Fp, G1Affine};
 use halo2curves::ff::{Field, PrimeField};
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use lazy_static::lazy_static;
 use log::{debug, error, trace, warn};
 use maybe_rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
@@ -59,7 +60,10 @@ use pyo3::prelude::*;
 #[cfg(feature = "python-bindings")]
 use pyo3::types::PyDict;
 #[cfg(feature = "python-bindings")]
+use pyo3::types::PyDictMethods;
+#[cfg(feature = "python-bindings")]
 use pyo3::ToPyObject;
+
 use serde::{Deserialize, Serialize};
 use std::ops::Deref;
 pub use utilities::*;
@@ -69,15 +73,16 @@ pub use vars::*;
 use crate::pfsys::field_to_string;
 
 /// The safety factor for the range of the lookup table.
-pub const RANGE_MULTIPLIER: i64 = 2;
+pub const RANGE_MULTIPLIER: IntegerRep = 2;
 
 /// The maximum number of columns in a lookup table.
 pub const MAX_NUM_LOOKUP_COLS: usize = 12;
 
 /// Max representation of a lookup table input
-pub const MAX_LOOKUP_ABS: i64 = (MAX_NUM_LOOKUP_COLS as i64) * 2_i64.pow(MAX_PUBLIC_SRS);
+pub const MAX_LOOKUP_ABS: IntegerRep =
+    (MAX_NUM_LOOKUP_COLS as IntegerRep) * 2_i128.pow(MAX_PUBLIC_SRS);
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 lazy_static! {
     /// Max circuit area
     pub static ref EZKL_MAX_CIRCUIT_AREA: Option<usize> =
@@ -88,7 +93,7 @@ lazy_static! {
         };
 }
 
-#[cfg(target_arch = "wasm32")]
+#[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
 const EZKL_MAX_CIRCUIT_AREA: Option<usize> = None;
 
 ///
@@ -126,11 +131,13 @@ pub struct GraphWitness {
     /// Any hashes of outputs generated during the forward pass
     pub processed_outputs: Option<ModuleForwardResult>,
     /// max lookup input
-    pub max_lookup_inputs: i64,
+    pub max_lookup_inputs: IntegerRep,
     /// max lookup input
-    pub min_lookup_inputs: i64,
+    pub min_lookup_inputs: IntegerRep,
     /// max range check size
-    pub max_range_size: i64,
+    pub max_range_size: IntegerRep,
+    /// (optional) version of ezkl used
+    pub version: Option<String>,
 }
 
 impl GraphWitness {
@@ -159,6 +166,7 @@ impl GraphWitness {
             max_lookup_inputs: 0,
             min_lookup_inputs: 0,
             max_range_size: 0,
+            version: None,
         }
     }
 
@@ -338,10 +346,10 @@ impl ToPyObject for GraphWitness {
         if let Some(processed_inputs) = &self.processed_inputs {
             //poseidon_hash
             if let Some(processed_inputs_poseidon_hash) = &processed_inputs.poseidon_hash {
-                insert_poseidon_hash_pydict(dict_inputs, processed_inputs_poseidon_hash).unwrap();
+                insert_poseidon_hash_pydict(&dict_inputs, processed_inputs_poseidon_hash).unwrap();
             }
             if let Some(processed_inputs_polycommit) = &processed_inputs.polycommit {
-                insert_polycommit_pydict(dict_inputs, processed_inputs_polycommit).unwrap();
+                insert_polycommit_pydict(&dict_inputs, processed_inputs_polycommit).unwrap();
             }
 
             dict.set_item("processed_inputs", dict_inputs).unwrap();
@@ -349,10 +357,10 @@ impl ToPyObject for GraphWitness {
 
         if let Some(processed_params) = &self.processed_params {
             if let Some(processed_params_poseidon_hash) = &processed_params.poseidon_hash {
-                insert_poseidon_hash_pydict(dict_params, processed_params_poseidon_hash).unwrap();
+                insert_poseidon_hash_pydict(&dict_params, processed_params_poseidon_hash).unwrap();
             }
             if let Some(processed_params_polycommit) = &processed_params.polycommit {
-                insert_polycommit_pydict(dict_inputs, processed_params_polycommit).unwrap();
+                insert_polycommit_pydict(&dict_params, processed_params_polycommit).unwrap();
             }
 
             dict.set_item("processed_params", dict_params).unwrap();
@@ -360,10 +368,11 @@ impl ToPyObject for GraphWitness {
 
         if let Some(processed_outputs) = &self.processed_outputs {
             if let Some(processed_outputs_poseidon_hash) = &processed_outputs.poseidon_hash {
-                insert_poseidon_hash_pydict(dict_outputs, processed_outputs_poseidon_hash).unwrap();
+                insert_poseidon_hash_pydict(&dict_outputs, processed_outputs_poseidon_hash)
+                    .unwrap();
             }
             if let Some(processed_outputs_polycommit) = &processed_outputs.polycommit {
-                insert_polycommit_pydict(dict_inputs, processed_outputs_polycommit).unwrap();
+                insert_polycommit_pydict(&dict_outputs, processed_outputs_polycommit).unwrap();
             }
 
             dict.set_item("processed_outputs", dict_outputs).unwrap();
@@ -374,7 +383,10 @@ impl ToPyObject for GraphWitness {
 }
 
 #[cfg(feature = "python-bindings")]
-fn insert_poseidon_hash_pydict(pydict: &PyDict, poseidon_hash: &Vec<Fp>) -> Result<(), PyErr> {
+fn insert_poseidon_hash_pydict(
+    pydict: &Bound<'_, PyDict>,
+    poseidon_hash: &Vec<Fp>,
+) -> Result<(), PyErr> {
     let poseidon_hash: Vec<String> = poseidon_hash.iter().map(field_to_string).collect();
     pydict.set_item("poseidon_hash", poseidon_hash)?;
 
@@ -382,8 +394,11 @@ fn insert_poseidon_hash_pydict(pydict: &PyDict, poseidon_hash: &Vec<Fp>) -> Resu
 }
 
 #[cfg(feature = "python-bindings")]
-fn insert_polycommit_pydict(pydict: &PyDict, commits: &Vec<Vec<G1Affine>>) -> Result<(), PyErr> {
-    use crate::python::PyG1Affine;
+fn insert_polycommit_pydict(
+    pydict: &Bound<'_, PyDict>,
+    commits: &Vec<Vec<G1Affine>>,
+) -> Result<(), PyErr> {
+    use crate::bindings::python::PyG1Affine;
     let poseidon_hash: Vec<Vec<PyG1Affine>> = commits
         .iter()
         .map(|c| c.iter().map(|x| PyG1Affine::from(*x)).collect())
@@ -406,6 +421,8 @@ pub struct GraphSettings {
     pub total_const_size: usize,
     /// total dynamic column size
     pub total_dynamic_col_size: usize,
+    /// max dynamic column input length
+    pub max_dynamic_input_len: usize,
     /// number of dynamic lookups
     pub num_dynamic_lookups: usize,
     /// number of shuffles
@@ -450,6 +467,18 @@ impl GraphSettings {
             .ceil() as u32
     }
 
+    /// Calc the number of rows required for the range checks
+    pub fn range_check_log_rows_with_blinding(&self) -> u32 {
+        let max_range = self
+            .required_range_checks
+            .iter()
+            .map(|x| x.1 - x.0)
+            .max()
+            .unwrap_or(0);
+
+        (max_range as f32).log2().ceil() as u32
+    }
+
     fn model_constraint_logrows_with_blinding(&self) -> u32 {
         (self.num_rows as f64 + RESERVED_BLINDING_ROWS as f64)
             .log2()
@@ -471,6 +500,13 @@ impl GraphSettings {
             .ceil() as u32
     }
 
+    /// calculate the number of rows required for the dynamic lookup and shuffle
+    pub fn min_dynamic_lookup_and_shuffle_logrows_with_blinding(&self) -> u32 {
+        (self.max_dynamic_input_len as f64 + RESERVED_BLINDING_ROWS as f64)
+            .log2()
+            .ceil() as u32
+    }
+
     fn dynamic_lookup_and_shuffle_col_size(&self) -> usize {
         self.total_dynamic_col_size + self.total_shuffle_col_size
     }
@@ -684,6 +720,7 @@ impl std::fmt::Display for TestDataSource {
     }
 }
 
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 impl ToFlags for TestDataSource {}
 
 impl From<String> for TestDataSource {
@@ -804,18 +841,26 @@ impl GraphCircuit {
         // the ordering here is important, we want the inputs to come before the outputs
         // as they are configured in that order as Column<Instances>
         let mut public_inputs: Vec<Fp> = vec![];
-        if self.settings().run_args.input_visibility.is_public() {
-            public_inputs.extend(self.graph_witness.inputs.clone().into_iter().flatten())
-        } else if let Some(processed_inputs) = &data.processed_inputs {
+
+        // we first process the inputs
+        if let Some(processed_inputs) = &data.processed_inputs {
             public_inputs.extend(processed_inputs.get_instances().into_iter().flatten());
         }
 
+        // we then process the params
         if let Some(processed_params) = &data.processed_params {
             public_inputs.extend(processed_params.get_instances().into_iter().flatten());
         }
 
+        // if the inputs are public, we add them to the public inputs AFTER the processed params as they are configured in that order as Column<Instances>
+        if self.settings().run_args.input_visibility.is_public() {
+            public_inputs.extend(self.graph_witness.inputs.clone().into_iter().flatten())
+        }
+
+        // if the outputs are public, we add them to the public inputs
         if self.settings().run_args.output_visibility.is_public() {
             public_inputs.extend(self.graph_witness.outputs.clone().into_iter().flatten());
+        // if the outputs are processed, we add the processed outputs to the public inputs
         } else if let Some(processed_outputs) = &data.processed_outputs {
             public_inputs.extend(processed_outputs.get_instances().into_iter().flatten());
         }
@@ -864,7 +909,7 @@ impl GraphCircuit {
             public_inputs.processed_outputs = elements.processed_outputs.clone();
         }
 
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
         debug!(
             "rescaled and processed public inputs: {}",
             serde_json::to_string(&public_inputs)?.to_colored_json_auto()?
@@ -874,7 +919,7 @@ impl GraphCircuit {
     }
 
     ///
-    #[cfg(target_arch = "wasm32")]
+    #[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
     pub fn load_graph_input(&mut self, data: &GraphData) -> Result<Vec<Tensor<Fp>>, GraphError> {
         let shapes = self.model().graph.input_shapes()?;
         let scales = self.model().graph.get_input_scales();
@@ -901,7 +946,7 @@ impl GraphCircuit {
     }
 
     ///
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     pub async fn load_graph_input(
         &mut self,
         data: &GraphData,
@@ -915,7 +960,7 @@ impl GraphCircuit {
             .await
     }
 
-    #[cfg(target_arch = "wasm32")]
+    #[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
     /// Process the data source for the model
     fn process_data_source(
         &mut self,
@@ -932,7 +977,7 @@ impl GraphCircuit {
         }
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     /// Process the data source for the model
     async fn process_data_source(
         &mut self,
@@ -962,18 +1007,31 @@ impl GraphCircuit {
     }
 
     /// Prepare on chain test data
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     pub async fn load_on_chain_data(
         &mut self,
         source: OnChainSource,
         shapes: &Vec<Vec<usize>>,
         scales: Vec<crate::Scale>,
     ) -> Result<Vec<Tensor<Fp>>, GraphError> {
-        use crate::eth::{evm_quantize, read_on_chain_inputs, setup_eth_backend};
+        use crate::eth::{
+            evm_quantize_multi, evm_quantize_single, read_on_chain_inputs_multi,
+            read_on_chain_inputs_single, setup_eth_backend,
+        };
         let (client, client_address) = setup_eth_backend(Some(&source.rpc), None).await?;
-        let inputs = read_on_chain_inputs(client.clone(), client_address, &source.calls).await?;
-        // quantize the supplied data using the provided scale + QuantizeData.sol
-        let quantized_evm_inputs = evm_quantize(client, scales, &inputs).await?;
+        let quantized_evm_inputs = match source.calls {
+            input::Calls::Single(call) => {
+                let (inputs, decimals) =
+                    read_on_chain_inputs_single(client.clone(), client_address, call).await?;
+
+                evm_quantize_single(client, scales, &inputs, decimals).await?
+            }
+            input::Calls::Multiple(calls) => {
+                let inputs =
+                    read_on_chain_inputs_multi(client.clone(), client_address, &calls).await?;
+                evm_quantize_multi(client, scales, &inputs).await?
+            }
+        };
         // on-chain data has already been quantized at this point. Just need to reshape it and push into tensor vector
         let mut inputs: Vec<Tensor<Fp>> = vec![];
         for (input, shape) in [quantized_evm_inputs].iter().zip(shapes) {
@@ -1036,12 +1094,12 @@ impl GraphCircuit {
 
     fn calc_safe_lookup_range(min_max_lookup: Range, lookup_safety_margin: f64) -> Range {
         (
-            (lookup_safety_margin * min_max_lookup.0 as f64).floor() as i64,
-            (lookup_safety_margin * min_max_lookup.1 as f64).ceil() as i64,
+            (lookup_safety_margin * min_max_lookup.0 as f64).floor() as IntegerRep,
+            (lookup_safety_margin * min_max_lookup.1 as f64).ceil() as IntegerRep,
         )
     }
 
-    fn calc_num_cols(range_len: i64, max_logrows: u32) -> usize {
+    fn calc_num_cols(range_len: IntegerRep, max_logrows: u32) -> usize {
         let max_col_size = Table::<Fp>::cal_col_size(max_logrows as usize, RESERVED_BLINDING_ROWS);
         num_cols_required(range_len, max_col_size)
     }
@@ -1049,7 +1107,7 @@ impl GraphCircuit {
     fn table_size_logrows(
         &self,
         safe_lookup_range: Range,
-        max_range_size: i64,
+        max_range_size: IntegerRep,
     ) -> Result<u32, GraphError> {
         // pick the range with the largest absolute size safe_lookup_range or max_range_size
         let safe_range = std::cmp::max(
@@ -1068,7 +1126,7 @@ impl GraphCircuit {
     pub fn calc_min_logrows(
         &mut self,
         min_max_lookup: Range,
-        max_range_size: i64,
+        max_range_size: IntegerRep,
         max_logrows: Option<u32>,
         lookup_safety_margin: f64,
     ) -> Result<(), GraphError> {
@@ -1086,7 +1144,7 @@ impl GraphCircuit {
             (safe_lookup_range.1.saturating_sub(safe_lookup_range.0)).saturating_abs();
         // check if has overflowed max lookup input
 
-        if lookup_size > (MAX_LOOKUP_ABS as f64 / lookup_safety_margin).floor() as i64 {
+        if lookup_size > (MAX_LOOKUP_ABS as f64 / lookup_safety_margin).floor() as IntegerRep {
             return Err(GraphError::LookupRangeTooLarge(
                 lookup_size.unsigned_abs() as usize
             ));
@@ -1166,7 +1224,7 @@ impl GraphCircuit {
         &self,
         k: u32,
         safe_lookup_range: Range,
-        max_range_size: i64,
+        max_range_size: IntegerRep,
     ) -> bool {
         // if num cols is too large then the extended k is too large
         if Self::calc_num_cols(safe_lookup_range.1 - safe_lookup_range.0, k) > MAX_NUM_LOOKUP_COLS
@@ -1181,12 +1239,12 @@ impl GraphCircuit {
         settings.required_range_checks = vec![(0, max_range_size)];
         let mut cs = ConstraintSystem::default();
         // if unix get a gag
-        #[cfg(unix)]
+        #[cfg(all(not(not(feature = "ezkl")), unix))]
         let _r = match Gag::stdout() {
             Ok(g) => Some(g),
             _ => None,
         };
-        #[cfg(unix)]
+        #[cfg(all(not(not(feature = "ezkl")), unix))]
         let _g = match Gag::stderr() {
             Ok(g) => Some(g),
             _ => None,
@@ -1195,9 +1253,9 @@ impl GraphCircuit {
         Self::configure_with_params(&mut cs, settings);
 
         // drop the gag
-        #[cfg(unix)]
+        #[cfg(all(not(not(feature = "ezkl")), unix))]
         drop(_r);
-        #[cfg(unix)]
+        #[cfg(all(not(not(feature = "ezkl")), unix))]
         drop(_g);
 
         #[cfg(feature = "mv-lookup")]
@@ -1224,8 +1282,7 @@ impl GraphCircuit {
         inputs: &mut [Tensor<Fp>],
         vk: Option<&VerifyingKey<G1Affine>>,
         srs: Option<&Scheme::ParamsProver>,
-        witness_gen: bool,
-        check_lookup: bool,
+        region_settings: RegionSettings,
     ) -> Result<GraphWitness, GraphError> {
         let original_inputs = inputs.to_vec();
 
@@ -1274,7 +1331,7 @@ impl GraphCircuit {
 
         let mut model_results =
             self.model()
-                .forward(inputs, &self.settings().run_args, witness_gen, check_lookup)?;
+                .forward(inputs, &self.settings().run_args, region_settings)?;
 
         if visibility.output.requires_processing() {
             let module_outlets = visibility.output.overwrites_inputs();
@@ -1319,6 +1376,7 @@ impl GraphCircuit {
             max_lookup_inputs: model_results.max_lookup_inputs,
             min_lookup_inputs: model_results.min_lookup_inputs,
             max_range_size: model_results.max_range_size,
+            version: Some(crate::version().to_string()),
         };
 
         witness.generate_rescaled_elements(
@@ -1327,7 +1385,7 @@ impl GraphCircuit {
             visibility,
         );
 
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
         log::trace!(
             "witness: \n {}",
             &witness.as_json()?.to_colored_json_auto()?
@@ -1337,7 +1395,7 @@ impl GraphCircuit {
     }
 
     /// Create a new circuit from a set of input data and [RunArgs].
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     pub fn from_run_args(
         run_args: &RunArgs,
         model_path: &std::path::Path,
@@ -1347,7 +1405,7 @@ impl GraphCircuit {
     }
 
     /// Create a new circuit from a set of input data and [GraphSettings].
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     pub fn from_settings(
         params: &GraphSettings,
         model_path: &std::path::Path,
@@ -1362,7 +1420,7 @@ impl GraphCircuit {
     }
 
     ///
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     pub async fn populate_on_chain_test_data(
         &mut self,
         data: &mut GraphData,
@@ -1455,7 +1513,7 @@ impl CircuitSize {
         }
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     /// Export the ezkl configuration as json
     pub fn as_json(&self) -> Result<String, GraphError> {
         let serialized = match serde_json::to_string(&self) {
@@ -1543,7 +1601,7 @@ impl Circuit<Fp> for GraphCircuit {
 
         let circuit_size = CircuitSize::from_cs(cs, params.run_args.logrows);
 
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
         debug!(
             "circuit size: \n {}",
             circuit_size

src/graph/model.rs

@@ -7,10 +7,12 @@ use super::GraphSettings;
 use crate::circuit::hybrid::HybridOp;
 use crate::circuit::region::ConstantsMap;
 use crate::circuit::region::RegionCtx;
+use crate::circuit::region::RegionSettings;
 use crate::circuit::table::Range;
 use crate::circuit::Input;
 use crate::circuit::InputType;
 use crate::circuit::Unknown;
+use crate::fieldutils::IntegerRep;
 use crate::tensor::ValType;
 use crate::{
     circuit::{lookup::LookupOp, BaseConfig as PolyConfig, CheckMode, Op},
@@ -19,9 +21,9 @@ use crate::{
 };
 use halo2curves::bn256::Fr as Fp;
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use super::input::GraphData;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use colored::Colorize;
 use halo2_proofs::{
     circuit::{Layouter, Value},
@@ -34,29 +36,29 @@ use log::{debug, info, trace};
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::BTreeMap;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use std::collections::HashMap;
 use std::collections::HashSet;
 use std::fs;
 use std::io::Read;
 use std::path::PathBuf;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tabled::Table;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::prelude::{
     Framework, Graph, InferenceFact, InferenceModelExt, SymbolValues, TypedFact, TypedOp,
 };
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::tract_core::internal::DatumType;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::tract_hir::ops::scan::Scan;
 use unzip_n::unzip_n;
 
 unzip_n!(pub 3);
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 type TractResult = (Graph<TypedFact, Box<dyn TypedOp>>, SymbolValues);
 /// The result of a forward pass.
 #[derive(Clone, Debug)]
@@ -64,11 +66,11 @@ pub struct ForwardResult {
     /// The outputs of the forward pass.
     pub outputs: Vec<Tensor<Fp>>,
     /// The maximum value of any input to a lookup operation.
-    pub max_lookup_inputs: i64,
+    pub max_lookup_inputs: IntegerRep,
     /// The minimum value of any input to a lookup operation.
-    pub min_lookup_inputs: i64,
+    pub min_lookup_inputs: IntegerRep,
     /// The max range check size
-    pub max_range_size: i64,
+    pub max_range_size: IntegerRep,
 }
 
 impl From<DummyPassRes> for ForwardResult {
@@ -101,6 +103,8 @@ pub struct DummyPassRes {
     pub num_rows: usize,
     /// num dynamic lookups
     pub num_dynamic_lookups: usize,
+    /// max dynamic lookup input len
+    pub max_dynamic_input_len: usize,
     /// dynamic lookup col size
     pub dynamic_lookup_col_coord: usize,
     /// num shuffles
@@ -116,11 +120,11 @@ pub struct DummyPassRes {
     /// range checks
     pub range_checks: HashSet<Range>,
     /// max lookup inputs
-    pub max_lookup_inputs: i64,
+    pub max_lookup_inputs: IntegerRep,
     /// min lookup inputs
-    pub min_lookup_inputs: i64,
+    pub min_lookup_inputs: IntegerRep,
     /// min range check
-    pub max_range_size: i64,
+    pub max_range_size: IntegerRep,
     /// outputs
     pub outputs: Vec<Tensor<Fp>>,
 }
@@ -358,6 +362,14 @@ impl NodeType {
             NodeType::SubGraph { .. } => SupportedOp::Unknown(Unknown),
         }
     }
+
+    /// check if it is a softmax
+    pub fn is_softmax(&self) -> bool {
+        match self {
+            NodeType::Node(n) => n.is_softmax(),
+            NodeType::SubGraph { .. } => false,
+        }
+    }
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
@@ -468,7 +480,7 @@ impl Model {
     /// # Arguments
     /// * `reader` - A reader for an Onnx file.
     /// * `run_args` - [RunArgs]
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     pub fn new(reader: &mut dyn std::io::Read, run_args: &RunArgs) -> Result<Self, GraphError> {
         let visibility = VarVisibility::from_args(run_args)?;
 
@@ -515,7 +527,7 @@ impl Model {
         check_mode: CheckMode,
     ) -> Result<GraphSettings, GraphError> {
         let instance_shapes = self.instance_shapes()?;
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
         debug!(
             "{} {} {}",
             "model has".blue(),
@@ -545,7 +557,11 @@ impl Model {
             })
             .collect::<Result<Vec<_>, GraphError>>()?;
 
-        let res = self.dummy_layout(run_args, &inputs, false, false)?;
+        let res = self.dummy_layout(
+            run_args,
+            &inputs,
+            RegionSettings::all_false(run_args.decomp_base, run_args.decomp_legs),
+        )?;
 
         // if we're using percentage tolerance, we need to add the necessary range check ops for it.
 
@@ -556,6 +572,7 @@ impl Model {
             num_rows: res.num_rows,
             total_assignments: res.linear_coord,
             required_lookups: res.lookup_ops.into_iter().collect(),
+            max_dynamic_input_len: res.max_dynamic_input_len,
             required_range_checks: res.range_checks.into_iter().collect(),
             model_output_scales: self.graph.get_output_scales()?,
             model_input_scales: self.graph.get_input_scales(),
@@ -568,13 +585,13 @@ impl Model {
             version: env!("CARGO_PKG_VERSION").to_string(),
             num_blinding_factors: None,
             // unix time timestamp
-            #[cfg(not(target_arch = "wasm32"))]
+            #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
             timestamp: Some(
                 instant::SystemTime::now()
                     .duration_since(instant::SystemTime::UNIX_EPOCH)?
                     .as_millis(),
             ),
-            #[cfg(target_arch = "wasm32")]
+            #[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
             timestamp: None,
         })
     }
@@ -588,14 +605,13 @@ impl Model {
         &self,
         model_inputs: &[Tensor<Fp>],
         run_args: &RunArgs,
-        witness_gen: bool,
-        check_lookup: bool,
+        region_settings: RegionSettings,
     ) -> Result<ForwardResult, GraphError> {
         let valtensor_inputs: Vec<ValTensor<Fp>> = model_inputs
             .iter()
             .map(|x| x.map(|elem| ValType::Value(Value::known(elem))).into())
             .collect();
-        let res = self.dummy_layout(run_args, &valtensor_inputs, witness_gen, check_lookup)?;
+        let res = self.dummy_layout(run_args, &valtensor_inputs, region_settings)?;
         Ok(res.into())
     }
 
@@ -604,7 +620,7 @@ impl Model {
     /// * `reader` - A reader for an Onnx file.
     /// * `scale` - The scale to use for quantization.
     /// * `public_params` - Whether to make the params public.
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     fn load_onnx_using_tract(
         reader: &mut dyn std::io::Read,
         run_args: &RunArgs,
@@ -640,7 +656,7 @@ impl Model {
 
         let mut symbol_values = SymbolValues::default();
         for (symbol, value) in run_args.variables.iter() {
-            let symbol = model.symbol_table.sym(symbol);
+            let symbol = model.symbols.sym(symbol);
             symbol_values = symbol_values.with(&symbol, *value as i64);
             debug!("set {} to {}", symbol, value);
         }
@@ -659,7 +675,7 @@ impl Model {
     /// * `reader` - A reader for an Onnx file.
     /// * `scale` - The scale to use for quantization.
     /// * `public_params` - Whether to make the params public.
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     fn load_onnx_model(
         reader: &mut dyn std::io::Read,
         run_args: &RunArgs,
@@ -695,7 +711,7 @@ impl Model {
     }
 
     /// Formats nodes (including subgraphs) into tables !
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     pub fn table_nodes(&self) -> String {
         let mut node_accumulator = vec![];
         let mut string = String::new();
@@ -737,7 +753,7 @@ impl Model {
     /// * `visibility` - Which inputs to the model are public and private (params, inputs, outputs) using [VarVisibility].
     /// * `input_scales` - The scales of the model's inputs.
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     pub fn nodes_from_graph(
         graph: &Graph<TypedFact, Box<dyn TypedOp>>,
         run_args: &RunArgs,
@@ -882,16 +898,8 @@ impl Model {
                     );
                 }
                 None => {
-                    let mut n = Node::new(
-                        n.clone(),
-                        &mut nodes,
-                        scales,
-                        &run_args.param_visibility,
-                        i,
-                        symbol_values,
-                        run_args.div_rebasing,
-                        run_args.rebase_frac_zero_constants,
-                    )?;
+                    let mut n =
+                        Node::new(n.clone(), &mut nodes, scales, i, symbol_values, run_args)?;
                     if let Some(ref scales) = override_input_scales {
                         if let Some(inp) = n.opkind.get_input() {
                             let scale = scales[input_idx];
@@ -907,20 +915,9 @@ impl Model {
                         if scales.contains_key(&i) {
                             let scale_diff = n.out_scale - scales[&i];
                             n.opkind = if scale_diff > 0 {
-                                RebaseScale::rebase(
-                                    n.opkind,
-                                    scales[&i],
-                                    n.out_scale,
-                                    1,
-                                    run_args.div_rebasing,
-                                )
+                                RebaseScale::rebase(n.opkind, scales[&i], n.out_scale, 1)
                             } else {
-                                RebaseScale::rebase_up(
-                                    n.opkind,
-                                    scales[&i],
-                                    n.out_scale,
-                                    run_args.div_rebasing,
-                                )
+                                RebaseScale::rebase_up(n.opkind, scales[&i], n.out_scale)
                             };
                             n.out_scale = scales[&i];
                         }
@@ -934,7 +931,7 @@ impl Model {
         Ok(nodes)
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     /// Removes all nodes that are consts with 0 uses
     fn remove_unused_nodes(nodes: &mut BTreeMap<usize, NodeType>) {
         // remove all nodes that are consts with 0 uses now
@@ -953,7 +950,7 @@ impl Model {
         });
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     /// Run tract onnx model on sample data !
     pub fn run_onnx_predictions(
         run_args: &RunArgs,
@@ -994,7 +991,7 @@ impl Model {
     /// Creates a `Model` from parsed run_args
     /// # Arguments
     /// * `params` - A [GraphSettings] struct holding parsed CLI arguments.
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     pub fn from_run_args(run_args: &RunArgs, model: &std::path::Path) -> Result<Self, GraphError> {
         let mut file = std::fs::File::open(model).map_err(|e| {
             GraphError::ReadWriteFileError(model.display().to_string(), e.to_string())
@@ -1111,6 +1108,8 @@ impl Model {
                     region,
                     0,
                     run_args.num_inner_cols,
+                    run_args.decomp_base,
+                    run_args.decomp_legs,
                     original_constants.clone(),
                 );
                 // we need to do this as this loop is called multiple times
@@ -1167,7 +1166,7 @@ impl Model {
                     })?;
                 }
                 // Then number of columns in the circuits
-                #[cfg(not(target_arch = "wasm32"))]
+                #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
                 thread_safe_region.debug_report();
 
                 *constants = thread_safe_region.assigned_constants().clone();
@@ -1198,11 +1197,11 @@ impl Model {
         for (idx, node) in self.graph.nodes.iter() {
             debug!("laying out {}: {}", idx, node.as_str(),);
             // Then number of columns in the circuits
-            #[cfg(not(target_arch = "wasm32"))]
+            #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
             region.debug_report();
-            debug!("input indices: {:?}", node.inputs());
-            debug!("output scales: {:?}", node.out_scales());
-            debug!(
+            trace!("input indices: {:?}", node.inputs());
+            trace!("output scales: {:?}", node.out_scales());
+            trace!(
                 "input scales: {:?}",
                 node.inputs()
                     .iter()
@@ -1221,8 +1220,8 @@ impl Model {
                 // we re-assign inputs, always from the 0 outlet
                 vec![results.get(idx).ok_or(GraphError::MissingResults)?[0].clone()]
             };
-            debug!("output dims: {:?}", node.out_dims());
-            debug!(
+            trace!("output dims: {:?}", node.out_dims());
+            trace!(
                 "input dims {:?}",
                 values.iter().map(|v| v.dims()).collect_vec()
             );
@@ -1390,8 +1389,7 @@ impl Model {
         &self,
         run_args: &RunArgs,
         inputs: &[ValTensor<Fp>],
-        witness_gen: bool,
-        check_lookup: bool,
+        region_settings: RegionSettings,
     ) -> Result<DummyPassRes, GraphError> {
         debug!("calculating num of constraints using dummy model layout...");
 
@@ -1410,8 +1408,7 @@ impl Model {
             vars: ModelVars::new_dummy(),
         };
 
-        let mut region =
-            RegionCtx::new_dummy(0, run_args.num_inner_cols, witness_gen, check_lookup);
+        let mut region = RegionCtx::new_dummy(0, run_args.num_inner_cols, region_settings);
 
         let outputs = self.layout_nodes(&mut model_config, &mut region, &mut results)?;
 
@@ -1454,7 +1451,7 @@ impl Model {
         trace!("dummy model layout took: {:?}", duration);
 
         // Then number of columns in the circuits
-        #[cfg(not(target_arch = "wasm32"))]
+        #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
         region.debug_report();
 
         let outputs = outputs
@@ -1468,6 +1465,7 @@ impl Model {
         let res = DummyPassRes {
             num_rows: region.row(),
             linear_coord: region.linear_coord(),
+            max_dynamic_input_len: region.max_dynamic_input_len(),
             total_const_size: region.total_constants(),
             lookup_ops: region.used_lookups(),
             range_checks: region.used_range_checks(),

src/graph/node.rs

@@ -1,9 +1,9 @@
 use super::scale_to_multiplier;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use super::utilities::node_output_shapes;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use super::VarScales;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use super::Visibility;
 use crate::circuit::hybrid::HybridOp;
 use crate::circuit::lookup::LookupOp;
@@ -13,29 +13,29 @@ use crate::circuit::Constant;
 use crate::circuit::Input;
 use crate::circuit::Op;
 use crate::circuit::Unknown;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::graph::errors::GraphError;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::graph::new_op_from_onnx;
 use crate::tensor::TensorError;
 use halo2curves::bn256::Fr as Fp;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use log::trace;
 use serde::Deserialize;
 use serde::Serialize;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use std::collections::BTreeMap;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use std::fmt;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tabled::Tabled;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::{
     self,
     prelude::{Node as OnnxNode, SymbolValues, TypedFact, TypedOp},
 };
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 fn display_vector<T: fmt::Debug>(v: &Vec<T>) -> String {
     if !v.is_empty() {
         format!("{:?}", v)
@@ -44,7 +44,7 @@ fn display_vector<T: fmt::Debug>(v: &Vec<T>) -> String {
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 fn display_opkind(v: &SupportedOp) -> String {
     v.as_string()
 }
@@ -120,11 +120,11 @@ impl RebaseScale {
         global_scale: crate::Scale,
         op_out_scale: crate::Scale,
         scale_rebase_multiplier: u32,
-        div_rebasing: bool,
     ) -> SupportedOp {
         if (op_out_scale > (global_scale * scale_rebase_multiplier as i32))
             && !inner.is_constant()
             && !inner.is_input()
+            && !inner.is_identity()
         {
             let multiplier =
                 scale_to_multiplier(op_out_scale - global_scale * scale_rebase_multiplier as i32);
@@ -136,7 +136,6 @@ impl RebaseScale {
                     multiplier,
                     rebase_op: HybridOp::Div {
                         denom: crate::circuit::utils::F32((multiplier) as f32),
-                        use_range_check_for_int: !div_rebasing,
                     },
                     original_scale: op.original_scale,
                 })
@@ -147,7 +146,6 @@ impl RebaseScale {
                     multiplier,
                     rebase_op: HybridOp::Div {
                         denom: crate::circuit::utils::F32(multiplier as f32),
-                        use_range_check_for_int: !div_rebasing,
                     },
                     original_scale: op_out_scale,
                 })
@@ -162,7 +160,6 @@ impl RebaseScale {
         inner: SupportedOp,
         target_scale: crate::Scale,
         op_out_scale: crate::Scale,
-        div_rebasing: bool,
     ) -> SupportedOp {
         if (op_out_scale < (target_scale)) && !inner.is_constant() && !inner.is_input() {
             let multiplier = scale_to_multiplier(op_out_scale - target_scale);
@@ -175,7 +172,6 @@ impl RebaseScale {
                     original_scale: op.original_scale,
                     rebase_op: HybridOp::Div {
                         denom: crate::circuit::utils::F32((multiplier) as f32),
-                        use_range_check_for_int: !div_rebasing,
                     },
                 })
             } else {
@@ -186,7 +182,6 @@ impl RebaseScale {
                     original_scale: op_out_scale,
                     rebase_op: HybridOp::Div {
                         denom: crate::circuit::utils::F32(multiplier as f32),
-                        use_range_check_for_int: !div_rebasing,
                     },
                 })
             }
@@ -302,7 +297,7 @@ impl SupportedOp {
         }
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     fn homogenous_rescale(
         &self,
         in_scales: Vec<crate::Scale>,
@@ -326,6 +321,19 @@ impl SupportedOp {
             SupportedOp::RebaseScale(op) => op,
         }
     }
+
+    /// check if is the identity operation
+    /// # Returns
+    /// * `true` if the operation is the identity operation
+    /// * `false` otherwise
+    pub fn is_identity(&self) -> bool {
+        match self {
+            SupportedOp::Linear(op) => matches!(op, PolyOp::Identity { .. }),
+            SupportedOp::Rescaled(op) => op.inner.is_identity(),
+            SupportedOp::RebaseScale(op) => op.inner.is_identity(),
+            _ => false,
+        }
+    }
 }
 
 impl From<Box<dyn Op<Fp>>> for SupportedOp {
@@ -427,7 +435,7 @@ pub struct Node {
     pub num_uses: usize,
 }
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 impl Tabled for Node {
     const LENGTH: usize = 6;
 
@@ -467,17 +475,15 @@ impl Node {
     /// * `other_nodes` - [BTreeMap] of other previously initialized [Node]s in the computational graph.
     /// * `public_params` - flag if parameters of model are public
     /// * `idx` - The node's unique identifier.
-    #[cfg(not(target_arch = "wasm32"))]
+    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         node: OnnxNode<TypedFact, Box<dyn TypedOp>>,
         other_nodes: &mut BTreeMap<usize, super::NodeType>,
         scales: &VarScales,
-        param_visibility: &Visibility,
         idx: usize,
         symbol_values: &SymbolValues,
-        div_rebasing: bool,
-        rebase_frac_zero_constants: bool,
+        run_args: &crate::RunArgs,
     ) -> Result<Self, GraphError> {
         trace!("Create {:?}", node);
         trace!("Create op {:?}", node.op);
@@ -517,11 +523,10 @@ impl Node {
         let (mut opkind, deleted_indices) = new_op_from_onnx(
             idx,
             scales,
-            param_visibility,
             node.clone(),
             &mut inputs,
             symbol_values,
-            rebase_frac_zero_constants,
+            run_args,
         )?; // parses the op name
 
         // we can only take the inputs as mutable once -- so we need to collect them first
@@ -569,7 +574,7 @@ impl Node {
                     rescale_const_with_single_use(
                         constant,
                         in_scales.clone(),
-                        param_visibility,
+                        &run_args.param_visibility,
                         input_node.num_uses(),
                     )?;
                     input_node.replace_opkind(constant.clone_dyn().into());
@@ -584,13 +589,7 @@ impl Node {
         let mut out_scale = opkind.out_scale(in_scales.clone())?;
         // rescale the inputs if necessary to get consistent fixed points, we select the largest scale (highest precision)
         let global_scale = scales.get_max();
-        opkind = RebaseScale::rebase(
-            opkind,
-            global_scale,
-            out_scale,
-            scales.rebase_multiplier,
-            div_rebasing,
-        );
+        opkind = RebaseScale::rebase(opkind, global_scale, out_scale, scales.rebase_multiplier);
 
         out_scale = opkind.out_scale(in_scales)?;
 
@@ -612,9 +611,18 @@ impl Node {
             num_uses,
         })
     }
+
+    /// check if it is a softmax node
+    pub fn is_softmax(&self) -> bool {
+        if let SupportedOp::Hybrid(HybridOp::Softmax { .. }) = self.opkind {
+            true
+        } else {
+            false
+        }
+    }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 fn rescale_const_with_single_use(
     constant: &mut Constant<Fp>,
     in_scales: Vec<crate::Scale>,

src/graph/postgres.rs

@@ -1,7 +1,7 @@
 use log::{debug, error, info};
 use std::fmt::Debug;
 use std::net::IpAddr;
-#[cfg(unix)]
+#[cfg(all(not(not(feature = "ezkl")), unix))]
 use std::path::Path;
 use std::str::FromStr;
 use std::sync::Arc;
@@ -150,7 +150,7 @@ impl Config {
     /// Adds a Unix socket host to the configuration.
     ///
     /// Unlike `host`, this method allows non-UTF8 paths.
-    #[cfg(unix)]
+    #[cfg(all(not(not(feature = "ezkl")), unix))]
     pub fn host_path<T>(&mut self, host: T) -> &mut Config
     where
         T: AsRef<Path>,

src/graph/utilities.rs

@@ -1,25 +1,26 @@
 use super::errors::GraphError;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use super::VarScales;
 use super::{Rescaled, SupportedOp, Visibility};
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::circuit::hybrid::HybridOp;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::circuit::lookup::LookupOp;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::circuit::poly::PolyOp;
 use crate::circuit::Op;
+use crate::fieldutils::IntegerRep;
 use crate::tensor::{Tensor, TensorError, TensorType};
 use halo2curves::bn256::Fr as Fp;
 use halo2curves::ff::PrimeField;
 use itertools::Itertools;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use log::{debug, warn};
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use std::sync::Arc;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::prelude::{DatumType, Node as OnnxNode, TypedFact, TypedOp};
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::tract_core::ops::{
     array::{
         Gather, GatherElements, GatherNd, MultiBroadcastTo, OneHot, ScatterElements, ScatterNd,
@@ -32,7 +33,7 @@ use tract_onnx::tract_core::ops::{
     nn::{LeakyRelu, Reduce, Softmax},
     Downsample,
 };
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::tract_hir::{
     internal::DimLike,
     ops::array::{Pad, PadMode, TypedConcat},
@@ -40,7 +41,7 @@ use tract_onnx::tract_hir::{
     ops::konst::Const,
     ops::nn::DataFormat,
     tract_core::ops::cast::Cast,
-    tract_core::ops::cnn::{conv::KernelFormat, MaxPool, PaddingSpec, SumPool},
+    tract_core::ops::cnn::{conv::KernelFormat, MaxPool, SumPool},
 };
 
 /// Quantizes an iterable of f32s to a [Tensor] of i32s using a fixed point representation.
@@ -50,16 +51,20 @@ use tract_onnx::tract_hir::{
 /// * `dims` - the dimensionality of the resulting [Tensor].
 /// * `shift` - offset used in the fixed point representation.
 /// * `scale` - `2^scale` used in the fixed point representation.
-pub fn quantize_float(elem: &f64, shift: f64, scale: crate::Scale) -> Result<i64, TensorError> {
+pub fn quantize_float(
+    elem: &f64,
+    shift: f64,
+    scale: crate::Scale,
+) -> Result<IntegerRep, TensorError> {
     let mult = scale_to_multiplier(scale);
-    let max_value = ((i64::MAX as f64 - shift) / mult).round(); // the maximum value that can be represented w/o sig bit truncation
+    let max_value = ((IntegerRep::MAX as f64 - shift) / mult).round(); // the maximum value that can be represented w/o sig bit truncation
 
     if *elem > max_value {
         return Err(TensorError::SigBitTruncationError);
     }
 
     // we parallelize the quantization process as it seems to be quite slow at times
-    let scaled = (mult * *elem + shift).round() as i64;
+    let scaled = (mult * *elem + shift).round() as IntegerRep;
 
     Ok(scaled)
 }
@@ -70,7 +75,7 @@ pub fn quantize_float(elem: &f64, shift: f64, scale: crate::Scale) -> Result<i64
 /// * `scale` - `2^scale` used in the fixed point representation.
 /// * `shift` - offset used in the fixed point representation.
 pub fn dequantize(felt: Fp, scale: crate::Scale, shift: f64) -> f64 {
-    let int_rep = crate::fieldutils::felt_to_i64(felt);
+    let int_rep = crate::fieldutils::felt_to_integer_rep(felt);
     let multiplier = scale_to_multiplier(scale);
     int_rep as f64 / multiplier - shift
 }
@@ -85,25 +90,26 @@ pub fn multiplier_to_scale(mult: f64) -> crate::Scale {
     mult.log2().round() as crate::Scale
 }
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 /// extract padding from a onnx node.
 pub fn extract_padding(
     pool_spec: &PoolSpec,
-    num_dims: usize,
+    image_size: &[usize],
 ) -> Result<Vec<(usize, usize)>, GraphError> {
-    let padding = match &pool_spec.padding {
-        PaddingSpec::Explicit(b, a) | PaddingSpec::ExplicitOnnxPool(b, a, _) => {
-            b.iter().zip(a.iter()).map(|(b, a)| (*b, *a)).collect()
-        }
-        PaddingSpec::Valid => vec![(0, 0); num_dims],
-        _ => {
-            return Err(GraphError::MissingParams("padding".to_string()));
-        }
-    };
+    let num_relevant_dims = pool_spec.kernel_shape.len();
+
+    // get the last num_relevant_dims of the image size
+    let image_size = &image_size[image_size.len() - num_relevant_dims..];
+
+    let dims = pool_spec.computed_padding(image_size);
+    let mut padding = Vec::new();
+    for dim in dims {
+        padding.push((dim.pad_before, dim.pad_after));
+    }
     Ok(padding)
 }
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 /// Extracts the strides from a onnx node.
 pub fn extract_strides(pool_spec: &PoolSpec) -> Result<Vec<usize>, GraphError> {
     Ok(pool_spec
@@ -114,7 +120,7 @@ pub fn extract_strides(pool_spec: &PoolSpec) -> Result<Vec<usize>, GraphError> {
 }
 
 /// Gets the shape of a onnx node's outlets.
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 pub fn node_output_shapes(
     node: &OnnxNode<TypedFact, Box<dyn TypedOp>>,
     symbol_values: &SymbolValues,
@@ -129,9 +135,9 @@ pub fn node_output_shapes(
     }
     Ok(shapes)
 }
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::prelude::SymbolValues;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 /// Extracts the raw values from a tensor.
 pub fn extract_tensor_value(
     input: Arc<tract_onnx::prelude::Tensor>,
@@ -240,7 +246,7 @@ pub fn extract_tensor_value(
     Ok(const_value)
 }
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 fn load_op<C: tract_onnx::prelude::Op + Clone>(
     op: &dyn tract_onnx::prelude::Op,
     idx: usize,
@@ -264,16 +270,17 @@ fn load_op<C: tract_onnx::prelude::Op + Clone>(
 /// * `param_visibility` - [Visibility] of the node.
 /// * `node` - the [OnnxNode] to be matched.
 /// * `inputs` - the node's inputs.
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 pub fn new_op_from_onnx(
     idx: usize,
     scales: &VarScales,
-    param_visibility: &Visibility,
     node: OnnxNode<TypedFact, Box<dyn TypedOp>>,
     inputs: &mut [super::NodeType],
     symbol_values: &SymbolValues,
-    rebase_frac_zero_constants: bool,
+    run_args: &crate::RunArgs,
 ) -> Result<(SupportedOp, Vec<usize>), GraphError> {
+    use std::f64::consts::E;
+
     use tract_onnx::tract_core::ops::array::Trilu;
 
     use crate::circuit::InputType;
@@ -283,10 +290,7 @@ pub fn new_op_from_onnx(
         .flat_map(|x| x.out_scales())
         .collect::<Vec<_>>();
 
-    let input_dims = inputs
-        .iter()
-        .flat_map(|x| x.out_dims())
-        .collect::<Vec<_>>();
+    let input_dims = inputs.iter().flat_map(|x| x.out_dims()).collect::<Vec<_>>();
 
     let mut replace_const = |scale: crate::Scale,
                              index: usize,
@@ -662,13 +666,16 @@ pub fn new_op_from_onnx(
 
             // if all raw_values are round then set scale to 0
             let all_round = raw_value.iter().all(|x| (x).fract() == 0.0);
-            if all_round && rebase_frac_zero_constants {
+            if all_round && run_args.rebase_frac_zero_constants {
                 constant_scale = 0;
             }
 
             // Quantize the raw value
-            let quantized_value =
-                quantize_tensor(raw_value.clone(), constant_scale, param_visibility)?;
+            let quantized_value = quantize_tensor(
+                raw_value.clone(),
+                constant_scale,
+                &run_args.param_visibility,
+            )?;
             let c = crate::circuit::ops::Constant::new(quantized_value, raw_value);
             // Create a constant op
             SupportedOp::Constant(c)
@@ -758,93 +765,52 @@ pub fn new_op_from_onnx(
                 .map(|(i, _)| i)
                 .collect::<Vec<_>>();
 
-            if const_inputs.len() != 1 {
-                return Err(GraphError::OpMismatch(idx, "Max".to_string()));
-            }
-
-            let const_idx = const_inputs[0];
-            let boxed_op = inputs[const_idx].opkind();
-            let unit = if let Some(c) = extract_const_raw_values(boxed_op) {
-                if c.len() == 1 {
-                    c[0]
-                } else {
-                    return Err(GraphError::InvalidDims(idx, "max".to_string()));
-                }
-            } else {
-                return Err(GraphError::OpMismatch(idx, "Max".to_string()));
-            };
-
             if inputs.len() == 2 {
-                if let Some(node) = inputs.get_mut(const_idx) {
-                    node.decrement_use();
-                    deleted_indices.push(const_idx);
-                }
-                if unit == 0. {
-                    SupportedOp::Nonlinear(LookupOp::ReLU)
+                if !const_inputs.is_empty() {
+                    let const_idx = const_inputs[0];
+                    let boxed_op = inputs[const_idx].opkind();
+                    let unit = if let Some(c) = extract_const_raw_values(boxed_op) {
+                        if c.len() == 1 {
+                            c[0]
+                        } else {
+                            return Err(GraphError::InvalidDims(idx, "max".to_string()));
+                        }
+                    } else {
+                        return Err(GraphError::OpMismatch(idx, "Max".to_string()));
+                    };
+                    if unit == 0. {
+                        if let Some(node) = inputs.get_mut(const_idx) {
+                            node.decrement_use();
+                            deleted_indices.push(const_idx);
+                        }
+                        SupportedOp::Linear(PolyOp::LeakyReLU {
+                            slope: 0.0.into(),
+                            scale: 1,
+                        })
+                    } else {
+                        SupportedOp::Hybrid(HybridOp::Max)
+                    }
                 } else {
-                    // get the non-constant index
-                    let non_const_idx = if const_idx == 0 { 1 } else { 0 };
-                    SupportedOp::Nonlinear(LookupOp::Max {
-                        scale: scale_to_multiplier(inputs[non_const_idx].out_scales()[0]).into(),
-                        a: crate::circuit::utils::F32(unit),
-                    })
+                    SupportedOp::Hybrid(HybridOp::Max)
                 }
             } else {
                 return Err(GraphError::InvalidDims(idx, "max".to_string()));
             }
         }
         "Min" => {
-            // Extract the min value
-            // first find the input that is a constant
-            // and then extract the value
-            let const_inputs = inputs
-                .iter()
-                .enumerate()
-                .filter(|(_, n)| n.is_constant())
-                .map(|(i, _)| i)
-                .collect::<Vec<_>>();
-
-            if const_inputs.len() != 1 {
-                return Err(GraphError::OpMismatch(idx, "Min".to_string()));
-            }
-
-            let const_idx = const_inputs[0];
-            let boxed_op = inputs[const_idx].opkind();
-            let unit = if let Some(c) = extract_const_raw_values(boxed_op) {
-                if c.len() == 1 {
-                    c[0]
-                } else {
-                    return Err(GraphError::InvalidDims(idx, "min".to_string()));
-                }
-            } else {
-                return Err(GraphError::OpMismatch(idx, "Min".to_string()));
-            };
-
             if inputs.len() == 2 {
-                if let Some(node) = inputs.get_mut(const_idx) {
-                    node.decrement_use();
-                    deleted_indices.push(const_idx);
-                }
-
-                // get the non-constant index
-                let non_const_idx = if const_idx == 0 { 1 } else { 0 };
-
-                SupportedOp::Nonlinear(LookupOp::Min {
-                    scale: scale_to_multiplier(inputs[non_const_idx].out_scales()[0]).into(),
-                    a: crate::circuit::utils::F32(unit),
-                })
+                SupportedOp::Hybrid(HybridOp::Min)
             } else {
                 return Err(GraphError::InvalidDims(idx, "min".to_string()));
             }
         }
         "Recip" => {
-            let in_scale = inputs[0].out_scales()[0];
+            let in_scale = input_scales[0];
             let max_scale = std::cmp::max(scales.get_max(), in_scale);
             // If the input scale is larger than the params scale
             SupportedOp::Hybrid(HybridOp::Recip {
                 input_scale: (scale_to_multiplier(in_scale) as f32).into(),
                 output_scale: (scale_to_multiplier(max_scale) as f32).into(),
-                use_range_check_for_int: true,
             })
         }
 
@@ -859,8 +825,9 @@ pub fn new_op_from_onnx(
                 }
             };
 
-            SupportedOp::Nonlinear(LookupOp::LeakyReLU {
+            SupportedOp::Linear(PolyOp::LeakyReLU {
                 slope: crate::circuit::utils::F32(leaky_op.alpha),
+                scale: scales.params,
             })
         }
         "Scan" => {
@@ -869,64 +836,79 @@ pub fn new_op_from_onnx(
         "QuantizeLinearU8" | "DequantizeLinearF32" => {
             SupportedOp::Linear(PolyOp::Identity { out_scale: None })
         }
-        "Abs" => SupportedOp::Nonlinear(LookupOp::Abs),
+        "Abs" => SupportedOp::Linear(PolyOp::Abs),
         "Neg" => SupportedOp::Linear(PolyOp::Neg),
         "HardSwish" => SupportedOp::Nonlinear(LookupOp::HardSwish {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Sigmoid" => SupportedOp::Nonlinear(LookupOp::Sigmoid {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
-        "Sqrt" => SupportedOp::Nonlinear(LookupOp::Sqrt {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
-        }),
-        "Rsqrt" => SupportedOp::Nonlinear(LookupOp::Rsqrt {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+        "Sqrt" => SupportedOp::Hybrid(HybridOp::Sqrt {
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
+        "Rsqrt" => {
+            let in_scale = input_scales[0];
+            let max_scale = std::cmp::max(scales.get_max(), in_scale);
+            SupportedOp::Hybrid(HybridOp::Rsqrt {
+                input_scale: (scale_to_multiplier(in_scale) as f32).into(),
+                output_scale: (scale_to_multiplier(max_scale) as f32).into(),
+            })
+        }
         "Exp" => SupportedOp::Nonlinear(LookupOp::Exp {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
-        }),
-        "Ln" => SupportedOp::Nonlinear(LookupOp::Ln {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
+            base: E.into(),
         }),
+        "Ln" => {
+            if run_args.bounded_log_lookup {
+                SupportedOp::Hybrid(HybridOp::Ln {
+                    scale: scale_to_multiplier(input_scales[0]).into(),
+                })
+            } else {
+                SupportedOp::Nonlinear(LookupOp::Ln {
+                    scale: scale_to_multiplier(input_scales[0]).into(),
+                })
+            }
+        }
+
         "Sin" => SupportedOp::Nonlinear(LookupOp::Sin {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Cos" => SupportedOp::Nonlinear(LookupOp::Cos {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Tan" => SupportedOp::Nonlinear(LookupOp::Tan {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Asin" => SupportedOp::Nonlinear(LookupOp::ASin {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Acos" => SupportedOp::Nonlinear(LookupOp::ACos {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Atan" => SupportedOp::Nonlinear(LookupOp::ATan {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Sinh" => SupportedOp::Nonlinear(LookupOp::Sinh {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Cosh" => SupportedOp::Nonlinear(LookupOp::Cosh {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Tanh" => SupportedOp::Nonlinear(LookupOp::Tanh {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Asinh" => SupportedOp::Nonlinear(LookupOp::ASinh {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Acosh" => SupportedOp::Nonlinear(LookupOp::ACosh {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Atanh" => SupportedOp::Nonlinear(LookupOp::ATanh {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Erf" => SupportedOp::Nonlinear(LookupOp::Erf {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+            scale: scale_to_multiplier(input_scales[0]).into(),
         }),
         "Source" => {
             let dt = node.outputs[0].fact.datum_type;
@@ -970,11 +952,9 @@ pub fn new_op_from_onnx(
                         replace_const(
                             0,
                             0,
-                            SupportedOp::Nonlinear(LookupOp::Cast {
-                                scale: crate::circuit::utils::F32(scale_to_multiplier(
-                                    input_scales[0],
-                                )
-                                    as f32),
+                            SupportedOp::Hybrid(HybridOp::Floor {
+                                scale: scale_to_multiplier(input_scales[0]).into(),
+                                legs: run_args.decomp_legs,
                             }),
                         )?
                     } else {
@@ -1012,8 +992,13 @@ pub fn new_op_from_onnx(
                         if raw_values.log2().fract() == 0.0 {
                             inputs[const_idx].decrement_use();
                             deleted_indices.push(const_idx);
+                            // get the non constant index
+                            let non_const_idx = if const_idx == 0 { 1 } else { 0 };
+
                             op = SupportedOp::Linear(PolyOp::Identity {
-                                out_scale: Some(input_scales[0] + raw_values.log2() as i32),
+                                out_scale: Some(
+                                    input_scales[non_const_idx] + raw_values.log2() as i32,
+                                ),
                             });
                         }
                     }
@@ -1022,21 +1007,21 @@ pub fn new_op_from_onnx(
             op
         }
         "Iff" => SupportedOp::Linear(PolyOp::Iff),
-        "Less" => {
+        "<" => {
             if inputs.len() == 2 {
                 SupportedOp::Hybrid(HybridOp::Less)
             } else {
                 return Err(GraphError::InvalidDims(idx, "less".to_string()));
             }
         }
-        "LessEqual" => {
+        "<=" => {
             if inputs.len() == 2 {
                 SupportedOp::Hybrid(HybridOp::LessEqual)
             } else {
                 return Err(GraphError::InvalidDims(idx, "less equal".to_string()));
             }
         }
-        "Greater" => {
+        ">" => {
             // Extract the slope layer hyperparams
             if inputs.len() == 2 {
                 SupportedOp::Hybrid(HybridOp::Greater)
@@ -1044,7 +1029,7 @@ pub fn new_op_from_onnx(
                 return Err(GraphError::InvalidDims(idx, "greater".to_string()));
             }
         }
-        "GreaterEqual" => {
+        ">=" => {
             // Extract the slope layer hyperparams
             if inputs.len() == 2 {
                 SupportedOp::Hybrid(HybridOp::GreaterEqual)
@@ -1075,7 +1060,7 @@ pub fn new_op_from_onnx(
                 }
             };
 
-            let in_scale = inputs[0].out_scales()[0];
+            let in_scale = input_scales[0];
             let max_scale = std::cmp::max(scales.get_max(), in_scale);
 
             SupportedOp::Hybrid(HybridOp::Softmax {
@@ -1104,7 +1089,7 @@ pub fn new_op_from_onnx(
             }
 
             let stride = extract_strides(pool_spec)?;
-            let padding = extract_padding(pool_spec, input_dims[0].len())?;
+            let padding = extract_padding(pool_spec, &input_dims[0])?;
             let kernel_shape = &pool_spec.kernel_shape;
 
             SupportedOp::Hybrid(HybridOp::MaxPool {
@@ -1113,19 +1098,23 @@ pub fn new_op_from_onnx(
                 pool_dims: kernel_shape.to_vec(),
             })
         }
-        "Ceil" => SupportedOp::Nonlinear(LookupOp::Ceil {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+        "Ceil" => SupportedOp::Hybrid(HybridOp::Ceil {
+            scale: scale_to_multiplier(input_scales[0]).into(),
+            legs: run_args.decomp_legs,
         }),
-        "Floor" => SupportedOp::Nonlinear(LookupOp::Floor {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+        "Floor" => SupportedOp::Hybrid(HybridOp::Floor {
+            scale: scale_to_multiplier(input_scales[0]).into(),
+            legs: run_args.decomp_legs,
         }),
-        "Round" => SupportedOp::Nonlinear(LookupOp::Round {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+        "Round" => SupportedOp::Hybrid(HybridOp::Round {
+            scale: scale_to_multiplier(input_scales[0]).into(),
+            legs: run_args.decomp_legs,
         }),
-        "RoundHalfToEven" => SupportedOp::Nonlinear(LookupOp::RoundHalfToEven {
-            scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
+        "RoundHalfToEven" => SupportedOp::Hybrid(HybridOp::RoundHalfToEven {
+            scale: scale_to_multiplier(input_scales[0]).into(),
+            legs: run_args.decomp_legs,
         }),
-        "Sign" => SupportedOp::Nonlinear(LookupOp::Sign),
+        "Sign" => SupportedOp::Linear(PolyOp::Sign),
         "Pow" => {
             // Extract the slope layer hyperparams from a const
 
@@ -1136,12 +1125,69 @@ pub fn new_op_from_onnx(
                 if c.raw_values.len() > 1 {
                     unimplemented!("only support scalar pow")
                 }
-                SupportedOp::Nonlinear(LookupOp::Pow {
-                    scale: scale_to_multiplier(inputs[0].out_scales()[0]).into(),
-                    a: crate::circuit::utils::F32(c.raw_values[0]),
-                })
+
+                let exponent = c.raw_values[0];
+
+                if exponent.fract() == 0.0 {
+                    SupportedOp::Linear(PolyOp::Pow(exponent as u32))
+                } else {
+                    SupportedOp::Nonlinear(LookupOp::Pow {
+                        scale: scale_to_multiplier(input_scales[0]).into(),
+                        a: crate::circuit::utils::F32(exponent),
+                    })
+                }
             } else {
-                unimplemented!("only support constant pow for now")
+                if let Some(c) = inputs[0].opkind().get_mutable_constant() {
+                    inputs[0].decrement_use();
+                    deleted_indices.push(0);
+                    if c.raw_values.len() > 1 {
+                        unimplemented!("only support scalar base")
+                    }
+
+                    let base = c.raw_values[0];
+
+                    SupportedOp::Nonlinear(LookupOp::Exp {
+                        scale: scale_to_multiplier(input_scales[1]).into(),
+                        base: base.into(),
+                    })
+                } else {
+                    unimplemented!("only support constant base or pow for now")
+                }
+            }
+        }
+        "Div" => {
+            let const_idx = inputs
+                .iter()
+                .enumerate()
+                .filter(|(_, n)| n.is_constant())
+                .map(|(i, _)| i)
+                .collect::<Vec<_>>();
+
+            if const_idx.len() > 1 {
+                return Err(GraphError::InvalidDims(idx, "div".to_string()));
+            }
+
+            let const_idx = const_idx[0];
+
+            if const_idx != 1 {
+                unimplemented!("only support div with constant as second input")
+            }
+
+            if let Some(c) = inputs[const_idx].opkind().get_mutable_constant() {
+                if c.raw_values.len() == 1 && c.raw_values[0] != 0. {
+                    inputs[const_idx].decrement_use();
+                    deleted_indices.push(const_idx);
+                    // get the non constant index
+                    let denom = c.raw_values[0];
+
+                    SupportedOp::Hybrid(HybridOp::Div {
+                        denom: denom.into(),
+                    })
+                } else {
+                    unimplemented!("only support non zero divisors of size 1")
+                }
+            } else {
+                unimplemented!("only support div with constant as second input")
             }
         }
         "Cube" => SupportedOp::Linear(PolyOp::Pow(3)),
@@ -1174,7 +1220,7 @@ pub fn new_op_from_onnx(
             let pool_spec = &conv_node.pool_spec;
 
             let stride = extract_strides(pool_spec)?;
-            let padding = extract_padding(pool_spec, input_dims[0].len())?;
+            let padding = extract_padding(pool_spec, &input_dims[0])?;
 
             // if bias exists then rescale it to the input + kernel scale
             if input_scales.len() == 3 {
@@ -1192,13 +1238,19 @@ pub fn new_op_from_onnx(
                 }
             }
 
-            SupportedOp::Linear(PolyOp::Conv { padding, stride })
+            let group = conv_node.group;
+
+            SupportedOp::Linear(PolyOp::Conv {
+                padding,
+                stride,
+                group,
+            })
         }
         "Not" => SupportedOp::Linear(PolyOp::Not),
         "And" => SupportedOp::Linear(PolyOp::And),
         "Or" => SupportedOp::Linear(PolyOp::Or),
         "Xor" => SupportedOp::Linear(PolyOp::Xor),
-        "Equals" => SupportedOp::Hybrid(HybridOp::Equals),
+        "==" => SupportedOp::Hybrid(HybridOp::Equals),
         "Deconv" => {
             let deconv_node: &Deconv = match node.op().downcast_ref::<Deconv>() {
                 Some(b) => b,
@@ -1226,7 +1278,7 @@ pub fn new_op_from_onnx(
             let pool_spec = &deconv_node.pool_spec;
 
             let stride = extract_strides(pool_spec)?;
-            let padding = extract_padding(pool_spec, input_dims[0].len())?;
+            let padding = extract_padding(pool_spec, &input_dims[0])?;
             // if bias exists then rescale it to the input + kernel scale
             if input_scales.len() == 3 {
                 let bias_scale = input_scales[2];
@@ -1247,6 +1299,7 @@ pub fn new_op_from_onnx(
                 padding,
                 output_padding: deconv_node.adjustments.to_vec(),
                 stride,
+                group: deconv_node.group,
             })
         }
         "Downsample" => {
@@ -1338,7 +1391,7 @@ pub fn new_op_from_onnx(
             }
 
             let stride = extract_strides(pool_spec)?;
-            let padding = extract_padding(pool_spec, input_dims[0].len())?;
+            let padding = extract_padding(pool_spec, &input_dims[0])?;
 
             SupportedOp::Hybrid(HybridOp::SumPool {
                 padding,
@@ -1347,11 +1400,6 @@ pub fn new_op_from_onnx(
                 normalized: sumpool_node.normalize,
             })
         }
-        // "GlobalAvgPool" => SupportedOp::Linear(PolyOp::SumPool {
-        //     padding: [(0, 0); 2],
-        //     stride: (1, 1),
-        //     kernel_shape: (inputs[0].out_dims()[0][1], inputs[0].out_dims()[0][2]),
-        // }),
         "Pad" => {
             let pad_node: &Pad = match node.op().downcast_ref::<Pad>() {
                 Some(b) => b,
@@ -1420,7 +1468,7 @@ pub fn quantize_tensor<F: PrimeField + TensorType + PartialOrd>(
     visibility: &Visibility,
 ) -> Result<Tensor<F>, TensorError> {
     let mut value: Tensor<F> = const_value.par_enum_map(|_, x| {
-        Ok::<_, TensorError>(crate::fieldutils::i64_to_felt::<F>(quantize_float(
+        Ok::<_, TensorError>(crate::fieldutils::integer_rep_to_felt::<F>(quantize_float(
             &(x).into(),
             0.0,
             scale,

src/graph/vars.rs

@@ -9,11 +9,11 @@ use itertools::Itertools;
 use log::debug;
 #[cfg(feature = "python-bindings")]
 use pyo3::{
-    exceptions::PyValueError, types::PyString, FromPyObject, IntoPy, PyAny, PyObject, PyResult,
-    PyTryFrom, Python, ToPyObject,
+    exceptions::PyValueError, FromPyObject, IntoPy, PyObject, PyResult, Python, ToPyObject,
 };
 
 use serde::{Deserialize, Serialize};
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tosubcommand::ToFlags;
 
 use self::errors::GraphError;
@@ -64,6 +64,7 @@ impl Display for Visibility {
     }
 }
 
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 impl ToFlags for Visibility {
     fn to_flags(&self) -> Vec<String> {
         vec![format!("{}", self)]
@@ -135,10 +136,8 @@ impl IntoPy<PyObject> for Visibility {
 #[cfg(feature = "python-bindings")]
 /// Obtains Visibility from PyObject (Required for Visibility to be compatible with Python)
 impl<'source> FromPyObject<'source> for Visibility {
-    fn extract(ob: &'source PyAny) -> PyResult<Self> {
-        let trystr = <PyString as PyTryFrom>::try_from(ob)?;
-        let strval = trystr.to_string();
-
+    fn extract_bound(ob: &pyo3::Bound<'source, pyo3::PyAny>) -> PyResult<Self> {
+        let strval = String::extract_bound(ob)?;
         let strval = strval.as_str();
 
         if strval.contains("hashed/private") {
@@ -441,7 +440,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ModelVars<F> {
                 let dynamic_lookup =
                     VarTensor::new_advice(cs, logrows, 1, dynamic_lookup_and_shuffle_size);
                 if dynamic_lookup.num_blocks() > 1 {
-                    panic!("dynamic lookup or shuffle should only have one block");
+                    warn!("dynamic lookup has {} blocks", dynamic_lookup.num_blocks());
                 };
                 advices.push(dynamic_lookup);
             }

src/lib.rs

@@ -23,18 +23,23 @@
 )]
 // we allow this for our dynamic range based indexing scheme
 #![allow(clippy::single_range_in_vec_init)]
+#![feature(buf_read_has_data_left)]
 #![feature(stmt_expr_attributes)]
 
 //! A library for turning computational graphs, such as neural networks, into ZK-circuits.
 //!
 
 /// Error type
+// #[cfg_attr(not(feature = "ezkl"), derive(uniffi::Error))]
 #[derive(thiserror::Error, Debug)]
 #[allow(missing_docs)]
 pub enum EZKLError {
     #[error("[aggregation] {0}")]
     AggregationError(#[from] pfsys::evm::aggregation_kzg::AggregationError),
-    #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+    #[cfg(all(
+        feature = "ezkl",
+        not(all(target_arch = "wasm32", target_os = "unknown"))
+    ))]
     #[error("[eth] {0}")]
     EthError(#[from] eth::EthError),
     #[error("[graph] {0}")]
@@ -53,7 +58,10 @@ pub enum EZKLError {
     JsonError(#[from] serde_json::Error),
     #[error("[utf8] {0}")]
     Utf8Error(#[from] std::str::Utf8Error),
-    #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+    #[cfg(all(
+        feature = "ezkl",
+        not(all(target_arch = "wasm32", target_os = "unknown"))
+    ))]
     #[error("[reqwest] {0}")]
     ReqwestError(#[from] reqwest::Error),
     #[error("[fmt] {0}")]
@@ -62,7 +70,10 @@ pub enum EZKLError {
     Halo2Error(#[from] halo2_proofs::plonk::Error),
     #[error("[Uncategorized] {0}")]
     UncategorizedError(String),
-    #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+    #[cfg(all(
+        feature = "ezkl",
+        not(all(target_arch = "wasm32", target_os = "unknown"))
+    ))]
     #[error("[execute] {0}")]
     ExecutionError(#[from] execute::ExecutionError),
     #[error("[srs] {0}")]
@@ -84,59 +95,84 @@ impl From<String> for EZKLError {
 use std::str::FromStr;
 
 use circuit::{table::Range, CheckMode, Tolerance};
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use clap::Args;
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
+use fieldutils::IntegerRep;
 use graph::Visibility;
 use halo2_proofs::poly::{
     ipa::commitment::IPACommitmentScheme, kzg::commitment::KZGCommitmentScheme,
 };
 use halo2curves::bn256::{Bn256, G1Affine};
 use serde::{Deserialize, Serialize};
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tosubcommand::ToFlags;
 
+// if CARGO VERSION is 0.0.0 replace with "source - no compatibility guaranteed"
+/// The version of the ezkl library
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// Get the version of the library
+pub fn version() -> &'static str {
+    match VERSION {
+        "0.0.0" => "source - no compatibility guaranteed",
+        _ => VERSION,
+    }
+}
+
+/// Bindings management
+#[cfg(any(
+    feature = "ios-bindings",
+    all(target_arch = "wasm32", target_os = "unknown"),
+    feature = "python-bindings"
+))]
+pub mod bindings;
 /// Methods for configuring tensor operations and assigning values to them in a Halo2 circuit.
 pub mod circuit;
 /// CLI commands.
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 pub mod commands;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 // abigen doesn't generate docs for this module
 #[allow(missing_docs)]
 /// Utility functions for contracts
 pub mod eth;
 /// Command execution
 ///
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 pub mod execute;
 /// Utilities for converting from Halo2 Field types to integers (and vice-versa).
 pub mod fieldutils;
 /// Methods for loading onnx format models and automatically laying them out in
 /// a Halo2 circuit.
-#[cfg(feature = "onnx")]
+#[cfg(any(feature = "onnx", not(feature = "ezkl")))]
 pub mod graph;
 /// beautiful logging
-#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+#[cfg(all(
+    feature = "ezkl",
+    not(all(target_arch = "wasm32", target_os = "unknown"))
+))]
 pub mod logger;
 /// Tools for proofs and verification used by cli
 pub mod pfsys;
-/// Python bindings
-#[cfg(feature = "python-bindings")]
-pub mod python;
 /// srs sha hashes
-#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+#[cfg(all(
+    feature = "ezkl",
+    not(all(target_arch = "wasm32", target_os = "unknown"))
+))]
 pub mod srs_sha;
 /// An implementation of multi-dimensional tensors.
 pub mod tensor;
-/// wasm prover and verifier
-#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
-pub mod wasm;
+#[cfg(feature = "ios-bindings")]
+uniffi::setup_scaffolding!();
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use lazy_static::lazy_static;
 
 /// The denominator in the fixed point representation used when quantizing inputs
 pub type Scale = i32;
 
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 // Buf writer capacity
 lazy_static! {
     /// The capacity of the buffer used for writing to disk
@@ -148,12 +184,13 @@ lazy_static! {
     /// The serialization format for the keys
     pub static ref EZKL_KEY_FORMAT: String = std::env::var("EZKL_KEY_FORMAT")
         .unwrap_or("raw-bytes".to_string());
+
 }
 
-#[cfg(target_arch = "wasm32")]
+#[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
 const EZKL_KEY_FORMAT: &str = "raw-bytes";
 
-#[cfg(target_arch = "wasm32")]
+#[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
 const EZKL_BUF_CAPACITY: &usize = &8000;
 
 #[derive(
@@ -206,6 +243,7 @@ impl std::fmt::Display for Commitments {
     }
 }
 
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 impl ToFlags for Commitments {
     /// Convert the struct to a subcommand string
     fn to_flags(&self) -> Vec<String> {
@@ -228,58 +266,79 @@ impl From<String> for Commitments {
 }
 
 /// Parameters specific to a proving run
-#[derive(Debug, Args, Deserialize, Serialize, Clone, PartialEq, PartialOrd, ToFlags)]
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, PartialOrd)]
+#[cfg_attr(
+    all(feature = "ezkl", not(target_arch = "wasm32")),
+    derive(Args, ToFlags)
+)]
 pub struct RunArgs {
     /// The tolerance for error on model outputs
-    #[arg(short = 'T', long, default_value = "0", value_hint = clap::ValueHint::Other)]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(short = 'T', long, default_value = "0", value_hint = clap::ValueHint::Other))]
     pub tolerance: Tolerance,
     /// The denominator in the fixed point representation used when quantizing inputs
-    #[arg(short = 'S', long, default_value = "7", value_hint = clap::ValueHint::Other)]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(short = 'S', long, default_value = "7", value_hint = clap::ValueHint::Other))]
     pub input_scale: Scale,
     /// The denominator in the fixed point representation used when quantizing parameters
-    #[arg(long, default_value = "7", value_hint = clap::ValueHint::Other)]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(long, default_value = "7", value_hint = clap::ValueHint::Other))]
     pub param_scale: Scale,
     /// if the scale is ever > scale_rebase_multiplier * input_scale then the scale is rebased to input_scale (this a more advanced parameter, use with caution)
-    #[arg(long, default_value = "1",  value_hint = clap::ValueHint::Other)]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(long, default_value = "1",  value_hint = clap::ValueHint::Other))]
     pub scale_rebase_multiplier: u32,
     /// The min and max elements in the lookup table input column
-    #[arg(short = 'B', long, value_parser = parse_key_val::<i64, i64>, default_value = "-32768->32768")]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(short = 'B', long, value_parser = parse_key_val::<IntegerRep, IntegerRep>, default_value = "-32768->32768"))]
     pub lookup_range: Range,
     /// The log_2 number of rows
-    #[arg(short = 'K', long, default_value = "17", value_hint = clap::ValueHint::Other)]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(short = 'K', long, default_value = "17", value_hint = clap::ValueHint::Other))]
     pub logrows: u32,
     /// The log_2 number of rows
-    #[arg(short = 'N', long, default_value = "2", value_hint = clap::ValueHint::Other)]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(short = 'N', long, default_value = "2", value_hint = clap::ValueHint::Other))]
     pub num_inner_cols: usize,
     /// Hand-written parser for graph variables, eg. batch_size=1
-    #[arg(short = 'V', long, value_parser = parse_key_val::<String, usize>, default_value = "batch_size->1", value_delimiter = ',', value_hint = clap::ValueHint::Other)]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(short = 'V', long, value_parser = parse_key_val::<String, usize>, default_value = "batch_size->1", value_delimiter = ',', value_hint = clap::ValueHint::Other))]
     pub variables: Vec<(String, usize)>,
     /// Flags whether inputs are public, private, fixed, hashed, polycommit
-    #[arg(long, default_value = "private", value_hint = clap::ValueHint::Other)]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(long, default_value = "private", value_hint = clap::ValueHint::Other))]
     pub input_visibility: Visibility,
     /// Flags whether outputs are public, private, fixed, hashed, polycommit
-    #[arg(long, default_value = "public", value_hint = clap::ValueHint::Other)]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(long, default_value = "public", value_hint = clap::ValueHint::Other))]
     pub output_visibility: Visibility,
     /// Flags whether params are fixed, private, hashed, polycommit
-    #[arg(long, default_value = "private", value_hint = clap::ValueHint::Other)]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(long, default_value = "private", value_hint = clap::ValueHint::Other))]
     pub param_visibility: Visibility,
-    #[arg(long, default_value = "false")]
-    /// Rebase the scale using lookup table for division instead of using a range check
-    pub div_rebasing: bool,
+    #[cfg_attr(
+        all(feature = "ezkl", not(target_arch = "wasm32")),
+        arg(long, default_value = "false")
+    )]
     /// Should constants with 0.0 fraction be rebased to scale 0
-    #[arg(long, default_value = "false")]
+    #[cfg_attr(
+        all(feature = "ezkl", not(target_arch = "wasm32")),
+        arg(long, default_value = "false")
+    )]
     pub rebase_frac_zero_constants: bool,
     /// check mode (safe, unsafe, etc)
-    #[arg(long, default_value = "unsafe", value_hint = clap::ValueHint::Other)]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(long, default_value = "unsafe", value_hint = clap::ValueHint::Other))]
     pub check_mode: CheckMode,
     /// commitment scheme
-    #[arg(long, default_value = "kzg", value_hint = clap::ValueHint::Other)]
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(long, default_value = "kzg", value_hint = clap::ValueHint::Other))]
     pub commitment: Option<Commitments>,
+    /// the base used for decompositions
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(long, default_value = "16384", value_hint = clap::ValueHint::Other))]
+    pub decomp_base: usize,
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(long, default_value = "2", value_hint = clap::ValueHint::Other))]
+    /// the number of legs used for decompositions
+    pub decomp_legs: usize,
+    #[cfg_attr(
+        all(feature = "ezkl", not(target_arch = "wasm32")),
+        arg(long, default_value = "false")
+    )]
+    /// use unbounded lookup for the log
+    pub bounded_log_lookup: bool,
 }
 
 impl Default for RunArgs {
     fn default() -> Self {
         Self {
+            bounded_log_lookup: false,
             tolerance: Tolerance::default(),
             input_scale: 7,
             param_scale: 7,
@@ -291,10 +350,11 @@ impl Default for RunArgs {
             input_visibility: Visibility::Private,
             output_visibility: Visibility::Public,
             param_visibility: Visibility::Private,
-            div_rebasing: false,
             rebase_frac_zero_constants: false,
             check_mode: CheckMode::UNSAFE,
             commitment: None,
+            decomp_base: 16384,
+            decomp_legs: 2,
         }
     }
 }
@@ -343,6 +403,7 @@ impl RunArgs {
 }
 
 /// Parse a single key-value pair
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 fn parse_key_val<T, U>(
     s: &str,
 ) -> Result<(T, U), Box<dyn std::error::Error + Send + Sync + 'static>>