ci: update version string in docs

BREAKING CHANGE: may break w/ old compiled circuits

.github/workflows/engine.yml

@@ -1,4 +1,4 @@
-name: Build and Publish EZKL npm packages (wasm bindings and in-browser evm verifier)
+name: Build and Publish EZKL Engine npm package
 
 on:
   workflow_dispatch:
@@ -62,7 +62,7 @@ jobs:
               "web/ezkl_bg.wasm",
               "web/ezkl.js",
               "web/ezkl.d.ts",
-              "web/snippets/wasm-bindgen-rayon-7afa899f36665473/src/workerHelpers.js",
+              "web/snippets/**/*",
               "web/package.json",
               "web/utils.js",
               "ezkl.d.ts"
@@ -79,6 +79,10 @@ jobs:
         run: |
           sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" pkg/nodejs/ezkl.js
 
+      - name: Replace `import.meta.url` with `import.meta.resolve` definition in workerHelpers.js
+        run: |
+          find ./pkg/web/snippets -type f -name "*.js" -exec sed -i "s|import.meta.url|import.meta.resolve|" {} +
+
       - name: Add serialize and deserialize methods to nodejs bundle
         run: |
           echo '
@@ -174,40 +178,3 @@ jobs:
           npm publish
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-  in-browser-evm-ver-publish:
-    name: publish-in-browser-evm-verifier-package
-    needs: ["publish-wasm-bindings"]
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    steps:
-      - uses: actions/checkout@v4
-      - name: Update version in package.json
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          sed -i "s|\"version\": \".*\"|\"version\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
-      - name: Update @ezkljs/engine version in package.json
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          sed -i "s|\"@ezkljs/engine\": \".*\"|\"@ezkljs/engine\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
-      - name: Update the engine import in in-browser-evm-verifier to use @ezkljs/engine package instead of the local one;
-        run: |
-          sed -i "s|import { encodeVerifierCalldata } from '../nodejs/ezkl';|import { encodeVerifierCalldata } from '@ezkljs/engine';|" in-browser-evm-verifier/src/index.ts
-      - name: Set up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: "18.12.1"
-          registry-url: "https://registry.npmjs.org"
-      - name: Publish to npm
-        run: |
-          cd in-browser-evm-verifier
-          npm install
-          npm run build
-          npm ci
-          npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/pypi-gpu.yml

@@ -26,7 +26,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
-          python-version: 3.7
+          python-version: 3.12
           architecture: x64
 
       - name: Set pyproject.toml version to match github tag

.github/workflows/pypi.yml

@@ -25,7 +25,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
-          python-version: 3.7
+          python-version: 3.12
           architecture: x64
 
       - name: Set Cargo.toml version to match github tag
@@ -70,7 +70,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
-          python-version: 3.7
+          python-version: 3.12
           architecture: ${{ matrix.target }}
 
       - name: Set Cargo.toml version to match github tag
@@ -115,7 +115,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
-          python-version: 3.7
+          python-version: 3.12
           architecture: x64
 
       - name: Set Cargo.toml version to match github tag
@@ -128,6 +128,7 @@ jobs:
           mv Cargo.lock Cargo.lock.orig
           sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig >Cargo.lock
 
+
       - name: Install required libraries
         shell: bash
         run: |
@@ -176,7 +177,7 @@ jobs:
   #   - uses: actions/checkout@v4
   #   - uses: actions/setup-python@v4
   #     with:
-  #       python-version: 3.7
+  #       python-version: 3.12
 
   #   - name: Install cross-compilation tools for aarch64
   #     if: matrix.target == 'aarch64'
@@ -228,7 +229,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
-          python-version: 3.7
+          python-version: 3.12
           architecture: x64
 
       - name: Set Cargo.toml version to match github tag
@@ -263,7 +264,7 @@ jobs:
             apk add py3-pip
             pip3 install -U pip
             python3 -m venv .venv
-            source .venv/bin/activate            
+            source .venv/bin/activate
             pip3 install ezkl --no-index --find-links /io/dist/ --force-reinstall
             python3 -c "import ezkl"
 
@@ -287,7 +288,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
-          python-version: 3.7
+          python-version: 3.12
 
       - name: Set Cargo.toml version to match github tag
         shell: bash
@@ -359,3 +360,17 @@ jobs:
         with:
           repository-url: https://test.pypi.org/legacy/
           packages-dir: ./
+
+  doc-publish:
+    name: Trigger ReadTheDocs Build
+    runs-on: ubuntu-latest
+    needs: pypi-publish
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Trigger RTDs build
+        uses: dfm/rtds-action@v1
+        with:
+          webhook_url: ${{ secrets.RTDS_WEBHOOK_URL }}
+          webhook_token: ${{ secrets.RTDS_WEBHOOK_TOKEN }}
+          commit_ref: ${{ github.ref_name }}

.github/workflows/rust.yml

@@ -184,7 +184,7 @@ jobs:
 
   wasm32-tests:
     runs-on: ubuntu-latest
-    # needs: [build,  library-tests, docs]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
@@ -207,7 +207,7 @@ jobs:
 
   tutorial:
     runs-on: ubuntu-latest
-    needs: [build, library-tests, docs]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
@@ -224,7 +224,7 @@ jobs:
 
   mock-proving-tests:
     runs-on: non-gpu
-    # needs: [build,  library-tests, docs]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
@@ -281,7 +281,7 @@ jobs:
 
   prove-and-verify-evm-tests:
     runs-on: non-gpu
-    needs: [build, library-tests]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
@@ -307,8 +307,8 @@ jobs:
         run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
       - name: Install dependencies for js tests and in-browser-evm-verifier package
         run: |
-          pnpm install --no-frozen-lockfile
-          pnpm install --dir ./in-browser-evm-verifier --no-frozen-lockfile
+          pnpm install --frozen-lockfile
+          pnpm install --dir ./in-browser-evm-verifier --frozen-lockfile
         env:
           CI: false
           NODE_ENV: development
@@ -354,7 +354,7 @@ jobs:
 
   prove-and-verify-tests:
     runs-on: non-gpu
-    needs: [build, library-tests]
+    needs: [build, library-tests, docs]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
@@ -380,7 +380,7 @@ jobs:
           cache: "pnpm"
       - name: Install dependencies for js tests
         run: |
-          pnpm install --no-frozen-lockfile
+          pnpm install --frozen-lockfile
         env:
           CI: false
           NODE_ENV: development
@@ -394,14 +394,18 @@ jobs:
       - name: Replace memory definition in nodejs
         run: |
           sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" tests/wasm/nodejs/ezkl.js
+      - name: KZG prove and verify tests (public outputs + column overflow)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w
+      - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_
+      - name: KZG prove and verify tests (hashed inputs + column overflow)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_hashed_inputs_
       - name: KZG prove and verify tests (public outputs)
         run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_tight_lookup_::t
       - name: IPA prove and verify tests
         run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_::t --test-threads 1
       - name: IPA prove and verify tests (ipa outputs)
         run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_ipa_output
-      - name: KZG prove and verify tests (public outputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w
       - name: KZG prove and verify tests single inner col
         run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_single_col
       - name: KZG prove and verify tests triple inner col
@@ -412,8 +416,6 @@ jobs:
         run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_octuple_col --test-threads 8
       - name: KZG prove and verify tests (kzg outputs)
         run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output
-      - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_
       - name: KZG prove and verify tests (public outputs)
         run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t
       - name: KZG prove and verify tests (public inputs)
@@ -460,7 +462,7 @@ jobs:
 
   prove-and-verify-mock-aggr-tests:
     runs-on: self-hosted
-    needs: [build, library-tests]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
@@ -495,7 +497,7 @@ jobs:
 
   prove-and-verify-aggr-tests:
     runs-on: large-self-hosted
-    needs: [build, library-tests]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
@@ -512,7 +514,7 @@ jobs:
 
   prove-and-verify-aggr-evm-tests:
     runs-on: large-self-hosted
-    needs: [build, library-tests]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
@@ -545,8 +547,6 @@ jobs:
         with:
           crate: cargo-nextest
           locked: true
-      - name: Download MNIST
-        run: sh data.sh
       - name: Examples
         run: cargo nextest run --release tests_examples
 
@@ -557,16 +557,18 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
-          python-version: "3.7"
+          python-version: "3.12"
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2024-02-06
           override: true
           components: rustfmt, clippy
+      - name: Install cmake
+        run: sudo apt-get install -y cmake
       - name: Install solc
         run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
       - name: Setup Virtual Env and Install python dependencies
-        run: python -m venv .env; source .env/bin/activate; pip install -r requirements.txt;
+        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
       - name: Build python ezkl
@@ -576,12 +578,12 @@ jobs:
 
   accuracy-measurement-tests:
     runs-on: ubuntu-latest-32-cores
-    # needs: [build, library-tests, docs]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
-          python-version: "3.7"
+          python-version: "3.12"
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2024-02-06
@@ -592,7 +594,7 @@ jobs:
           crate: cargo-nextest
           locked: true
       - name: Setup Virtual Env and Install python dependencies
-        run: python -m venv .env; source .env/bin/activate; pip install -r requirements.txt;
+        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
@@ -608,11 +610,29 @@ jobs:
 
   python-integration-tests:
     runs-on: large-self-hosted
+    services:
+      # Label used to access the service container
+      postgres:
+        # Docker Hub image
+        image: postgres
+        env:
+          POSTGRES_USER: ubuntu
+          POSTGRES_HOST_AUTH_METHOD: trust
+        # Set health checks to wait until postgres has started
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+          -v /var/run/postgresql:/var/run/postgresql
+        ports:
+          # Maps tcp port 5432 on service container to the host
+          - 5432:5432
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
-          python-version: "3.10"
+          python-version: "3.11"
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2024-02-06
@@ -626,10 +646,16 @@ jobs:
         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: Install pip
+        run: python -m ensurepip --upgrade
       - name: Setup Virtual Env and Install python dependencies
-        run: python -m venv .env; source .env/bin/activate; pip install -r requirements.txt;
+        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: Postgres tutorials
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::postgres_ --no-capture
+      - name: Tictactoe tutorials
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_ --test-threads 1
       # - name: authenticate-kaggle-cli
       #   shell: bash
       #   env:
@@ -645,7 +671,3 @@ 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: Tictactoe tutorials
-        run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_
-      # - name: Postgres tutorials
-      #   run: source .env/bin/activate; cargo nextest run py_tests::tests::postgres_ --test-threads 1

.github/workflows/tagging.yml

@@ -14,6 +14,40 @@ jobs:
       - uses: actions/checkout@v4
       - name: Bump version and push tag
         id: tag_version
-        uses: mathieudutour/github-tag-action@v6.1
+        uses: mathieudutour/github-tag-action@v6.2
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set Cargo.toml version to match github tag for docs
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ steps.tag_version.outputs.new_tag }}
+        run: |
+          mv docs/python/src/conf.py docs/python/src/conf.py.orig
+          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" docs/python/src/conf.py.orig >docs/python/src/conf.py
+          rm docs/python/src/conf.py.orig
+          mv docs/python/requirements-docs.txt docs/python/requirements-docs.txt.orig
+          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" docs/python/requirements-docs.txt.orig >docs/python/requirements-docs.txt
+          rm docs/python/requirements-docs.txt.orig
+
+      - name: Commit files and create tag
+        env:
+          RELEASE_TAG: ${{ steps.tag_version.outputs.new_tag }}
+        run: |
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git fetch --tags
+          git checkout -b release-$RELEASE_TAG
+          git add .
+          git commit -m "ci: update version string in docs"
+          git tag -d $RELEASE_TAG
+          git tag $RELEASE_TAG
+
+      - name: Push changes
+        uses: ad-m/github-push-action@master
+        env:
+          RELEASE_TAG: ${{ steps.tag_version.outputs.new_tag }}
+        with:
+          branch: release-${{ steps.tag_version.outputs.new_tag }}
+          force: true
+          tags: true

.github/workflows/verify.yml

@@ -0,0 +1,65 @@
+name: Build and Publish EZKL npm packages (wasm bindings and in-browser evm verifier)
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "The tag to release"
+        required: true
+  push:
+    tags:
+      - "*"
+
+defaults:
+  run:
+    working-directory: .
+jobs:
+  in-browser-evm-ver-publish:
+    name: publish-in-browser-evm-verifier-package
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - uses: actions/checkout@v4
+      - name: Update version in package.json
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          sed -i "s|\"version\": \".*\"|\"version\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
+      - name: Update @ezkljs/engine version in package.json
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          sed -i "s|\"@ezkljs/engine\": \".*\"|\"@ezkljs/engine\": \"${{ github.ref_name#v }}\"|" in-browser-evm-verifier/package.json
+      - name: Update the engine import in in-browser-evm-verifier to use @ezkljs/engine package instead of the local one;
+        run: |
+          sed -i "s|import { encodeVerifierCalldata } from '../nodejs/ezkl';|import { encodeVerifierCalldata } from '@ezkljs/engine';|" in-browser-evm-verifier/src/index.ts
+      - name: Fetch integrity
+        run: |
+          ENGINE_INTEGRITY=$(npm view @ezkljs/engine@${{ github.ref_name#v }} dist.integrity)
+          echo "ENGINE_INTEGRITY=$ENGINE_INTEGRITY" >> $GITHUB_ENV
+      - name: Update pnpm-lock.yaml versions and integrity
+        run: |
+          awk -v integrity="$ENGINE_INTEGRITY" -v tag="${{ github.ref_name#v }}" '
+          NR==30{$0="    specifier: \"" tag "\""}
+          NR==31{$0="    version: \"" tag "\""}
+          NR==400{$0="  /@ezkljs/engine@" tag ":"}
+          NR==401{$0="    resolution: {integrity: \"" integrity "\"}"} 1' in-browser-evm-verifier/pnpm-lock.yaml > temp.yaml && mv temp.yaml in-browser-evm-verifier/pnpm-lock.yaml  
+      - name: Use pnpm 8
+        uses: pnpm/action-setup@v2
+        with:
+          version: 8
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "18.12.1"
+          registry-url: "https://registry.npmjs.org"
+      - name: Publish to npm
+        run: |
+          cd in-browser-evm-verifier
+          pnpm install --frozen-lockfile
+          pnpm run build
+          pnpm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.gitignore

@@ -1,6 +1,5 @@
 target
 pkg
-data
 *.csv
 !examples/notebooks/eth_price.csv
 *.ipynb_checkpoints
@@ -48,4 +47,6 @@ node_modules
 /dist
 timingData.json
 !tests/wasm/pk.key
-!tests/wasm/vk.key
+!tests/wasm/vk.key
+docs/python/build
+!tests/wasm/vk_aggr.key

.python-version

@@ -0,0 +1 @@
+3.12.1

.readthedocs.yaml

@@ -0,0 +1,26 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.12"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: ./docs/python/src/conf.py
+
+# Optionally build your docs in additional formats such as PDF and ePub
+# formats:
+#    - pdf
+#    - epub
+
+# Optional but recommended, declare the Python requirements required
+# to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+python:
+  install:
+  - requirements: ./docs/python/requirements-docs.txt

Cargo.lock

@@ -655,6 +655,12 @@ dependencies = [
  "constant_time_eq",
 ]
 
+[[package]]
+name = "block"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"
+
 [[package]]
 name = "block-buffer"
 version = "0.9.0"
@@ -1011,6 +1017,17 @@ version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
 
+[[package]]
+name = "core-graphics-types"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation",
+ "libc",
+]
+
 [[package]]
 name = "cpufeatures"
 version = "0.2.12"
@@ -1307,6 +1324,12 @@ version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
 
+[[package]]
+name = "dyn-hash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a650a461c6a8ff1ef205ed9a2ad56579309853fecefc2423f73dced342f92258"
+
 [[package]]
 name = "ecc"
 version = "0.1.0"
@@ -1793,8 +1816,10 @@ dependencies = [
  "lazy_static",
  "log",
  "maybe-rayon",
+ "metal",
  "mnist",
  "num",
+ "objc",
  "openssl",
  "pg_bigdecimal",
  "plotters",
@@ -1932,7 +1957,28 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
 dependencies = [
- "foreign-types-shared",
+ "foreign-types-shared 0.1.1",
+]
+
+[[package]]
+name = "foreign-types"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
+dependencies = [
+ "foreign-types-macros",
+ "foreign-types-shared 0.3.1",
+]
+
+[[package]]
+name = "foreign-types-macros"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.53",
 ]
 
 [[package]]
@@ -1941,6 +1987,12 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
 
+[[package]]
+name = "foreign-types-shared"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
+
 [[package]]
 name = "form_urlencoded"
 version = "1.2.1"
@@ -2224,7 +2276,7 @@ dependencies = [
 [[package]]
 name = "halo2_solidity_verifier"
 version = "0.1.0"
-source = "git+https://github.com/alexander-camuto/halo2-solidity-verifier?branch=main#eb04be1f7d005e5b9dd3ff41efa30aeb5e0c34a3"
+source = "git+https://github.com/alexander-camuto/halo2-solidity-verifier?branch=main#fd74f1da2ce51664e2d4349965987ee606551060"
 dependencies = [
  "askama",
  "blake2b_simd",
@@ -2699,6 +2751,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.10"
@@ -2924,6 +2985,15 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "malloc_buf"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "maplit"
 version = "1.0.2"
@@ -2968,9 +3038,9 @@ checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
 
 [[package]]
 name = "memmap2"
-version = "0.5.10"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
+checksum = "fe751422e4a8caa417e13c3ea66452215d7d63e19e604f4980461212f3ae1322"
 dependencies = [
  "libc",
 ]
@@ -2984,6 +3054,20 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "metal"
+version = "0.27.0"
+source = "git+https://github.com/gfx-rs/metal-rs#ff8fd3d6dc7792852f8a015458d7e6d42d7fb352"
+dependencies = [
+ "bitflags 2.5.0",
+ "block",
+ "core-graphics-types",
+ "foreign-types 0.5.0",
+ "log",
+ "objc",
+ "paste",
+]
+
 [[package]]
 name = "mime"
 version = "0.3.17"
@@ -3196,6 +3280,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
 
+[[package]]
+name = "objc"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"
+dependencies = [
+ "malloc_buf",
+]
+
 [[package]]
 name = "object"
 version = "0.32.2"
@@ -3256,7 +3349,7 @@ checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f"
 dependencies = [
  "bitflags 2.5.0",
  "cfg-if",
- "foreign-types",
+ "foreign-types 0.3.2",
  "libc",
  "once_cell",
  "openssl-macros",
@@ -4601,9 +4694,9 @@ dependencies = [
 
 [[package]]
 name = "serde-wasm-bindgen"
-version = "0.4.5"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b4c031cd0d9014307d82b8abf653c0290fbdaeb4c02d00c63cf52f728628bf"
+checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b"
 dependencies = [
  "js-sys",
  "serde",
@@ -4845,12 +4938,12 @@ checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
 
 [[package]]
 name = "string-interner"
-version = "0.14.0"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91e2531d8525b29b514d25e275a43581320d587b86db302b9a7e464bac579648"
+checksum = "07f9fdfdd31a0ff38b59deb401be81b73913d76c9cc5b1aed4e1330a223420b9"
 dependencies = [
  "cfg-if",
- "hashbrown 0.11.2",
+ "hashbrown 0.14.3",
  "serde",
 ]
 
@@ -5389,8 +5482,8 @@ dependencies = [
 
 [[package]]
 name = "tract-core"
-version = "0.20.23-pre"
-source = "git+https://github.com/sonos/tract/?rev=7b1aa33b2f7d1f19b80e270c83320f0f94daff69#7b1aa33b2f7d1f19b80e270c83320f0f94daff69"
+version = "0.21.5-pre"
+source = "git+https://github.com/sonos/tract/?rev=05ebf550aa9922b221af4635c21a67a8d2af12a9#05ebf550aa9922b221af4635c21a67a8d2af12a9"
 dependencies = [
  "anyhow",
  "bit-set",
@@ -5413,12 +5506,14 @@ dependencies = [
 
 [[package]]
 name = "tract-data"
-version = "0.20.23-pre"
-source = "git+https://github.com/sonos/tract/?rev=7b1aa33b2f7d1f19b80e270c83320f0f94daff69#7b1aa33b2f7d1f19b80e270c83320f0f94daff69"
+version = "0.21.5-pre"
+source = "git+https://github.com/sonos/tract/?rev=05ebf550aa9922b221af4635c21a67a8d2af12a9#05ebf550aa9922b221af4635c21a67a8d2af12a9"
 dependencies = [
  "anyhow",
+ "downcast-rs",
+ "dyn-hash",
  "half 2.2.1",
- "itertools 0.10.5",
+ "itertools 0.12.1",
  "lazy_static",
  "maplit",
  "ndarray",
@@ -5432,8 +5527,8 @@ dependencies = [
 
 [[package]]
 name = "tract-hir"
-version = "0.20.23-pre"
-source = "git+https://github.com/sonos/tract/?rev=7b1aa33b2f7d1f19b80e270c83320f0f94daff69#7b1aa33b2f7d1f19b80e270c83320f0f94daff69"
+version = "0.21.5-pre"
+source = "git+https://github.com/sonos/tract/?rev=05ebf550aa9922b221af4635c21a67a8d2af12a9#05ebf550aa9922b221af4635c21a67a8d2af12a9"
 dependencies = [
  "derive-new",
  "log",
@@ -5442,13 +5537,14 @@ dependencies = [
 
 [[package]]
 name = "tract-linalg"
-version = "0.20.23-pre"
-source = "git+https://github.com/sonos/tract/?rev=7b1aa33b2f7d1f19b80e270c83320f0f94daff69#7b1aa33b2f7d1f19b80e270c83320f0f94daff69"
+version = "0.21.5-pre"
+source = "git+https://github.com/sonos/tract/?rev=05ebf550aa9922b221af4635c21a67a8d2af12a9#05ebf550aa9922b221af4635c21a67a8d2af12a9"
 dependencies = [
  "cc",
  "derive-new",
  "downcast-rs",
  "dyn-clone",
+ "dyn-hash",
  "half 2.2.1",
  "lazy_static",
  "liquid",
@@ -5466,8 +5562,8 @@ dependencies = [
 
 [[package]]
 name = "tract-nnef"
-version = "0.20.23-pre"
-source = "git+https://github.com/sonos/tract/?rev=7b1aa33b2f7d1f19b80e270c83320f0f94daff69#7b1aa33b2f7d1f19b80e270c83320f0f94daff69"
+version = "0.21.5-pre"
+source = "git+https://github.com/sonos/tract/?rev=05ebf550aa9922b221af4635c21a67a8d2af12a9#05ebf550aa9922b221af4635c21a67a8d2af12a9"
 dependencies = [
  "byteorder",
  "flate2",
@@ -5480,8 +5576,8 @@ dependencies = [
 
 [[package]]
 name = "tract-onnx"
-version = "0.20.23-pre"
-source = "git+https://github.com/sonos/tract/?rev=7b1aa33b2f7d1f19b80e270c83320f0f94daff69#7b1aa33b2f7d1f19b80e270c83320f0f94daff69"
+version = "0.21.5-pre"
+source = "git+https://github.com/sonos/tract/?rev=05ebf550aa9922b221af4635c21a67a8d2af12a9#05ebf550aa9922b221af4635c21a67a8d2af12a9"
 dependencies = [
  "bytes",
  "derive-new",
@@ -5497,8 +5593,8 @@ dependencies = [
 
 [[package]]
 name = "tract-onnx-opl"
-version = "0.20.23-pre"
-source = "git+https://github.com/sonos/tract/?rev=7b1aa33b2f7d1f19b80e270c83320f0f94daff69#7b1aa33b2f7d1f19b80e270c83320f0f94daff69"
+version = "0.21.5-pre"
+source = "git+https://github.com/sonos/tract/?rev=05ebf550aa9922b221af4635c21a67a8d2af12a9#05ebf550aa9922b221af4635c21a67a8d2af12a9"
 dependencies = [
  "getrandom",
  "log",

Cargo.toml

@@ -43,6 +43,7 @@ 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 }
 
 
 # evm related deps
@@ -80,9 +81,11 @@ pyo3-asyncio = { version = "0.20.0", features = [
     "tokio-runtime",
 ], default_features = false, optional = true }
 pyo3-log = { version = "0.9.0", default_features = false, optional = true }
-tract-onnx = { git = "https://github.com/sonos/tract/", rev = "7b1aa33b2f7d1f19b80e270c83320f0f94daff69", default_features = false, optional = true }
+tract-onnx = { git = "https://github.com/sonos/tract/", rev = "05ebf550aa9922b221af4635c21a67a8d2af12a9", default_features = false, optional = true }
 tabled = { version = "0.12.0", optional = true }
 
+objc = { version = "0.2.4", optional = true }
+
 
 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
 colored = { version = "2.0.0", default_features = false, optional = true }
@@ -95,10 +98,10 @@ getrandom = { version = "0.2.8", features = ["js"] }
 instant = { version = "0.1", features = ["wasm-bindgen", "inaccurate"] }
 
 [target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
-wasm-bindgen-rayon = { version = "1.0", optional = true }
-wasm-bindgen-test = "0.3.34"
-serde-wasm-bindgen = "0.4"
-wasm-bindgen = { version = "0.2.81", features = ["serde-serialize"] }
+wasm-bindgen-rayon = { version = "1.2.1", optional = true }
+wasm-bindgen-test = "0.3.42"
+serde-wasm-bindgen = "0.6.5"
+wasm-bindgen = { version = "0.2.92", features = ["serde-serialize"] }
 console_error_panic_hook = "0.1.7"
 wasm-bindgen-console-logger = "0.1.1"
 
@@ -198,6 +201,7 @@ det-prove = []
 icicle = ["halo2_proofs/icicle_gpu"]
 empty-cmd = []
 no-banner = []
+metal = ["dep:metal", "dep:objc"]
 
 # icicle patch to 0.1.0 if feature icicle is enabled
 [patch.'https://github.com/ingonyama-zk/icicle']

abis/QuantizeData.json

@@ -20,9 +20,9 @@
 		"name": "quantize_data",
 		"outputs": [
 			{
-				"internalType": "int128[]",
+				"internalType": "int64[]",
 				"name": "quantized_data",
-				"type": "int128[]"
+				"type": "int64[]"
 			}
 		],
 		"stateMutability": "pure",
@@ -31,9 +31,9 @@
 	{
 		"inputs": [
 			{
-				"internalType": "int128[]",
+				"internalType": "int64[]",
 				"name": "quantized_data",
-				"type": "int128[]"
+				"type": "int64[]"
 			}
 		],
 		"name": "to_field_element",

benches/accum_conv.rs

@@ -70,8 +70,8 @@ impl Circuit<Fr> for MyCircuit {
                         &mut region,
                         &[self.image.clone(), self.kernel.clone(), self.bias.clone()],
                         Box::new(PolyOp::Conv {
-                            padding: [(0, 0); 2],
-                            stride: (1, 1),
+                            padding: vec![(0, 0)],
+                            stride: vec![1; 2],
                         }),
                     )
                     .unwrap();

benches/accum_sumpool.rs

@@ -65,9 +65,9 @@ impl Circuit<Fr> for MyCircuit {
                         &mut region,
                         &[self.image.clone()],
                         Box::new(HybridOp::SumPool {
-                            padding: [(0, 0); 2],
-                            stride: (1, 1),
-                            kernel_shape: (2, 2),
+                            padding: vec![(0, 0); 2],
+                            stride: vec![1, 1],
+                            kernel_shape: vec![2, 2],
                             normalized: false,
                         }),
                     )

contracts/QuantizeData.sol

@@ -125,7 +125,7 @@ contract QuantizeData {
     }
 
     function to_field_element(
-        int128[] memory quantized_data
+        int64[] memory quantized_data
     ) public pure returns (uint256[] memory output) {
         output = new uint256[](quantized_data.length);
         for (uint i; i < quantized_data.length; i++) {

data.sh

@@ -1,11 +0,0 @@
-#! /bin/bash
-
-mkdir data
-cd data
-
-wget http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
-wget http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
-wget http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
-wget http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
-
-gzip -d *.gz

docs/python/build.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+sphinx-build ./src build

docs/python/requirements-docs.txt

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

docs/python/src/conf.py

@@ -0,0 +1,29 @@
+import ezkl
+
+project = 'ezkl'
+release = '11.0.6'
+version = release
+
+
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.autosummary',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.todo',
+    'sphinx.ext.inheritance_diagram',
+    'sphinx.ext.autosectionlabel',
+    'sphinx.ext.napoleon',
+    'sphinx_rtd_theme',
+]
+
+autosummary_generate = True
+autosummary_imported_members = True
+
+templates_path = ['_templates']
+exclude_patterns = []
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = 'sphinx_rtd_theme'
+html_static_path = ['_static']

docs/python/src/index.rst

@@ -0,0 +1,11 @@
+.. extension documentation master file, created by
+   sphinx-quickstart on Mon Jun 19 15:02:05 2023.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+ezkl python bindings
+================================================
+
+.. automodule:: ezkl
+   :members:
+   :undoc-members:

examples/conv2d_mnist/main.rs

@@ -42,8 +42,8 @@ const NUM_INNER_COLS: usize = 1;
 struct Config<
     const LEN: usize, //LEN = CHOUT x OH x OW flattened //not supported yet in rust stable
     const CLASSES: usize,
-    const LOOKUP_MIN: i128,
-    const LOOKUP_MAX: i128,
+    const LOOKUP_MIN: i64,
+    const LOOKUP_MAX: i64,
     // Convolution
     const KERNEL_HEIGHT: usize,
     const KERNEL_WIDTH: usize,
@@ -66,8 +66,8 @@ struct Config<
 struct MyCircuit<
     const LEN: usize, //LEN = CHOUT x OH x OW flattened
     const CLASSES: usize,
-    const LOOKUP_MIN: i128,
-    const LOOKUP_MAX: i128,
+    const LOOKUP_MIN: i64,
+    const LOOKUP_MAX: i64,
     // Convolution
     const KERNEL_HEIGHT: usize,
     const KERNEL_WIDTH: usize,
@@ -90,8 +90,8 @@ struct MyCircuit<
 impl<
         const LEN: usize,
         const CLASSES: usize,
-        const LOOKUP_MIN: i128,
-        const LOOKUP_MAX: i128,
+        const LOOKUP_MIN: i64,
+        const LOOKUP_MAX: i64,
         // Convolution
         const KERNEL_HEIGHT: usize,
         const KERNEL_WIDTH: usize,
@@ -203,8 +203,8 @@ where
                     let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS);
 
                     let op = PolyOp::Conv {
-                        padding: [(PADDING, PADDING); 2],
-                        stride: (STRIDE, STRIDE),
+                        padding: vec![(PADDING, PADDING); 2],
+                        stride: vec![STRIDE; 2],
                     };
                     let x = config
                         .layer_config
@@ -308,6 +308,7 @@ pub fn runconv() {
         tst_lbl: _,
         ..
     } = MnistBuilder::new()
+        .base_path("examples/data")
         .label_format_digit()
         .training_set_length(50_000)
         .validation_set_length(10_000)

examples/mlp_4d_einsum.rs

@@ -23,8 +23,8 @@ struct MyConfig {
 #[derive(Clone)]
 struct MyCircuit<
     const LEN: usize, //LEN = CHOUT x OH x OW flattened
-    const LOOKUP_MIN: i128,
-    const LOOKUP_MAX: i128,
+    const LOOKUP_MIN: i64,
+    const LOOKUP_MAX: i64,
 > {
     // 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: i128, const LOOKUP_MAX: i128> Circuit<F>
+impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
     for MyCircuit<LEN, LOOKUP_MIN, LOOKUP_MAX>
 {
     type Config = MyConfig;

examples/notebooks/keras_simple_demo.ipynb

@@ -67,6 +67,7 @@
                 "model.add(Dense(128, activation='relu'))\n",
                 "model.add(Dropout(0.5))\n",
                 "model.add(Dense(10, activation='softmax'))\n",
+                "model.output_names=['output']\n",
                 "\n",
                 "\n",
                 "# Train the model as you like here (skipped for brevity)\n",

examples/notebooks/logistic_regression.ipynb

@@ -0,0 +1,279 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
+            "metadata": {},
+            "source": [
+                "## Logistic Regression\n",
+                "\n",
+                "\n",
+                "Sklearn based models are slightly finicky to get into a suitable onnx format. \n",
+                "This notebook showcases how to do so using the `hummingbird-ml` python package for a Logistic Regression model. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "95613ee9",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# check if notebook is in colab\n",
+                "try:\n",
+                "    # install ezkl\n",
+                "    import google.colab\n",
+                "    import subprocess\n",
+                "    import sys\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"hummingbird-ml\"])\n",
+                "\n",
+                "# rely on local installation of ezkl if the notebook is not in colab\n",
+                "except:\n",
+                "    pass\n",
+                "\n",
+                "import os\n",
+                "import torch\n",
+                "import ezkl\n",
+                "import json\n",
+                "from hummingbird.ml import convert\n",
+                "\n",
+                "\n",
+                "# here we create and (potentially train a model)\n",
+                "\n",
+                "# make sure you have the dependencies required here already installed\n",
+                "import numpy as np\n",
+                "from sklearn.linear_model import LogisticRegression\n",
+                "X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])\n",
+                "# y = 1 * x_0 + 2 * x_1 + 3\n",
+                "y = np.dot(X, np.array([1, 2])) + 3\n",
+                "reg = LogisticRegression().fit(X, y)\n",
+                "reg.score(X, y)\n",
+                "\n",
+                "circuit = convert(reg, \"torch\", X[:1]).model\n",
+                "\n",
+                "\n",
+                "\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "b37637c4",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "model_path = os.path.join('network.onnx')\n",
+                "compiled_model_path = os.path.join('network.compiled')\n",
+                "pk_path = os.path.join('test.pk')\n",
+                "vk_path = os.path.join('test.vk')\n",
+                "settings_path = os.path.join('settings.json')\n",
+                "\n",
+                "witness_path = os.path.join('witness.json')\n",
+                "data_path = os.path.join('input.json')"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "82db373a",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "\n",
+                "\n",
+                "# export to onnx format\n",
+                "# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
+                "\n",
+                "# Input to the model\n",
+                "shape = X.shape[1:]\n",
+                "x = torch.rand(1, *shape, requires_grad=True)\n",
+                "torch_out = circuit(x)\n",
+                "# Export the model\n",
+                "torch.onnx.export(circuit,               # model being run\n",
+                "                  # model input (or a tuple for multiple inputs)\n",
+                "                  x,\n",
+                "                  # where to save the model (can be a file or file-like object)\n",
+                "                  \"network.onnx\",\n",
+                "                  export_params=True,        # store the trained parameter weights inside the model file\n",
+                "                  opset_version=10,          # the ONNX version to export the model to\n",
+                "                  do_constant_folding=True,  # whether to execute constant folding for optimization\n",
+                "                  input_names=['input'],   # the model's input names\n",
+                "                  output_names=['output'],  # the model's output names\n",
+                "                  dynamic_axes={'input': {0: 'batch_size'},    # variable length axes\n",
+                "                                'output': {0: 'batch_size'}})\n",
+                "\n",
+                "d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
+                "\n",
+                "data = dict(input_shapes=[shape],\n",
+                "            input_data=[d],\n",
+                "            output_data=[((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])\n",
+                "\n",
+                "# Serialize data into file:\n",
+                "json.dump(data, open(\"input.json\", 'w'))\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "d5e374a2",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "!RUST_LOG=trace\n",
+                "# TODO: Dictionary outputs\n",
+                "res = ezkl.gen_settings(model_path, settings_path)\n",
+                "assert res == True\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "cal_path = os.path.join(\"calibration.json\")\n",
+                "\n",
+                "data_array = (torch.randn(20, *shape).detach().numpy()).reshape([-1]).tolist()\n",
+                "\n",
+                "data = dict(input_data = [data_array])\n",
+                "\n",
+                "# Serialize data into file:\n",
+                "json.dump(data, open(cal_path, 'w'))\n",
+                "\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "assert res == True\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "3aa4f090",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
+                "assert res == True"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "8b74dcee",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# srs path\n",
+                "res = ezkl.get_srs( settings_path)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "18c8b7c7",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# now generate the witness file \n",
+                "\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "assert os.path.isfile(witness_path)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "b1c561a8",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "\n",
+                "# HERE WE SETUP THE CIRCUIT PARAMS\n",
+                "# WE GOT KEYS\n",
+                "# WE GOT CIRCUIT PARAMETERS\n",
+                "# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
+                "\n",
+                "\n",
+                "\n",
+                "res = ezkl.setup(\n",
+                "        compiled_model_path,\n",
+                "        vk_path,\n",
+                "        pk_path,\n",
+                "        \n",
+                "    )\n",
+                "\n",
+                "assert res == True\n",
+                "assert os.path.isfile(vk_path)\n",
+                "assert os.path.isfile(pk_path)\n",
+                "assert os.path.isfile(settings_path)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "c384cbc8",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# GENERATE A PROOF\n",
+                "\n",
+                "\n",
+                "proof_path = os.path.join('test.pf')\n",
+                "\n",
+                "res = ezkl.prove(\n",
+                "        witness_path,\n",
+                "        compiled_model_path,\n",
+                "        pk_path,\n",
+                "        proof_path,\n",
+                "        \n",
+                "        \"single\",\n",
+                "    )\n",
+                "\n",
+                "print(res)\n",
+                "assert os.path.isfile(proof_path)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "76f00d41",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# VERIFY IT\n",
+                "\n",
+                "res = ezkl.verify(\n",
+                "        proof_path,\n",
+                "        settings_path,\n",
+                "        vk_path,\n",
+                "        \n",
+                "    )\n",
+                "\n",
+                "assert res == True\n",
+                "print(\"verified\")"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "Python 3 (ipykernel)",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.12.2"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}

examples/notebooks/mean_postgres.ipynb

@@ -7,9 +7,9 @@
         "## Mean of ERC20 transfer amounts\n",
         "\n",
         "This notebook shows how to calculate the mean of ERC20 transfer amounts, pulling data in from a Postgres database. First we install and get the necessary libraries running. \n",
-        "The first of which is [e2pg](https://github.com/indexsupply/x/tree/main/docs/e2pg), which is a library that allows us to pull data from the Ethereum blockchain into a Postgres database.\n",
+        "The first of which is [shovel](https://indexsupply.com/shovel/docs/#getting-started), which is a library that allows us to pull data from the Ethereum blockchain into a Postgres database.\n",
         "\n",
-        "Make sure you install postgres if needed https://postgresapp.com/. \n",
+        "Make sure you install postgres if needed https://indexsupply.com/shovel/docs/#getting-started. \n",
         "\n"
       ]
     },
@@ -21,23 +21,81 @@
       "source": [
         "import os\n",
         "import getpass\n",
-        "\n",
+        "import json\n",
+        "import time\n",
+        "import subprocess\n",
         "\n",
         "# swap out for the relevant linux/amd64, darwin/arm64, darwin/amd64, windows/amd64\n",
-        "os.system(\"curl -LO https://indexsupply.net/bin/main/linux/amd64/e2pg\")\n",
-        "os.system(\"chmod +x e2pg\")\n",
+        "os.system(\"curl -LO https://indexsupply.net/bin/1.0/linux/amd64/shovel\")\n",
+        "os.system(\"chmod +x shovel\")\n",
         "\n",
         "\n",
-        "os.environ[\"PG_URL\"] = \"postgresql://\" + getpass.getuser() + \":@localhost:5432/e2pg\"\n",
-        "os.environ[\"RLPS_URL\"] = \"https://1.rlps.indexsupply.net\"\n",
+        "os.environ[\"PG_URL\"] = \"postgres://\" + getpass.getuser() + \":@localhost:5432/shovel\"\n",
+        "\n",
+        "# create a config.json file with the following contents\n",
+        "config = {\n",
+        "  \"pg_url\": \"$PG_URL\",\n",
+        "  \"eth_sources\": [\n",
+        "    {\"name\": \"mainnet\", \"chain_id\": 1, \"url\": \"https://ethereum-rpc.publicnode.com\"},\n",
+        "    {\"name\": \"base\", \"chain_id\": 8453, \"url\": \"https://base-rpc.publicnode.com\"}\n",
+        "  ],\n",
+        "  \"integrations\": [{\n",
+        "    \"name\": \"usdc_transfer\",\n",
+        "    \"enabled\": True,\n",
+        "    \"sources\": [{\"name\": \"mainnet\"}, {\"name\": \"base\"}],\n",
+        "    \"table\": {\n",
+        "      \"name\": \"usdc\",\n",
+        "      \"columns\": [\n",
+        "        {\"name\": \"log_addr\",  \"type\": \"bytea\"},\n",
+        "        {\"name\": \"block_num\", \"type\": \"numeric\"},\n",
+        "        {\"name\": \"f\",         \"type\": \"bytea\"},\n",
+        "        {\"name\": \"t\",         \"type\": \"bytea\"},\n",
+        "        {\"name\": \"v\",         \"type\": \"numeric\"}\n",
+        "      ]\n",
+        "    },\n",
+        "    \"block\": [\n",
+        "      {\"name\": \"block_num\", \"column\": \"block_num\"},\n",
+        "      {\n",
+        "        \"name\": \"log_addr\",\n",
+        "        \"column\": \"log_addr\",\n",
+        "        \"filter_op\": \"contains\",\n",
+        "        \"filter_arg\": [\n",
+        "          \"a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48\",\n",
+        "          \"833589fCD6eDb6E08f4c7C32D4f71b54bdA02913\"\n",
+        "        ]\n",
+        "      }\n",
+        "    ],\n",
+        "    \"event\": {\n",
+        "      \"name\": \"Transfer\",\n",
+        "      \"type\": \"event\",\n",
+        "      \"anonymous\": False,\n",
+        "      \"inputs\": [\n",
+        "        {\"indexed\": True,  \"name\": \"from\",  \"type\": \"address\", \"column\": \"f\"},\n",
+        "        {\"indexed\": True,  \"name\": \"to\",    \"type\": \"address\", \"column\": \"t\"},\n",
+        "        {\"indexed\": False, \"name\": \"value\", \"type\": \"uint256\", \"column\": \"v\"}\n",
+        "      ]\n",
+        "    }\n",
+        "  }]\n",
+        "}\n",
+        "\n",
+        "# write the config to a file\n",
+        "with open(\"config.json\", \"w\") as f:\n",
+        "  f.write(json.dumps(config))\n",
+        "\n",
         "\n",
         "# print the two env variables\n",
         "os.system(\"echo $PG_URL\")\n",
-        "os.system(\"echo $RLPS_URL\")\n",
         "\n",
-        "os.system(\"createdb -h localhost -p 5432 e2pg\")\n",
-        "# equivalent of nohup ./e2pg -reset -e $RLPS_URL -pg $PG_URL &\n",
-        "e2pg_process = os.system(\"nohup ./e2pg -e $RLPS_URL -pg $PG_URL &\")\n",
+        "os.system(\"createdb -h localhost -p 5432 shovel\")\n",
+        "\n",
+        "os.system(\"echo shovel is now installed. starting:\")\n",
+        "\n",
+        "command = [\"./shovel\", \"-config\", \"config.json\"]\n",
+        "subprocess.Popen(command)\n",
+        "\n",
+        "os.system(\"echo shovel started.\")\n",
+        "\n",
+        "time.sleep(5)\n",
         "\n"
       ]
     },
@@ -79,11 +137,13 @@
         "import json\n",
         "import os\n",
         "\n",
-        "# import logging\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)"
+        "import logging\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",
+        "\n",
+        "print(\"ezkl version: \", ezkl.__version__)"
       ]
     },
     {
@@ -176,6 +236,7 @@
       },
       "outputs": [],
       "source": [
+        "import getpass\n",
         "# make an input.json file from the df above\n",
         "input_filename = os.path.join('input.json')\n",
         "\n",
@@ -183,9 +244,9 @@
         "  \"host\": \"localhost\",\n",
         "  # make sure you replace this with your own username\n",
         "  \"user\": getpass.getuser(),\n",
-        "  \"dbname\": \"e2pg\",\n",
+        "  \"dbname\": \"shovel\",\n",
         "  \"password\": \"\",\n",
-        "  \"query\": \"SELECT value FROM erc20_transfers ORDER BY block_number DESC LIMIT 5\",\n",
+        "  \"query\": \"SELECT v FROM usdc ORDER BY block_num DESC LIMIT 5\",\n",
         "  \"port\": \"5432\",\n",
         "})\n",
         "\n",
@@ -194,7 +255,7 @@
         "\n",
         "\n",
         "    # Serialize data into file:\n",
-        "json.dump( pg_input_file, open(input_filename, 'w' ))\n"
+        "json.dump(pg_input_file, open(input_filename, 'w' ))\n"
       ]
     },
     {
@@ -210,9 +271,9 @@
         "  \"host\": \"localhost\",\n",
         "  # make sure you replace this with your own username\n",
         "  \"user\": getpass.getuser(),\n",
-        "  \"dbname\": \"e2pg\",\n",
+        "  \"dbname\": \"shovel\",\n",
         "  \"password\": \"\",\n",
-        "  \"query\": \"SELECT value FROM erc20_transfers ORDER BY block_number DESC LIMIT 20\",\n",
+        "  \"query\": \"SELECT v FROM usdc ORDER BY block_num DESC LIMIT 20\",\n",
         "  \"port\": \"5432\",\n",
         "})\n",
         "\n",
@@ -229,22 +290,6 @@
         "**EZKL Workflow**"
       ]
     },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "onnx_filename = os.path.join('lol.onnx')\n",
-        "compiled_filename = os.path.join('lol.compiled')\n",
-        "settings_filename = os.path.join('settings.json')\n",
-        "\n",
-        "ezkl.gen_settings(onnx_filename, settings_filename)\n",
-        "\n",
-        "ezkl.calibrate_settings(\n",
-        "    input_filename, onnx_filename, settings_filename, \"resources\")"
-      ]
-    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -253,10 +298,21 @@
       },
       "outputs": [],
       "source": [
-        "# setup kzg params\n",
-        "params_path = os.path.join('kzg.params')\n",
+        "import subprocess\n",
+        "import os\n",
         "\n",
-        "res = ezkl.get_srs(params_path, settings_filename)"
+        "onnx_filename = os.path.join('lol.onnx')\n",
+        "compiled_filename = os.path.join('lol.compiled')\n",
+        "settings_filename = os.path.join('settings.json')\n",
+        "\n",
+        "# Generate settings using ezkl\n",
+        "res = ezkl.gen_settings(onnx_filename, settings_filename)\n",
+        "\n",
+        "assert res == True\n",
+        "\n",
+        "res = ezkl.calibrate_settings(input_filename, onnx_filename, settings_filename, \"resources\")\n",
+        "\n",
+        "assert res == True"
       ]
     },
     {
@@ -306,16 +362,13 @@
       "source": [
         "pk_path = os.path.join('test.pk')\n",
         "vk_path = os.path.join('test.vk')\n",
-        "params_path = os.path.join('kzg.params')\n",
         "\n",
         "\n",
         "# setup the proof\n",
         "res = ezkl.setup(\n",
         "        compiled_filename,\n",
         "        vk_path,\n",
-        "        pk_path,\n",
-        "        params_path,\n",
-        "        settings_filename,\n",
+        "        pk_path\n",
         "    )\n",
         "\n",
         "assert res == True\n",
@@ -331,11 +384,14 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "\n",
         "witness_path = \"witness.json\"\n",
         "\n",
-        "res = ezkl.gen_witness(input_filename, compiled_filename, witness_path)\n",
-        "assert os.path.isfile(witness_path)"
+        "# generate the witness\n",
+        "res = ezkl.gen_witness(\n",
+        "        input_filename,\n",
+        "        compiled_filename,\n",
+        "        witness_path\n",
+        "    )\n"
       ]
     },
     {
@@ -360,73 +416,14 @@
         "        compiled_filename,\n",
         "        pk_path,\n",
         "        proof_path,\n",
-        "        params_path,\n",
-        "        \"single\",\n",
+        "        \"single\"\n",
         "    )\n",
         "\n",
         "\n",
+        "print(\"proved\")\n",
+        "\n",
         "assert os.path.isfile(proof_path)\n",
-        "\n",
-        "# verify\n",
-        "res = ezkl.verify(\n",
-        "        proof_path,\n",
-        "        settings_filename,\n",
-        "        vk_path,\n",
-        "        params_path,\n",
-        "    )\n",
-        "\n",
-        "assert res == True\n",
-        "print(\"verified\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "W7tAa-DFAtvS"
-      },
-      "source": [
-        "# Part 2 (Using the ZK Computational Graph Onchain!)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "8Ym91kaVAIB6"
-      },
-      "source": [
-        "**Now How Do We Do It Onchain?????**"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 339
-        },
-        "id": "fodkNgwS70FM",
-        "outputId": "827b5efd-f74f-44de-c114-861b3a86daf2"
-      },
-      "outputs": [],
-      "source": [
-        "# first we need to create evm verifier\n",
-        "print(vk_path)\n",
-        "print(params_path)\n",
-        "print(settings_filename)\n",
-        "\n",
-        "\n",
-        "abi_path = 'test.abi'\n",
-        "sol_code_path = 'test.sol'\n",
-        "\n",
-        "res = ezkl.create_evm_verifier(\n",
-        "        vk_path,\n",
-        "        params_path,\n",
-        "        settings_filename,\n",
-        "        sol_code_path,\n",
-        "        abi_path,\n",
-        "    )\n",
-        "assert res == True"
+        "\n"
       ]
     },
     {
@@ -435,51 +432,8 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "# Make sure anvil is running locally first\n",
-        "# run with $ anvil -p 3030\n",
-        "# we use the default anvil node here\n",
-        "import json\n",
-        "\n",
-        "address_path = os.path.join(\"address.json\")\n",
-        "\n",
-        "res = ezkl.deploy_evm(\n",
-        "    address_path,\n",
-        "    sol_code_path,\n",
-        "    'http://127.0.0.1:3030'\n",
-        ")\n",
-        "\n",
-        "assert res == True\n",
-        "\n",
-        "with open(address_path, 'r') as file:\n",
-        "    addr = file.read().rstrip()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# read the address from addr_path\n",
-        "addr = None\n",
-        "with open(address_path, 'r') as f:\n",
-        "    addr = f.read()\n",
-        "\n",
-        "res = ezkl.verify_evm(\n",
-        "    addr,\n",
-        "    proof_path,\n",
-        "    \"http://127.0.0.1:3030\"\n",
-        ")\n",
-        "assert res == True"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "os.system(\"killall -9 e2pg\");"
+        "# kill all shovel process \n",
+        "os.system(\"pkill -f shovel\")"
       ]
     }
   ],
@@ -501,7 +455,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.9.13"
+      "version": "3.12.2"
     }
   },
   "nbformat": 4,

examples/notebooks/mnist_gan.ipynb

@@ -38,7 +38,7 @@
                 "import logging\n",
                 "\n",
                 "import tensorflow as tf\n",
-                "from tensorflow.keras.optimizers.legacy import Adam\n",
+                "from tensorflow.keras.optimizers import Adam\n",
                 "from tensorflow.keras.layers import *\n",
                 "from tensorflow.keras.models import Model\n",
                 "from tensorflow.keras.datasets import mnist\n",
@@ -71,9 +71,11 @@
             },
             "outputs": [],
             "source": [
-                "opt = Adam()\n",
                 "ZDIM = 100\n",
                 "\n",
+                "opt = Adam()\n",
+                "\n",
+                "\n",
                 "# discriminator\n",
                 "# 0 if it's fake, 1 if it's real\n",
                 "x = in1 = Input((28,28))\n",
@@ -114,8 +116,11 @@
                 "\n",
                 "gm = Model(in1, x)\n",
                 "gm.compile('adam', 'mse')\n",
+                "gm.output_names=['output']\n",
                 "gm.summary()\n",
                 "\n",
+                "opt = Adam()\n",
+                "\n",
                 "# GAN\n",
                 "dm.trainable = False\n",
                 "x = dm(gm.output)\n",
@@ -415,7 +420,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.2"
         }
     },
     "nbformat": 4,

examples/notebooks/mnist_vae.ipynb

@@ -349,6 +349,8 @@
                 "z_log_var = Dense(ZDIM)(x)\n",
                 "z = Lambda(lambda x: x[0] + K.exp(0.5 * x[1]) * K.random_normal(shape=K.shape(x[0])))([z_mu, z_log_var])\n",
                 "dec = get_decoder()\n",
+                "dec.output_names=['output']\n",
+                "\n",
                 "out = dec(z)\n",
                 "\n",
                 "mse_loss = mse(Reshape((28*28,))(in1), Reshape((28*28,))(out)) * 28 * 28\n",

examples/notebooks/random_forest.ipynb

@@ -61,11 +61,10 @@
                 "from sklearn.datasets import load_iris\n",
                 "from sklearn.model_selection import train_test_split\n",
                 "from sklearn.ensemble import RandomForestClassifier as Rf\n",
-                "import sk2torch\n",
                 "import torch\n",
                 "import ezkl\n",
                 "import os\n",
-                "from torch import nn\n",
+                "from hummingbird.ml import convert\n",
                 "\n",
                 "\n",
                 "\n",
@@ -77,28 +76,12 @@
                 "clr.fit(X_train, y_train)\n",
                 "\n",
                 "\n",
-                "trees = []\n",
-                "for tree in clr.estimators_:\n",
-                "    trees.append(sk2torch.wrap(tree))\n",
                 "\n",
-                "\n",
-                "class RandomForest(nn.Module):\n",
-                "    def __init__(self, trees):\n",
-                "        super(RandomForest, self).__init__()\n",
-                "        self.trees = nn.ModuleList(trees)\n",
-                "\n",
-                "    def forward(self, x):\n",
-                "        out = self.trees[0](x)\n",
-                "        for tree in self.trees[1:]:\n",
-                "            out += tree(x)\n",
-                "        return out / len(self.trees)\n",
-                "\n",
-                "\n",
-                "torch_rf = RandomForest(trees)\n",
+                "torch_rf = convert(clr, 'torch')\n",
                 "# assert predictions from torch are = to sklearn \n",
                 "diffs = []\n",
                 "for i in range(len(X_test)):\n",
-                "    torch_pred = torch_rf(torch.tensor(X_test[i].reshape(1, -1)))\n",
+                "    torch_pred = torch_rf.predict(torch.tensor(X_test[i].reshape(1, -1)))\n",
                 "    sk_pred = clr.predict(X_test[i].reshape(1, -1))\n",
                 "    diffs.append(torch_pred[0].round() - sk_pred[0])\n",
                 "\n",
@@ -134,14 +117,12 @@
                 "\n",
                 "# export to onnx format\n",
                 "\n",
-                "torch_rf.eval()\n",
-                "\n",
                 "# Input to the model\n",
                 "shape = X_train.shape[1:]\n",
                 "x = torch.rand(1, *shape, requires_grad=False)\n",
-                "torch_out = torch_rf(x)\n",
+                "torch_out = torch_rf.predict(x)\n",
                 "# Export the model\n",
-                "torch.onnx.export(torch_rf,               # model being run\n",
+                "torch.onnx.export(torch_rf.model,               # model being run\n",
                 "                  # model input (or a tuple for multiple inputs)\n",
                 "                  x,\n",
                 "                  # where to save the model (can be a file or file-like object)\n",
@@ -158,7 +139,7 @@
                 "\n",
                 "data = dict(input_shapes=[shape],\n",
                 "            input_data=[d],\n",
-                "            output_data=[((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])\n",
+                "            output_data=[o.reshape([-1]).tolist() for o in torch_out])\n",
                 "\n",
                 "# Serialize data into file:\n",
                 "json.dump(data, open(\"input.json\", 'w'))\n"
@@ -321,7 +302,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.2"
         }
     },
     "nbformat": 4,

examples/notebooks/tictactoe_autoencoder.ipynb

@@ -13,7 +13,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 1,
             "metadata": {},
             "outputs": [],
             "source": [
@@ -57,7 +57,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 2,
             "metadata": {},
             "outputs": [],
             "source": [
@@ -119,7 +119,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 3,
             "metadata": {},
             "outputs": [],
             "source": [
@@ -163,7 +163,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 4,
             "metadata": {},
             "outputs": [],
             "source": [
@@ -217,7 +217,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 6,
             "metadata": {},
             "outputs": [],
             "source": [
@@ -227,6 +227,10 @@
                 "        self.length = self.compute_length(self.file_good)\n",
                 "        self.data = self.load_data(self.file_good)\n",
                 "\n",
+                "    def __iter__(self):\n",
+                "        for i in range(len(self.data)):\n",
+                "            yield self.data[i]\n",
+                "\n",
                 "    def parse_json_object(self, line):\n",
                 "        try:\n",
                 "            return json.loads(line)\n",
@@ -749,7 +753,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.2"
         }
     },
     "nbformat": 4,

examples/notebooks/tictactoe_binary_classification.ipynb

@@ -209,6 +209,11 @@
                 "        self.length = self.compute_length(self.file_good, self.file_bad)\n",
                 "        self.data = self.load_data(self.file_good, self.file_bad)\n",
                 "\n",
+                "    def __iter__(self):\n",
+                "        for i in range(len(self.data)):\n",
+                "            yield self.data[i]\n",
+                "\n",
+                "\n",
                 "    def parse_json_object(self, line):\n",
                 "        try:\n",
                 "            return json.loads(line)\n",
@@ -637,7 +642,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.2"
         }
     },
     "nbformat": 4,

examples/onnx/lstm_large/input.json

@@ -0,0 +1,13 @@
+{
+  "input_data": [
+    [
+      0.8894134163856506,
+      0.8894201517105103
+    ]
+  ],
+  "output_data": [
+    [
+      0.8436377
+    ]
+  ]
+}

examples/onnx/lstm_medium/input.json

@@ -0,0 +1,9 @@
+{
+  "input_data": [
+    [
+      1.514470100402832, 1.519423007965088, 1.5182757377624512,
+      1.5262789726257324, 1.5298409461975098
+    ]
+  ],
+  "output_data": [[-0.1862019]]
+}

in-browser-evm-verifier/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezkljs/verify",
-  "version": "0.0.0",
+  "version": "v10.4.2",
   "publishConfig": {
     "access": "public"
   },
@@ -20,16 +20,16 @@
     "build": "npm run clean && npm run build:commonjs && npm run build:esm"
   },
   "dependencies": {
-    "@ethereumjs/common": "^4.0.0",
-    "@ethereumjs/evm": "^2.0.0",
-    "@ethereumjs/statemanager": "^2.0.0",
-    "@ethereumjs/tx": "^5.0.0",
-    "@ethereumjs/util": "^9.0.0",
-    "@ethereumjs/vm": "^7.0.0",
-    "@ethersproject/abi": "^5.7.0",
-    "@ezkljs/engine": "^9.4.4",
-    "ethers": "^6.7.1",
-    "json-bigint": "^1.0.0"
+    "@ethereumjs/common": "4.0.0",
+    "@ethereumjs/evm": "2.0.0",
+    "@ethereumjs/statemanager": "2.0.0",
+    "@ethereumjs/tx": "5.0.0",
+    "@ethereumjs/util": "9.0.0",
+    "@ethereumjs/vm": "7.0.0",
+    "@ethersproject/abi": "5.7.0",
+    "@ezkljs/engine": "10.4.2",
+    "ethers": "6.7.1",
+    "json-bigint": "1.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.8.3",

in-browser-evm-verifier/pnpm-lock.yaml

@@ -6,34 +6,34 @@ settings:
 
 dependencies:
   '@ethereumjs/common':
-    specifier: ^4.0.0
+    specifier: 4.0.0
     version: 4.0.0
   '@ethereumjs/evm':
-    specifier: ^2.0.0
+    specifier: 2.0.0
     version: 2.0.0
   '@ethereumjs/statemanager':
-    specifier: ^2.0.0
+    specifier: 2.0.0
     version: 2.0.0
   '@ethereumjs/tx':
-    specifier: ^5.0.0
+    specifier: 5.0.0
     version: 5.0.0
   '@ethereumjs/util':
-    specifier: ^9.0.0
+    specifier: 9.0.0
     version: 9.0.0
   '@ethereumjs/vm':
-    specifier: ^7.0.0
+    specifier: 7.0.0
     version: 7.0.0
   '@ethersproject/abi':
-    specifier: ^5.7.0
+    specifier: 5.7.0
     version: 5.7.0
   '@ezkljs/engine':
-    specifier: ^9.4.4
-    version: 9.4.4
+    specifier: "10.4.2"
+    version: "10.4.2"
   ethers:
-    specifier: ^6.7.1
+    specifier: 6.7.1
     version: 6.7.1
   json-bigint:
-    specifier: ^1.0.0
+    specifier: 1.0.0
     version: 1.0.0
 
 devDependencies:
@@ -397,8 +397,8 @@ packages:
       '@ethersproject/strings': 5.7.0
     dev: false
 
-  /@ezkljs/engine@9.4.4:
-    resolution: {integrity: sha512-kNsTmDQa8mIiQ6yjJmBMwVgAAxh4nfs4NCtnewJifonyA8Mfhs+teXwwW8WhERRDoQPUofKO2pT8BPvV/XGIDA==}
+  /@ezkljs/engine@10.4.2:
+    resolution: {integrity: "sha512-1GNB4vChbaQ1ALcYbEbM/AFoh4QWtswpzGCO/g9wL8Ep6NegM2gQP/uWICU7Utl0Lj1DncXomD7PUhFSXhtx8A=="}
     dependencies:
       '@types/json-bigint': 1.0.2
       json-bigint: 1.0.0

install_ezkl_cli.sh

@@ -36,7 +36,7 @@ if  [ "$(which ezkl)s" != "s" ] && [ "$(which ezkl)" != "$EZKL_DIR/ezkl" ] ; the
     exit 1
 fi
 
-if [[ ":$PATH:" != *":${EZKl_DIR}:"* ]]; then
+if [[ ":$PATH:" != *":${EZKL_DIR}:"* ]]; then
     # Add the ezkl directory to the path and ensure the old PATH variables remain.
     echo >> $PROFILE && echo "export PATH=\"\$PATH:$EZKL_DIR\"" >> $PROFILE
 fi

pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["maturin>=0.14,<0.15"]
+requires = ["maturin>=1.0,<2.0"]
 build-backend = "maturin"
 
 [tool.pytest.ini_options]

requirements.txt

@@ -1,14 +1,14 @@
-attrs==22.2.0
-exceptiongroup==1.1.1
-importlib-metadata==6.1.0
+attrs==23.2.0
+exceptiongroup==1.2.0
+importlib-metadata==7.1.0
 iniconfig==2.0.0
-maturin==1.0.1
-packaging==23.0
-pluggy==1.0.0
-pytest==7.2.2
+maturin==1.5.1
+packaging==24.0
+pluggy==1.4.0
+pytest==8.1.1
 tomli==2.0.1
-typing-extensions==4.5.0
-zipp==3.15.0
-onnx==1.14.1
-onnxruntime==1.14.1
-numpy==1.21.6
+typing-extensions==4.10.0
+zipp==3.18.1
+onnx==1.15.0
+onnxruntime==1.17.1
+numpy==1.26.4

src/circuit/modules/polycommit.rs

@@ -44,12 +44,11 @@ impl PolyCommitChip {
     /// Commit to the message using the KZG commitment scheme
     pub fn commit<Scheme: CommitmentScheme<Scalar = Fp, Curve = G1Affine>>(
         message: Vec<Scheme::Scalar>,
-        degree: u32,
         num_unusable_rows: u32,
         params: &Scheme::ParamsProver,
     ) -> Vec<G1Affine> {
         let k = params.k();
-        let domain = halo2_proofs::poly::EvaluationDomain::new(degree, k);
+        let domain = halo2_proofs::poly::EvaluationDomain::new(2, k);
         let n = 2_u64.pow(k) - num_unusable_rows as u64;
         let num_poly = (message.len() / n as usize) + 1;
         let mut poly = vec![domain.empty_lagrange(); num_poly];

src/circuit/ops/chip.rs

@@ -24,7 +24,7 @@ use crate::{
         table::{Range, RangeCheck, Table},
         utils,
     },
-    tensor::{Tensor, TensorType, ValTensor, VarTensor},
+    tensor::{IntoI64, Tensor, TensorType, ValTensor, VarTensor},
 };
 use std::{collections::BTreeMap, error::Error, marker::PhantomData};
 
@@ -80,14 +80,18 @@ impl ToFlags for CheckMode {
 
 impl From<String> for CheckMode {
     fn from(value: String) -> Self {
-        match value.to_lowercase().as_str() {
-            "safe" => CheckMode::SAFE,
-            "unsafe" => CheckMode::UNSAFE,
-            _ => {
-                log::error!("Invalid value for CheckMode");
-                log::warn!("defaulting to SAFE");
-                CheckMode::SAFE
-            }
+        Self::from_str(value.as_str()).unwrap()
+    }
+}
+
+impl FromStr for CheckMode {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "safe" => Ok(CheckMode::SAFE),
+            "unsafe" => Ok(CheckMode::UNSAFE),
+            _ => Err("Invalid value for CheckMode".to_string()),
         }
     }
 }
@@ -345,7 +349,7 @@ pub struct BaseConfig<F: PrimeField + TensorType + PartialOrd> {
     _marker: PhantomData<F>,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> 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 {
@@ -956,20 +960,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
         values: &[ValTensor<F>],
         op: Box<dyn Op<F>>,
     ) -> Result<Option<ValTensor<F>>, Box<dyn Error>> {
-        let res = op.layout(self, region, values)?;
-
-        if matches!(&self.check_mode, CheckMode::SAFE) && !region.is_dummy() {
-            if let Some(claimed_output) = &res {
-                // during key generation this will be unknown vals so we use this as a flag to check
-                let mut is_assigned = !claimed_output.any_unknowns()?;
-                for val in values.iter() {
-                    is_assigned = is_assigned && !val.any_unknowns()?;
-                }
-                if is_assigned {
-                    op.safe_mode_check(claimed_output, values)?;
-                }
-            }
-        };
-        Ok(res)
+        op.layout(self, region, values)
     }
 }

src/circuit/ops/hybrid.rs

@@ -1,9 +1,9 @@
 use super::*;
 use crate::{
     circuit::{layouts, utils, Tolerance},
-    fieldutils::{felt_to_i128, i128_to_felt},
+    fieldutils::i64_to_felt,
     graph::multiplier_to_scale,
-    tensor::{self, Tensor, TensorError, TensorType, ValTensor},
+    tensor::{self, Tensor, TensorType, ValTensor},
 };
 use halo2curves::ff::PrimeField;
 use serde::{Deserialize, Serialize};
@@ -29,15 +29,15 @@ pub enum HybridOp {
         dim: usize,
     },
     SumPool {
-        padding: [(usize, usize); 2],
-        stride: (usize, usize),
-        kernel_shape: (usize, usize),
+        padding: Vec<(usize, usize)>,
+        stride: Vec<usize>,
+        kernel_shape: Vec<usize>,
         normalized: bool,
     },
-    MaxPool2d {
-        padding: [(usize, usize); 2],
-        stride: (usize, usize),
-        pool_dims: (usize, usize),
+    MaxPool {
+        padding: Vec<(usize, usize)>,
+        stride: Vec<usize>,
+        pool_dims: Vec<usize>,
     },
     ReduceMin {
         axes: Vec<usize>,
@@ -71,7 +71,7 @@ pub enum HybridOp {
     },
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for HybridOp {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for HybridOp {
     ///
     fn requires_homogenous_input_scales(&self) -> Vec<usize> {
         match self {
@@ -85,93 +85,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
     fn as_any(&self) -> &dyn Any {
         self
     }
-    /// Matches a [Op] to an operation in the `tensor::ops` module.
-    fn f(&self, inputs: &[Tensor<F>]) -> Result<ForwardResult<F>, TensorError> {
-        let x = inputs[0].clone().map(|x| felt_to_i128(x));
-
-        let res = match &self {
-            HybridOp::ReduceMax { axes, .. } => tensor::ops::max_axes(&x, axes)?,
-            HybridOp::ReduceMin { axes, .. } => tensor::ops::min_axes(&x, axes)?,
-            HybridOp::Div { denom, .. } => {
-                crate::tensor::ops::nonlinearities::const_div(&x, denom.0 as f64)
-            }
-            HybridOp::Recip {
-                input_scale,
-                output_scale,
-                ..
-            } => crate::tensor::ops::nonlinearities::recip(
-                &x,
-                input_scale.0 as f64,
-                output_scale.0 as f64,
-            ),
-            HybridOp::ReduceArgMax { dim } => tensor::ops::argmax_axes(&x, *dim)?,
-            HybridOp::ReduceArgMin { dim } => tensor::ops::argmin_axes(&x, *dim)?,
-            HybridOp::Gather { dim, constant_idx } => {
-                if let Some(idx) = constant_idx {
-                    tensor::ops::gather(&x, idx, *dim)?
-                } else {
-                    let y = inputs[1].clone().map(|x| felt_to_i128(x));
-                    tensor::ops::gather(&x, &y.map(|x| x as usize), *dim)?
-                }
-            }
-            HybridOp::OneHot { dim, num_classes } => {
-                tensor::ops::one_hot(&x, *num_classes, *dim)?.clone()
-            }
-
-            HybridOp::TopK { dim, k, largest } => tensor::ops::topk_axes(&x, *k, *dim, *largest)?,
-            HybridOp::MaxPool2d {
-                padding,
-                stride,
-                pool_dims,
-                ..
-            } => tensor::ops::max_pool2d(&x, padding, stride, pool_dims)?,
-            HybridOp::SumPool {
-                padding,
-                stride,
-                kernel_shape,
-                normalized,
-            } => tensor::ops::sumpool(&x, *padding, *stride, *kernel_shape, *normalized)?,
-            HybridOp::Softmax {
-                input_scale,
-                output_scale,
-                axes,
-            } => tensor::ops::nonlinearities::softmax_axes(
-                &x,
-                input_scale.into(),
-                output_scale.into(),
-                axes,
-            ),
-            HybridOp::RangeCheck(tol) => {
-                let y = inputs[1].clone().map(|x| felt_to_i128(x));
-                tensor::ops::nonlinearities::range_check_percent(&[x, y], 128, 128, tol.val)
-            }
-            HybridOp::Greater => {
-                let y = inputs[1].clone().map(|x| felt_to_i128(x));
-                tensor::ops::greater(&x, &y)?
-            }
-            HybridOp::GreaterEqual => {
-                let y = inputs[1].clone().map(|x| felt_to_i128(x));
-                tensor::ops::greater_equal(&x, &y)?
-            }
-            HybridOp::Less => {
-                let y = inputs[1].clone().map(|x| felt_to_i128(x));
-                tensor::ops::less(&x, &y)?
-            }
-            HybridOp::LessEqual => {
-                let y = inputs[1].clone().map(|x| felt_to_i128(x));
-                tensor::ops::less_equal(&x, &y)?
-            }
-            HybridOp::Equals => {
-                let y = inputs[1].clone().map(|x| felt_to_i128(x));
-                tensor::ops::equals(&x, &y)?
-            }
-        };
-
-        // convert back to felt
-        let output = res.map(|x| i128_to_felt(x));
-
-        Ok(ForwardResult { output })
-    }
 
     fn as_string(&self) -> String {
         match self {
@@ -201,12 +114,12 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
             ),
             HybridOp::ReduceMax { axes } => format!("REDUCEMAX (axes={:?})", axes),
             HybridOp::ReduceArgMax { dim } => format!("REDUCEARGMAX (dim={})", dim),
-            HybridOp::MaxPool2d {
+            HybridOp::MaxPool {
                 padding,
                 stride,
                 pool_dims,
             } => format!(
-                "MAXPOOL2D (padding={:?}, stride={:?}, pool_dims={:?})",
+                "MaxPool (padding={:?}, stride={:?}, pool_dims={:?})",
                 padding, stride, pool_dims
             ),
             HybridOp::ReduceMin { axes } => format!("REDUCEMIN (axes={:?})", axes),
@@ -253,9 +166,9 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                 config,
                 region,
                 values[..].try_into()?,
-                *padding,
-                *stride,
-                *kernel_shape,
+                padding,
+                stride,
+                kernel_shape,
                 *normalized,
             )?,
             HybridOp::Recip {
@@ -271,8 +184,8 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                         config,
                         region,
                         values[..].try_into()?,
-                        i128_to_felt(input_scale.0 as i128),
-                        i128_to_felt(output_scale.0 as i128),
+                        i64_to_felt(input_scale.0 as i64),
+                        i64_to_felt(output_scale.0 as i64),
                     )?
                 } else {
                     layouts::nonlinearity(
@@ -296,7 +209,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                         config,
                         region,
                         values[..].try_into()?,
-                        i128_to_felt(denom.0 as i128),
+                        i64_to_felt(denom.0 as i64),
                     )?
                 } else {
                     layouts::nonlinearity(
@@ -315,17 +228,17 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                 }
             }
 
-            HybridOp::MaxPool2d {
+            HybridOp::MaxPool {
                 padding,
                 stride,
                 pool_dims,
-            } => layouts::max_pool2d(
+            } => layouts::max_pool(
                 config,
                 region,
                 values[..].try_into()?,
-                *padding,
-                *stride,
-                *pool_dims,
+                padding,
+                stride,
+                pool_dims,
             )?,
             HybridOp::ReduceMax { axes } => {
                 layouts::max_axes(config, region, values[..].try_into()?, axes)?

src/circuit/ops/lookup.rs

@@ -4,9 +4,9 @@ use std::error::Error;
 
 use crate::{
     circuit::{layouts, table::Range, utils},
-    fieldutils::{felt_to_i128, i128_to_felt},
+    fieldutils::{felt_to_i64, i64_to_felt},
     graph::multiplier_to_scale,
-    tensor::{self, Tensor, TensorError, TensorType},
+    tensor::{self, IntoI64, Tensor, TensorError, TensorType},
 };
 
 use super::Op;
@@ -132,19 +132,16 @@ impl LookupOp {
     /// Returns the range of values that can be represented by the table
     pub fn bit_range(max_len: usize) -> Range {
         let range = (max_len - 1) as f64 / 2_f64;
-        let range = range as i128;
+        let range = range as i64;
         (-range, range)
     }
-}
 
-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
-    }
     /// Matches a [Op] to an operation in the `tensor::ops` module.
-    fn f(&self, x: &[Tensor<F>]) -> Result<ForwardResult<F>, TensorError> {
-        let x = x[0].clone().map(|x| felt_to_i128(x));
+    pub(crate) fn f<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64>(
+        &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())),
@@ -231,10 +228,17 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Lookup
             }
         }?;
 
-        let output = res.map(|x| i128_to_felt(x));
+        let output = res.map(|x| i64_to_felt(x));
 
         Ok(ForwardResult { output })
     }
+}
+
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for LookupOp {
+    /// Returns a reference to the Any trait.
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
 
     /// Returns the name of the operation
     fn as_string(&self) -> String {

src/circuit/ops/mod.rs

@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     graph::quantize_tensor,
-    tensor::{self, Tensor, TensorError, TensorType, ValTensor},
+    tensor::{self, IntoI64, Tensor, TensorType, ValTensor},
 };
 use halo2curves::ff::PrimeField;
 
@@ -27,16 +27,14 @@ pub mod region;
 
 /// 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> {
+pub struct ForwardResult<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> {
     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>:
+pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64>:
     std::fmt::Debug + Send + Sync + Any
 {
-    /// Matches a [Op] to an operation in the `tensor::ops` module.
-    fn f(&self, x: &[Tensor<F>]) -> Result<ForwardResult<F>, TensorError>;
     /// Returns a string representation of the operation.
     fn as_string(&self) -> String;
 
@@ -71,36 +69,9 @@ pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>:
 
     /// Returns a reference to the Any trait.
     fn as_any(&self) -> &dyn Any;
-
-    /// Safe mode output checl
-    fn safe_mode_check(
-        &self,
-        claimed_output: &ValTensor<F>,
-        original_values: &[ValTensor<F>],
-    ) -> Result<(), TensorError> {
-        let felt_evals = original_values
-            .iter()
-            .map(|v| {
-                let mut evals = v.get_felt_evals().map_err(|_| TensorError::FeltError)?;
-                evals.reshape(v.dims())?;
-                Ok(evals)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-
-        let ref_op: Tensor<F> = self.f(&felt_evals)?.output;
-
-        let mut output = claimed_output
-            .get_felt_evals()
-            .map_err(|_| TensorError::FeltError)?;
-        output.reshape(claimed_output.dims())?;
-
-        assert_eq!(output, ref_op);
-
-        Ok(())
-    }
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Clone for Box<dyn Op<F>> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Clone for Box<dyn Op<F>> {
     fn clone(&self) -> Self {
         self.clone_dyn()
     }
@@ -151,8 +122,8 @@ impl InputType {
                 *input = T::from_f64(f64_input).unwrap();
             }
             InputType::Int | InputType::TDim => {
-                let int_input = input.clone().to_i128().unwrap();
-                *input = T::from_i128(int_input).unwrap();
+                let int_input = input.clone().to_i64().unwrap();
+                *input = T::from_i64(int_input).unwrap();
             }
         }
     }
@@ -167,7 +138,7 @@ pub struct Input {
     pub datum_type: InputType,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for Input {
     fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, Box<dyn Error>> {
         Ok(self.scale)
     }
@@ -176,12 +147,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input
         self
     }
 
-    fn f(&self, x: &[Tensor<F>]) -> Result<ForwardResult<F>, TensorError> {
-        Ok(ForwardResult {
-            output: x[0].clone(),
-        })
-    }
-
     fn as_string(&self) -> String {
         "Input".into()
     }
@@ -228,16 +193,13 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct Unknown;
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Unknown {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for Unknown {
     fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, Box<dyn Error>> {
         Ok(0)
     }
     fn as_any(&self) -> &dyn Any {
         self
     }
-    fn f(&self, _: &[Tensor<F>]) -> Result<ForwardResult<F>, TensorError> {
-        Err(TensorError::WrongMethod)
-    }
 
     fn as_string(&self) -> String {
         "Unknown".into()
@@ -258,7 +220,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Unknow
 
 ///
 #[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
+pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> {
     ///
     pub quantized_values: Tensor<F>,
     ///
@@ -268,7 +230,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> Constant<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Constant<F> {
     ///
     pub fn new(quantized_values: Tensor<F>, raw_values: Tensor<f32>) -> Self {
         Self {
@@ -301,17 +263,13 @@ impl<
             + PartialOrd
             + std::hash::Hash
             + Serialize
-            + for<'de> Deserialize<'de>,
+            + for<'de> Deserialize<'de>
+            + IntoI64,
     > Op<F> for Constant<F>
 {
     fn as_any(&self) -> &dyn Any {
         self
     }
-    fn f(&self, _: &[Tensor<F>]) -> Result<ForwardResult<F>, TensorError> {
-        let output = self.quantized_values.clone();
-
-        Ok(ForwardResult { output })
-    }
 
     fn as_string(&self) -> String {
         format!("CONST (scale={})", self.quantized_values.scale().unwrap())

src/circuit/ops/poly.rs

@@ -1,6 +1,5 @@
 use crate::{
     circuit::layouts,
-    fieldutils::felt_to_i128,
     tensor::{self, Tensor, TensorError},
 };
 
@@ -32,8 +31,8 @@ pub enum PolyOp {
         equation: String,
     },
     Conv {
-        padding: [(usize, usize); 2],
-        stride: (usize, usize),
+        padding: Vec<(usize, usize)>,
+        stride: Vec<usize>,
     },
     Downsample {
         axis: usize,
@@ -41,9 +40,9 @@ pub enum PolyOp {
         modulo: usize,
     },
     DeConv {
-        padding: [(usize, usize); 2],
-        output_padding: (usize, usize),
-        stride: (usize, usize),
+        padding: Vec<(usize, usize)>,
+        output_padding: Vec<usize>,
+        stride: Vec<usize>,
     },
     Add,
     Sub,
@@ -58,10 +57,13 @@ pub enum PolyOp {
         destination: usize,
     },
     Flatten(Vec<usize>),
-    Pad([(usize, usize); 2]),
+    Pad(Vec<(usize, usize)>),
     Sum {
         axes: Vec<usize>,
     },
+    MeanOfSquares {
+        axes: Vec<usize>,
+    },
     Prod {
         axes: Vec<usize>,
         len_prod: usize,
@@ -95,7 +97,8 @@ impl<
             + PartialOrd
             + std::hash::Hash
             + Serialize
-            + for<'de> Deserialize<'de>,
+            + for<'de> Deserialize<'de>
+            + IntoI64,
     > Op<F> for PolyOp
 {
     /// Returns a reference to the Any trait.
@@ -105,10 +108,28 @@ impl<
 
     fn as_string(&self) -> String {
         match &self {
-            PolyOp::GatherElements { dim, .. } => format!("GATHERELEMENTS (dim={})", dim),
-            PolyOp::GatherND { batch_dims, .. } => format!("GATHERND (batch_dims={})", batch_dims),
-            PolyOp::ScatterElements { dim, .. } => format!("SCATTERELEMENTS (dim={})", dim),
-            PolyOp::ScatterND { .. } => "SCATTERND".into(),
+            PolyOp::GatherElements { dim, constant_idx } => format!(
+                "GATHERELEMENTS (dim={}, constant_idx{})",
+                dim,
+                constant_idx.is_some()
+            ),
+            PolyOp::GatherND {
+                batch_dims,
+                indices,
+            } => format!(
+                "GATHERND (batch_dims={}, constant_idx{})",
+                batch_dims,
+                indices.is_some()
+            ),
+            PolyOp::MeanOfSquares { axes } => format!("MEANOFSQUARES (axes={:?})", axes),
+            PolyOp::ScatterElements { dim, constant_idx } => format!(
+                "SCATTERELEMENTS (dim={}, constant_idx{})",
+                dim,
+                constant_idx.is_some()
+            ),
+            PolyOp::ScatterND { constant_idx } => {
+                format!("SCATTERND (constant_idx={})", constant_idx.is_some())
+            }
             PolyOp::MultiBroadcastTo { shape } => format!("MULTIBROADCASTTO (shape={:?})", shape),
             PolyOp::MoveAxis { .. } => "MOVEAXIS".into(),
             PolyOp::Downsample { .. } => "DOWNSAMPLE".into(),
@@ -120,15 +141,26 @@ impl<
             }
             PolyOp::Reshape(shape) => format!("RESHAPE (shape={:?})", shape),
             PolyOp::Flatten(_) => "FLATTEN".into(),
-            PolyOp::Pad(_) => "PAD".into(),
+            PolyOp::Pad(pads) => format!("PAD (pads={:?})", pads),
             PolyOp::Add => "ADD".into(),
             PolyOp::Mult => "MULT".into(),
             PolyOp::Sub => "SUB".into(),
             PolyOp::Sum { axes } => format!("SUM (axes={:?})", axes),
             PolyOp::Prod { .. } => "PROD".into(),
             PolyOp::Pow(_) => "POW".into(),
-            PolyOp::Conv { .. } => "CONV".into(),
-            PolyOp::DeConv { .. } => "DECONV".into(),
+            PolyOp::Conv { stride, padding } => {
+                format!("CONV (stride={:?}, padding={:?})", stride, padding)
+            }
+            PolyOp::DeConv {
+                stride,
+                padding,
+                output_padding,
+            } => {
+                format!(
+                    "DECONV (stride={:?}, padding={:?}, output_padding={:?})",
+                    stride, padding, output_padding
+                )
+            }
             PolyOp::Concat { axis } => format!("CONCAT (axis={})", axis),
             PolyOp::Slice { axis, start, end } => {
                 format!("SLICE (axis={}, start={}, end={})", axis, start, end)
@@ -142,146 +174,6 @@ impl<
         }
     }
 
-    /// Matches a [Op] to an operation in the `tensor::ops` module.
-    fn f(&self, inputs: &[Tensor<F>]) -> Result<ForwardResult<F>, TensorError> {
-        let mut inputs = inputs.to_vec();
-        let res = match &self {
-            PolyOp::MultiBroadcastTo { shape } => {
-                if 1 != inputs.len() {
-                    return Err(TensorError::DimMismatch(
-                        "multibroadcastto inputs".to_string(),
-                    ));
-                }
-                inputs[0].expand(shape)
-            }
-            PolyOp::And => tensor::ops::and(&inputs[0], &inputs[1]),
-            PolyOp::Or => tensor::ops::or(&inputs[0], &inputs[1]),
-            PolyOp::Xor => tensor::ops::xor(&inputs[0], &inputs[1]),
-            PolyOp::Not => tensor::ops::not(&inputs[0]),
-            PolyOp::Downsample {
-                axis,
-                stride,
-                modulo,
-            } => tensor::ops::downsample(&inputs[0], *axis, *stride, *modulo),
-            PolyOp::Resize { scale_factor } => tensor::ops::resize(&inputs[0], scale_factor),
-            PolyOp::Iff => tensor::ops::iff(&inputs[0], &inputs[1], &inputs[2]),
-            PolyOp::Einsum { equation } => tensor::ops::einsum(equation, &inputs),
-            PolyOp::Identity { .. } => Ok(inputs[0].clone()),
-            PolyOp::Reshape(new_dims) => {
-                let mut t = inputs[0].clone();
-                t.reshape(new_dims)?;
-                Ok(t)
-            }
-            PolyOp::MoveAxis {
-                source,
-                destination,
-            } => inputs[0].move_axis(*source, *destination),
-            PolyOp::Flatten(new_dims) => {
-                let mut t = inputs[0].clone();
-                t.reshape(new_dims)?;
-                Ok(t)
-            }
-            PolyOp::Pad(p) => {
-                if 1 != inputs.len() {
-                    return Err(TensorError::DimMismatch("pad inputs".to_string()));
-                }
-                tensor::ops::pad(&inputs[0], *p)
-            }
-            PolyOp::Add => tensor::ops::add(&inputs),
-            PolyOp::Neg => tensor::ops::neg(&inputs[0]),
-            PolyOp::Sub => tensor::ops::sub(&inputs),
-            PolyOp::Mult => tensor::ops::mult(&inputs),
-            PolyOp::Conv { padding, stride } => tensor::ops::conv(&inputs, *padding, *stride),
-            PolyOp::DeConv {
-                padding,
-                output_padding,
-                stride,
-            } => tensor::ops::deconv(&inputs, *padding, *output_padding, *stride),
-            PolyOp::Pow(u) => {
-                if 1 != inputs.len() {
-                    return Err(TensorError::DimMismatch("pow inputs".to_string()));
-                }
-                inputs[0].pow(*u)
-            }
-            PolyOp::Sum { axes } => {
-                if 1 != inputs.len() {
-                    return Err(TensorError::DimMismatch("sum inputs".to_string()));
-                }
-                tensor::ops::sum_axes(&inputs[0], axes)
-            }
-            PolyOp::Prod { axes, .. } => {
-                if 1 != inputs.len() {
-                    return Err(TensorError::DimMismatch("prod inputs".to_string()));
-                }
-                tensor::ops::prod_axes(&inputs[0], axes)
-            }
-            PolyOp::Concat { axis } => {
-                tensor::ops::concat(&inputs.iter().collect::<Vec<_>>(), *axis)
-            }
-            PolyOp::Slice { axis, start, end } => {
-                if 1 != inputs.len() {
-                    return Err(TensorError::DimMismatch("slice inputs".to_string()));
-                }
-                tensor::ops::slice(&inputs[0], axis, start, end)
-            }
-            PolyOp::GatherElements { dim, constant_idx } => {
-                let x = inputs[0].clone();
-                let y = if let Some(idx) = constant_idx {
-                    idx.clone()
-                } else {
-                    inputs[1].clone().map(|x| felt_to_i128(x) as usize)
-                };
-                tensor::ops::gather_elements(&x, &y, *dim)
-            }
-            PolyOp::GatherND {
-                indices,
-                batch_dims,
-            } => {
-                let x = inputs[0].clone();
-                let y = if let Some(idx) = indices {
-                    idx.clone()
-                } else {
-                    inputs[1].clone().map(|x| felt_to_i128(x) as usize)
-                };
-                tensor::ops::gather_nd(&x, &y, *batch_dims)
-            }
-            PolyOp::ScatterElements { dim, constant_idx } => {
-                let x = inputs[0].clone();
-
-                let idx = if let Some(idx) = constant_idx {
-                    idx.clone()
-                } else {
-                    inputs[1].clone().map(|x| felt_to_i128(x) as usize)
-                };
-
-                let src = if constant_idx.is_some() {
-                    inputs[1].clone()
-                } else {
-                    inputs[2].clone()
-                };
-                tensor::ops::scatter(&x, &idx, &src, *dim)
-            }
-
-            PolyOp::ScatterND { constant_idx } => {
-                let x = inputs[0].clone();
-                let idx = if let Some(idx) = constant_idx {
-                    idx.clone()
-                } else {
-                    inputs[1].clone().map(|x| felt_to_i128(x) as usize)
-                };
-                let src = if constant_idx.is_some() {
-                    inputs[1].clone()
-                } else {
-                    inputs[2].clone()
-                };
-                tensor::ops::scatter_nd(&x, &idx, &src)
-            }
-            PolyOp::Trilu { upper, k } => tensor::ops::trilu(&inputs[0], *k, *upper),
-        }?;
-
-        Ok(ForwardResult { output: res })
-    }
-
     fn layout(
         &self,
         config: &mut crate::circuit::BaseConfig<F>,
@@ -292,6 +184,9 @@ impl<
             PolyOp::MultiBroadcastTo { shape } => {
                 layouts::expand(config, region, values[..].try_into()?, shape)?
             }
+            PolyOp::MeanOfSquares { axes } => {
+                layouts::mean_of_squares_axes(config, region, values[..].try_into()?, axes)?
+            }
             PolyOp::Xor => layouts::xor(config, region, values[..].try_into()?)?,
             PolyOp::Or => layouts::or(config, region, values[..].try_into()?)?,
             PolyOp::And => layouts::and(config, region, values[..].try_into()?)?,
@@ -318,7 +213,7 @@ impl<
                 layouts::prod_axes(config, region, values[..].try_into()?, axes)?
             }
             PolyOp::Conv { padding, stride } => {
-                layouts::conv(config, region, values[..].try_into()?, *padding, *stride)?
+                layouts::conv(config, region, values[..].try_into()?, padding, stride)?
             }
             PolyOp::GatherElements { dim, constant_idx } => {
                 if let Some(idx) = constant_idx {
@@ -370,9 +265,9 @@ impl<
                 config,
                 region,
                 values[..].try_into()?,
-                *padding,
-                *output_padding,
-                *stride,
+                padding,
+                output_padding,
+                stride,
             )?,
             PolyOp::Add => layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Add)?,
             PolyOp::Sub => layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Sub)?,
@@ -388,7 +283,7 @@ impl<
                     )));
                 }
                 let mut input = values[0].clone();
-                input.pad(*p)?;
+                input.pad(p.clone(), 0)?;
                 input
             }
             PolyOp::Pow(exp) => layouts::pow(config, region, values[..].try_into()?, *exp)?,
@@ -404,6 +299,7 @@ impl<
 
     fn out_scale(&self, in_scales: Vec<crate::Scale>) -> Result<crate::Scale, Box<dyn Error>> {
         let scale = match self {
+            PolyOp::MeanOfSquares { .. } => 2 * in_scales[0],
             PolyOp::Xor | PolyOp::Or | PolyOp::And | PolyOp::Not => 0,
             PolyOp::Iff => in_scales[1],
             PolyOp::Einsum { .. } => {

src/circuit/ops/region.rs

@@ -9,7 +9,7 @@ use halo2_proofs::{
     plonk::{Error, Selector},
 };
 use halo2curves::ff::PrimeField;
-use portable_atomic::AtomicI128 as AtomicInt;
+use portable_atomic::AtomicI64 as AtomicInt;
 use std::{
     cell::RefCell,
     collections::{HashMap, HashSet},
@@ -133,10 +133,11 @@ pub struct RegionCtx<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Ha
     shuffle_index: ShuffleIndex,
     used_lookups: HashSet<LookupOp>,
     used_range_checks: HashSet<Range>,
-    max_lookup_inputs: i128,
-    min_lookup_inputs: i128,
-    max_range_size: i128,
+    max_lookup_inputs: i64,
+    min_lookup_inputs: i64,
+    max_range_size: i64,
     witness_gen: bool,
+    check_lookup_range: bool,
     assigned_constants: ConstantsMap<F>,
 }
 
@@ -191,6 +192,11 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         self.witness_gen
     }
 
+    ///
+    pub fn check_lookup_range(&self) -> bool {
+        self.check_lookup_range
+    }
+
     /// Create a new region context
     pub fn new(region: Region<'a, F>, row: usize, num_inner_cols: usize) -> RegionCtx<'a, F> {
         let region = Some(RefCell::new(region));
@@ -209,6 +215,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             min_lookup_inputs: 0,
             max_range_size: 0,
             witness_gen: true,
+            check_lookup_range: true,
             assigned_constants: HashMap::new(),
         }
     }
@@ -246,12 +253,18 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             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) -> RegionCtx<'a, F> {
+    pub fn new_dummy(
+        row: usize,
+        num_inner_cols: usize,
+        witness_gen: bool,
+        check_lookup_range: bool,
+    ) -> RegionCtx<'a, F> {
         let region = None;
         let linear_coord = row * num_inner_cols;
 
@@ -268,6 +281,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             min_lookup_inputs: 0,
             max_range_size: 0,
             witness_gen,
+            check_lookup_range,
             assigned_constants: HashMap::new(),
         }
     }
@@ -278,6 +292,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         linear_coord: usize,
         num_inner_cols: usize,
         witness_gen: bool,
+        check_lookup_range: bool,
     ) -> RegionCtx<'a, F> {
         let region = None;
         RegionCtx {
@@ -293,6 +308,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
             min_lookup_inputs: 0,
             max_range_size: 0,
             witness_gen,
+            check_lookup_range,
             assigned_constants: HashMap::new(),
         }
     }
@@ -364,6 +380,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
                     starting_linear_coord,
                     self.num_inner_cols,
                     self.witness_gen,
+                    self.check_lookup_range,
                 );
                 let res = inner_loop_function(idx, &mut local_reg);
                 // we update the offset and constants
@@ -546,17 +563,17 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
     }
 
     /// max lookup inputs
-    pub fn max_lookup_inputs(&self) -> i128 {
+    pub fn max_lookup_inputs(&self) -> i64 {
         self.max_lookup_inputs
     }
 
     /// min lookup inputs
-    pub fn min_lookup_inputs(&self) -> i128 {
+    pub fn min_lookup_inputs(&self) -> i64 {
         self.min_lookup_inputs
     }
 
     /// max range check
-    pub fn max_range_size(&self) -> i128 {
+    pub fn max_range_size(&self) -> i64 {
         self.max_range_size
     }
 

src/circuit/table.rs

@@ -11,19 +11,17 @@ use maybe_rayon::prelude::{IntoParallelIterator, ParallelIterator};
 
 use crate::{
     circuit::CircuitError,
-    fieldutils::i128_to_felt,
-    tensor::{Tensor, TensorType},
+    fieldutils::i64_to_felt,
+    tensor::{IntoI64, Tensor, TensorType},
 };
 
 use crate::circuit::lookup::LookupOp;
 
-use super::Op;
-
 /// The range of the lookup table.
-pub type Range = (i128, i128);
+pub type Range = (i64, i64);
 
 /// The safety factor for the range of the lookup table.
-pub const RANGE_MULTIPLIER: i128 = 2;
+pub const RANGE_MULTIPLIER: i64 = 2;
 /// The safety factor offset for the number of rows in the lookup table.
 pub const RESERVED_BLINDING_ROWS_PAD: usize = 3;
 
@@ -98,26 +96,25 @@ pub struct Table<F: PrimeField> {
     _marker: PhantomData<F>,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> 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_i128(input) - self.range.0).abs() / (self.col_size as i128);
+            (crate::fieldutils::felt_to_i64(input) - self.range.0).abs() / (self.col_size as i64);
 
-        i128_to_felt(chunk)
+        i64_to_felt(chunk)
     }
 
     /// get first_element of column
     pub fn get_first_element(&self, chunk: usize) -> (F, F) {
-        let chunk = chunk as i128;
+        let chunk = chunk as i64;
         // we index from 1 to prevent soundness issues
-        let first_element = i128_to_felt(chunk * (self.col_size as i128) + self.range.0);
-        let op_f = Op::<F>::f(
-            &self.nonlinearity,
-            &[Tensor::from(vec![first_element].into_iter())],
-        )
-        .unwrap();
+        let first_element = i64_to_felt(chunk * (self.col_size as i64) + self.range.0);
+        let op_f = self
+            .nonlinearity
+            .f(&[Tensor::from(vec![first_element].into_iter())])
+            .unwrap();
         (first_element, op_f.output[0])
     }
 
@@ -133,12 +130,12 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
 }
 
 ///
-pub fn num_cols_required(range_len: i128, col_size: usize) -> usize {
+pub fn num_cols_required(range_len: i64, col_size: usize) -> usize {
     // number of cols needed to store the range
-    (range_len / (col_size as i128)) as usize + 1
+    (range_len / (col_size as i64)) as usize + 1
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<F> {
     /// Configures the table.
     pub fn configure(
         cs: &mut ConstraintSystem<F>,
@@ -205,8 +202,8 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
         let smallest = self.range.0;
         let largest = self.range.1;
 
-        let inputs = Tensor::from(smallest..=largest).map(|x| i128_to_felt(x));
-        let evals = Op::<F>::f(&self.nonlinearity, &[inputs.clone()])?;
+        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;
@@ -275,12 +272,12 @@ pub struct RangeCheck<F: PrimeField> {
     _marker: PhantomData<F>,
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RangeCheck<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeCheck<F> {
     /// get first_element of column
     pub fn get_first_element(&self, chunk: usize) -> F {
-        let chunk = chunk as i128;
+        let chunk = chunk as i64;
         // we index from 1 to prevent soundness issues
-        i128_to_felt(chunk * (self.col_size as i128) + self.range.0)
+        i64_to_felt(chunk * (self.col_size as i64) + self.range.0)
     }
 
     ///
@@ -297,13 +294,13 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RangeCheck<F> {
     pub fn get_col_index(&self, input: F) -> F {
         //    range is split up into chunks of size col_size, find the chunk that input is in
         let chunk =
-            (crate::fieldutils::felt_to_i128(input) - self.range.0).abs() / (self.col_size as i128);
+            (crate::fieldutils::felt_to_i64(input) - self.range.0).abs() / (self.col_size as i64);
 
-        i128_to_felt(chunk)
+        i64_to_felt(chunk)
     }
 }
 
-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RangeCheck<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeCheck<F> {
     /// Configures the table.
     pub fn configure(cs: &mut ConstraintSystem<F>, range: Range, logrows: usize) -> RangeCheck<F> {
         log::debug!("range check range: {:?}", range);
@@ -353,7 +350,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RangeCheck<F> {
         let smallest = self.range.0;
         let largest = self.range.1;
 
-        let inputs: Tensor<F> = Tensor::from(smallest..=largest).map(|x| i128_to_felt(x));
+        let inputs: Tensor<F> = Tensor::from(smallest..=largest).map(|x| i64_to_felt(x));
         let chunked_inputs = inputs.chunks(self.col_size);
 
         self.is_assigned = true;

src/circuit/tests.rs

@@ -1048,8 +1048,8 @@ mod conv {
                                 &mut region,
                                 &self.inputs,
                                 Box::new(PolyOp::Conv {
-                                    padding: [(1, 1); 2],
-                                    stride: (2, 2),
+                                    padding: vec![(1, 1); 2],
+                                    stride: vec![2; 2],
                                 }),
                             )
                             .map_err(|_| Error::Synthesis)
@@ -1198,8 +1198,8 @@ mod conv_col_ultra_overflow {
                                 &mut region,
                                 &[self.image.clone(), self.kernel.clone()],
                                 Box::new(PolyOp::Conv {
-                                    padding: [(1, 1); 2],
-                                    stride: (2, 2),
+                                    padding: vec![(1, 1); 2],
+                                    stride: vec![2; 2],
                                 }),
                             )
                             .map_err(|_| Error::Synthesis)
@@ -1343,8 +1343,8 @@ mod conv_relu_col_ultra_overflow {
                                 &mut region,
                                 &[self.image.clone(), self.kernel.clone()],
                                 Box::new(PolyOp::Conv {
-                                    padding: [(1, 1); 2],
-                                    stride: (2, 2),
+                                    padding: vec![(1, 1); 2],
+                                    stride: vec![2; 2],
                                 }),
                             )
                             .map_err(|_| Error::Synthesis);

src/commands.rs

@@ -290,7 +290,7 @@ pub enum Commands {
     Table {
         /// The path to the .onnx model file
         #[arg(short = 'M', long, default_value = DEFAULT_MODEL)]
-        model: PathBuf,
+        model: Option<PathBuf>,
         /// proving arguments
         #[clap(flatten)]
         args: RunArgs,
@@ -300,13 +300,13 @@ pub enum Commands {
     GenWitness {
         /// The path to the .json data file
         #[arg(short = 'D', long, default_value = DEFAULT_DATA)]
-        data: PathBuf,
+        data: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT)]
-        compiled_circuit: PathBuf,
+        compiled_circuit: Option<PathBuf>,
         /// Path to output the witness .json file
         #[arg(short = 'O', long, default_value = DEFAULT_WITNESS)]
-        output: PathBuf,
+        output: Option<PathBuf>,
         /// Path to the verification key file (optional - solely used to generate kzg commits)
         #[arg(short = 'V', long)]
         vk_path: Option<PathBuf>,
@@ -319,10 +319,10 @@ pub enum Commands {
     GenSettings {
         /// The path to the .onnx model file
         #[arg(short = 'M', long, default_value = DEFAULT_MODEL)]
-        model: PathBuf,
+        model: Option<PathBuf>,
         /// The path to generate the circuit settings .json file to
         #[arg(short = 'O', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         /// proving arguments
         #[clap(flatten)]
         args: RunArgs,
@@ -333,19 +333,19 @@ pub enum Commands {
     CalibrateSettings {
         /// The path to the .json calibration data file.
         #[arg(short = 'D', long, default_value = DEFAULT_CALIBRATION_FILE)]
-        data: PathBuf,
+        data: Option<PathBuf>,
         /// The path to the .onnx model file
         #[arg(short = 'M', long, default_value = DEFAULT_MODEL)]
-        model: PathBuf,
+        model: Option<PathBuf>,
         /// The path to load circuit settings .json file AND overwrite (generated using the gen-settings command).
         #[arg(short = 'O', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         #[arg(long = "target", default_value = DEFAULT_CALIBRATION_TARGET)]
         /// Target for calibration. Set to "resources" to optimize for computational resource. Otherwise, set to "accuracy" to optimize for accuracy.
         target: CalibrationTarget,
         /// 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
         #[arg(long, default_value = DEFAULT_LOOKUP_SAFETY_MARGIN)]
-        lookup_safety_margin: i128,
+        lookup_safety_margin: i64,
         /// Optional scales to specifically try for calibration. Example, --scales 0,4
         #[arg(long, value_delimiter = ',', allow_hyphen_values = true)]
         scales: Option<Vec<crate::Scale>>,
@@ -361,8 +361,8 @@ pub enum Commands {
         #[arg(long)]
         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)]
-        only_range_check_rebase: bool,
+        #[arg(long, default_value = DEFAULT_ONLY_RANGE_CHECK_REBASE, action = clap::ArgAction::SetTrue)]
+        only_range_check_rebase: Option<bool>,
     },
 
     /// Generates a dummy SRS
@@ -376,7 +376,7 @@ pub enum Commands {
         logrows: usize,
         /// commitment used
         #[arg(long, default_value = DEFAULT_COMMITMENT)]
-        commitment: Commitments,
+        commitment: Option<Commitments>,
     },
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -400,10 +400,10 @@ pub enum Commands {
     Mock {
         /// The path to the .json witness file (generated using the gen-witness command)
         #[arg(short = 'W', long, default_value = DEFAULT_WITNESS)]
-        witness: PathBuf,
+        witness: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT)]
-        model: PathBuf,
+        model: Option<PathBuf>,
     },
 
     /// Mock aggregate proofs
@@ -413,10 +413,10 @@ pub enum Commands {
         aggregation_snarks: Vec<PathBuf>,
         /// logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
-        logrows: u32,
+        logrows: Option<u32>,
         /// whether the accumulated are segments of a larger proof
-        #[arg(long, default_value = DEFAULT_SPLIT)]
-        split_proofs: bool,
+        #[arg(long, default_value = DEFAULT_SPLIT, action = clap::ArgAction::SetTrue)]
+        split_proofs: Option<bool>,
     },
 
     /// setup aggregation circuit :)
@@ -426,25 +426,25 @@ pub enum Commands {
         sample_snarks: Vec<PathBuf>,
         /// The path to save the desired verification key file to
         #[arg(long, default_value = DEFAULT_VK_AGGREGATED)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// The path to save the proving key to
         #[arg(long, default_value = DEFAULT_PK_AGGREGATED)]
-        pk_path: PathBuf,
+        pk_path: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
         /// logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
-        logrows: u32,
+        logrows: Option<u32>,
         /// whether the accumulated are segments of a larger proof
-        #[arg(long, default_value = DEFAULT_SPLIT)]
-        split_proofs: bool,
+        #[arg(long, default_value = DEFAULT_SPLIT, action = clap::ArgAction::SetTrue)]
+        split_proofs: Option<bool>,
         /// compress selectors
-        #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION)]
-        disable_selector_compression: bool,
+        #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION, action = clap::ArgAction::SetTrue)]
+        disable_selector_compression: Option<bool>,
         /// commitment used
         #[arg(long, default_value = DEFAULT_COMMITMENT)]
-        commitment: Commitments,
+        commitment: Option<Commitments>,
     },
     /// Aggregates proofs :)
     Aggregate {
@@ -453,10 +453,10 @@ pub enum Commands {
         aggregation_snarks: Vec<PathBuf>,
         /// The path to load the desired proving key file (generated using the setup-aggregate command)
         #[arg(long, default_value = DEFAULT_PK_AGGREGATED)]
-        pk_path: PathBuf,
+        pk_path: Option<PathBuf>,
         /// The path to output the proof file to
         #[arg(long, default_value = DEFAULT_PROOF_AGGREGATED)]
-        proof_path: PathBuf,
+        proof_path: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
@@ -470,49 +470,49 @@ pub enum Commands {
         transcript: TranscriptType,
         /// logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
-        logrows: u32,
+        logrows: Option<u32>,
         /// run sanity checks during calculations (safe or unsafe)
         #[arg(long, default_value = DEFAULT_CHECKMODE)]
-        check_mode: CheckMode,
+        check_mode: Option<CheckMode>,
         /// whether the accumulated proofs are segments of a larger circuit
-        #[arg(long, default_value = DEFAULT_SPLIT)]
-        split_proofs: bool,
+        #[arg(long, default_value = DEFAULT_SPLIT, action = clap::ArgAction::SetTrue)]
+        split_proofs: Option<bool>,
         /// commitment used
         #[arg(long, default_value = DEFAULT_COMMITMENT)]
-        commitment: Commitments,
+        commitment: Option<Commitments>,
     },
     /// Compiles a circuit from onnx to a simplified graph (einsum + other ops) and parameters as sets of field elements
     CompileCircuit {
         /// The path to the .onnx model file
         #[arg(short = 'M', long, default_value = DEFAULT_MODEL)]
-        model: PathBuf,
+        model: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(long, default_value = DEFAULT_COMPILED_CIRCUIT)]
-        compiled_circuit: PathBuf,
+        compiled_circuit: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
     },
     /// Creates pk and vk
     Setup {
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT)]
-        compiled_circuit: PathBuf,
+        compiled_circuit: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
         /// The path to output the verification key file to
         #[arg(long, default_value = DEFAULT_VK)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// The path to output the proving key file to
         #[arg(long, default_value = DEFAULT_PK)]
-        pk_path: PathBuf,
+        pk_path: Option<PathBuf>,
         /// The graph witness (optional - used to override fixed values in the circuit)
         #[arg(short = 'W', long)]
         witness: Option<PathBuf>,
         /// compress selectors
-        #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION)]
-        disable_selector_compression: bool,
+        #[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
@@ -520,10 +520,10 @@ pub enum Commands {
     SetupTestEvmData {
         /// The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
         #[arg(short = 'D', long)]
-        data: PathBuf,
+        data: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long)]
-        compiled_circuit: PathBuf,
+        compiled_circuit: Option<PathBuf>,
         /// 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)
@@ -548,7 +548,7 @@ pub enum Commands {
         addr: H160Flag,
         /// The path to the .json data file.
         #[arg(short = 'D', long)]
-        data: PathBuf,
+        data: Option<PathBuf>,
         /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
         #[arg(short = 'U', long)]
         rpc_url: Option<String>,
@@ -558,10 +558,10 @@ pub enum Commands {
     SwapProofCommitments {
         /// The path to the proof file
         #[arg(short = 'P', long, default_value = DEFAULT_PROOF)]
-        proof_path: PathBuf,
+        proof_path: Option<PathBuf>,
         /// The path to the witness file
         #[arg(short = 'W', long, default_value = DEFAULT_WITNESS)]
-        witness_path: PathBuf,
+        witness_path: Option<PathBuf>,
     },
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -569,16 +569,16 @@ pub enum Commands {
     Prove {
         /// The path to the .json witness file (generated using the gen-witness command)
         #[arg(short = 'W', long, default_value = DEFAULT_WITNESS)]
-        witness: PathBuf,
+        witness: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT)]
-        compiled_circuit: PathBuf,
+        compiled_circuit: Option<PathBuf>,
         /// The path to load the desired proving key file (generated using the setup command)
         #[arg(long, default_value = DEFAULT_PK)]
-        pk_path: PathBuf,
+        pk_path: Option<PathBuf>,
         /// The path to output the proof file to
         #[arg(long, default_value = DEFAULT_PROOF)]
-        proof_path: PathBuf,
+        proof_path: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
@@ -592,7 +592,7 @@ pub enum Commands {
         proof_type: ProofType,
         /// run sanity checks during calculations (safe or unsafe)
         #[arg(long, default_value = DEFAULT_CHECKMODE)]
-        check_mode: CheckMode,
+        check_mode: Option<CheckMode>,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Creates an Evm verifier for a single proof
@@ -603,21 +603,21 @@ pub enum Commands {
         srs_path: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         /// The path to load the desired verification key file
         #[arg(long, default_value = DEFAULT_VK)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// The path to output the Solidity code
         #[arg(long, default_value = DEFAULT_SOL_CODE)]
-        sol_code_path: PathBuf,
+        sol_code_path: Option<PathBuf>,
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VERIFIER_ABI)]
-        abi_path: PathBuf,
+        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)]
-        render_vk_seperately: bool,
+        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY, action = clap::ArgAction::SetTrue)]
+        render_vk_seperately: Option<bool>,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Creates an Evm verifier for a single proof
@@ -628,16 +628,16 @@ pub enum Commands {
         srs_path: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         /// The path to load the desired verification key file
         #[arg(long, default_value = DEFAULT_VK)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// The path to output the Solidity code
         #[arg(long, default_value = DEFAULT_VK_SOL)]
-        sol_code_path: PathBuf,
+        sol_code_path: Option<PathBuf>,
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VK_ABI)]
-        abi_path: PathBuf,
+        abi_path: Option<PathBuf>,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Creates an Evm verifier that attests to on-chain inputs for a single proof
@@ -645,20 +645,20 @@ pub enum Commands {
     CreateEvmDataAttestation {
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         /// The path to output the Solidity code
         #[arg(long, default_value = DEFAULT_SOL_CODE_DA)]
-        sol_code_path: PathBuf,
+        sol_code_path: Option<PathBuf>,
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VERIFIER_DA_ABI)]
-        abi_path: PathBuf,
+        abi_path: Option<PathBuf>,
         /// 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.
         #[arg(short = 'D', long, default_value = DEFAULT_DATA)]
-        data: PathBuf,
+        data: Option<PathBuf>,
     },
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -670,76 +670,76 @@ pub enum Commands {
         srs_path: Option<PathBuf>,
         /// The path to load the desired verification key file
         #[arg(long, default_value = DEFAULT_VK_AGGREGATED)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// The path to the Solidity code
         #[arg(long, default_value = DEFAULT_SOL_CODE_AGGREGATED)]
-        sol_code_path: PathBuf,
+        sol_code_path: Option<PathBuf>,
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VERIFIER_AGGREGATED_ABI)]
-        abi_path: PathBuf,
+        abi_path: Option<PathBuf>,
         // aggregated circuit settings paths, used to calculate the number of instances in the aggregate proof
         #[arg(long, default_value = DEFAULT_SETTINGS, value_delimiter = ',', allow_hyphen_values = true)]
         aggregation_settings: Vec<PathBuf>,
         // logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
-        logrows: u32,
+        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)]
-        render_vk_seperately: bool,
+        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY, action = clap::ArgAction::SetTrue)]
+        render_vk_seperately: Option<bool>,
     },
     /// Verifies a proof, returning accept or reject
     Verify {
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         /// The path to the proof file (generated using the prove command)
         #[arg(long, default_value = DEFAULT_PROOF)]
-        proof_path: PathBuf,
+        proof_path: Option<PathBuf>,
         /// The path to the verification key file (generated using the setup command)
         #[arg(long, default_value = DEFAULT_VK)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
         /// Reduce SRS logrows to the number of instances rather than the number of logrows used for proofs (only works if the srs were generated in the same ceremony)
-        #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION)]
-        reduced_srs: bool,
+        #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION, action = clap::ArgAction::SetTrue)]
+        reduced_srs: Option<bool>,
     },
     /// Verifies an aggregate proof, returning accept or reject
     VerifyAggr {
         /// The path to the proof file (generated using the prove command)
         #[arg(long, default_value = DEFAULT_PROOF_AGGREGATED)]
-        proof_path: PathBuf,
+        proof_path: Option<PathBuf>,
         /// The path to the verification key file (generated using the setup-aggregate command)
         #[arg(long, default_value = DEFAULT_VK_AGGREGATED)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// reduced srs
-        #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION)]
-        reduced_srs: bool,
+        #[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
         #[arg(long)]
         srs_path: Option<PathBuf>,
         /// logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
-        logrows: u32,
+        logrows: Option<u32>,
         /// commitment
         #[arg(long, default_value = DEFAULT_COMMITMENT)]
-        commitment: Commitments,
+        commitment: Option<Commitments>,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Deploys an evm verifier that is generated by ezkl
     DeployEvmVerifier {
         /// The path to the Solidity code (generated using the create-evm-verifier command)
         #[arg(long, default_value = DEFAULT_SOL_CODE)]
-        sol_code_path: PathBuf,
+        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)]
         rpc_url: Option<String>,
         #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS)]
         /// The path to output the contract address
-        addr_path: PathBuf,
+        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)]
         optimizer_runs: usize,
@@ -752,13 +752,13 @@ pub enum Commands {
     DeployEvmVK {
         /// The path to the Solidity code (generated using the create-evm-verifier command)
         #[arg(long, default_value = DEFAULT_VK_SOL)]
-        sol_code_path: PathBuf,
+        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)]
         rpc_url: Option<String>,
         #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_VK)]
         /// The path to output the contract address
-        addr_path: PathBuf,
+        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)]
         optimizer_runs: usize,
@@ -772,19 +772,19 @@ pub enum Commands {
     DeployEvmDataAttestation {
         /// The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
         #[arg(short = 'D', long, default_value = DEFAULT_DATA)]
-        data: PathBuf,
+        data: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         /// The path to the Solidity code
         #[arg(long, default_value = DEFAULT_SOL_CODE_DA)]
-        sol_code_path: PathBuf,
+        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)]
         rpc_url: Option<String>,
         #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_DA)]
         /// The path to output the contract address
-        addr_path: PathBuf,
+        addr_path: Option<PathBuf>,
         /// The optimizer runs to set on the verifier. (Lower values optimize for deployment, while higher values optimize for execution)
         #[arg(long, default_value = DEFAULT_OPTIMIZER_RUNS)]
         optimizer_runs: usize,
@@ -798,7 +798,7 @@ pub enum Commands {
     VerifyEvm {
         /// The path to the proof file (generated using the prove command)
         #[arg(long, default_value = DEFAULT_PROOF)]
-        proof_path: PathBuf,
+        proof_path: Option<PathBuf>,
         /// The path to verifier contract's address
         #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS)]
         addr_verifier: H160Flag,

src/eth.rs

@@ -424,7 +424,7 @@ pub async fn setup_test_contract<M: 'static + Middleware>(
             let input = input.to_float() as f32;
             let decimal_places = count_decimal_places(input) as u8;
             let scaled_by_decimals = input * f32::powf(10., decimal_places.into());
-            scaled_by_decimals_data.push(I256::from(scaled_by_decimals as i128));
+            scaled_by_decimals_data.push(I256::from(scaled_by_decimals as i64));
             decimals.push(decimal_places);
         } else if input.is_field() {
             let input = input.to_field(0);

src/execute.rs

@@ -1,9 +1,7 @@
 use crate::circuit::CheckMode;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::commands::CalibrationTarget;
-use crate::commands::Commands;
-#[cfg(not(target_arch = "wasm32"))]
-use crate::commands::H160Flag;
+use crate::commands::*;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::eth::{deploy_contract_via_solidity, deploy_da_verifier_via_solidity};
 #[cfg(not(target_arch = "wasm32"))]
@@ -71,6 +69,7 @@ use std::path::Path;
 use std::path::PathBuf;
 #[cfg(not(target_arch = "wasm32"))]
 use std::process::Command;
+use std::str::FromStr;
 #[cfg(not(target_arch = "wasm32"))]
 use std::sync::OnceLock;
 
@@ -152,7 +151,11 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             srs_path,
             logrows,
             commitment,
-        } => gen_srs_cmd(srs_path, logrows as u32, commitment),
+        } => gen_srs_cmd(
+            srs_path,
+            logrows as u32,
+            commitment.unwrap_or(Commitments::from_str(DEFAULT_COMMITMENT)?),
+        ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::GetSrs {
             srs_path,
@@ -160,12 +163,16 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             logrows,
             commitment,
         } => get_srs_cmd(srs_path, settings_path, logrows, commitment).await,
-        Commands::Table { model, args } => table(model, args),
+        Commands::Table { model, args } => table(model.unwrap_or(DEFAULT_MODEL.into()), args),
         Commands::GenSettings {
             model,
             settings_path,
             args,
-        } => gen_circuit_settings(model, settings_path, args),
+        } => gen_circuit_settings(
+            model.unwrap_or(DEFAULT_MODEL.into()),
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+            args,
+        ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::CalibrateSettings {
             model,
@@ -178,14 +185,14 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             max_logrows,
             only_range_check_rebase,
         } => calibrate(
-            model,
-            data,
-            settings_path,
+            model.unwrap_or(DEFAULT_MODEL.into()),
+            data.unwrap_or(DEFAULT_DATA.into()),
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
             target,
             lookup_safety_margin,
             scales,
             scale_rebase_multiplier,
-            only_range_check_rebase,
+            only_range_check_rebase.unwrap_or(DEFAULT_ONLY_RANGE_CHECK_REBASE.parse()?),
             max_logrows,
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
@@ -195,10 +202,18 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             output,
             vk_path,
             srs_path,
-        } => gen_witness(compiled_circuit, data, Some(output), vk_path, srs_path)
-            .await
-            .map(|e| serde_json::to_string(&e).unwrap()),
-        Commands::Mock { model, witness } => mock(model, witness),
+        } => gen_witness(
+            compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
+            data.unwrap_or(DEFAULT_DATA.into()),
+            Some(output.unwrap_or(DEFAULT_WITNESS.into())),
+            vk_path,
+            srs_path,
+        )
+        .map(|e| serde_json::to_string(&e).unwrap()),
+        Commands::Mock { model, witness } => mock(
+            model.unwrap_or(DEFAULT_MODEL.into()),
+            witness.unwrap_or(DEFAULT_WITNESS.into()),
+        ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::CreateEvmVerifier {
             vk_path,
@@ -208,12 +223,12 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             abi_path,
             render_vk_seperately,
         } => create_evm_verifier(
-            vk_path,
+            vk_path.unwrap_or(DEFAULT_VK.into()),
             srs_path,
-            settings_path,
-            sol_code_path,
-            abi_path,
-            render_vk_seperately,
+            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()?),
         ),
         Commands::CreateEvmVK {
             vk_path,
@@ -221,14 +236,25 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             settings_path,
             sol_code_path,
             abi_path,
-        } => create_evm_vk(vk_path, srs_path, settings_path, sol_code_path, abi_path),
+        } => create_evm_vk(
+            vk_path.unwrap_or(DEFAULT_VK.into()),
+            srs_path,
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+            sol_code_path.unwrap_or(DEFAULT_VK_SOL.into()),
+            abi_path.unwrap_or(DEFAULT_VK_ABI.into()),
+        ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::CreateEvmDataAttestation {
             settings_path,
             sol_code_path,
             abi_path,
             data,
-        } => create_evm_data_attestation(settings_path, sol_code_path, abi_path, data),
+        } => create_evm_data_attestation(
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+            sol_code_path.unwrap_or(DEFAULT_SOL_CODE_DA.into()),
+            abi_path.unwrap_or(DEFAULT_VERIFIER_DA_ABI.into()),
+            data.unwrap_or(DEFAULT_DATA.into()),
+        ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::CreateEvmVerifierAggr {
             vk_path,
@@ -239,19 +265,23 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             logrows,
             render_vk_seperately,
         } => create_evm_aggregate_verifier(
-            vk_path,
+            vk_path.unwrap_or(DEFAULT_VK.into()),
             srs_path,
-            sol_code_path,
-            abi_path,
+            sol_code_path.unwrap_or(DEFAULT_SOL_CODE_AGGREGATED.into()),
+            abi_path.unwrap_or(DEFAULT_VERIFIER_AGGREGATED_ABI.into()),
             aggregation_settings,
-            logrows,
-            render_vk_seperately,
+            logrows.unwrap_or(DEFAULT_AGGREGATED_LOGROWS.parse()?),
+            render_vk_seperately.unwrap_or(DEFAULT_RENDER_VK_SEPERATELY.parse()?),
         ),
         Commands::CompileCircuit {
             model,
             compiled_circuit,
             settings_path,
-        } => compile_circuit(model, compiled_circuit, settings_path),
+        } => compile_circuit(
+            model.unwrap_or(DEFAULT_MODEL.into()),
+            compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+        ),
         Commands::Setup {
             compiled_circuit,
             srs_path,
@@ -260,12 +290,12 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             witness,
             disable_selector_compression,
         } => setup(
-            compiled_circuit,
+            compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
             srs_path,
-            vk_path,
-            pk_path,
+            vk_path.unwrap_or(DEFAULT_VK.into()),
+            pk_path.unwrap_or(DEFAULT_PK.into()),
             witness,
-            disable_selector_compression,
+            disable_selector_compression.unwrap_or(DEFAULT_DISABLE_SELECTOR_COMPRESSION.parse()?),
         ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::SetupTestEvmData {
@@ -277,8 +307,8 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             output_source,
         } => {
             setup_test_evm_witness(
-                data,
-                compiled_circuit,
+                data.unwrap_or(DEFAULT_DATA.into()),
+                compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
                 test_data,
                 rpc_url,
                 input_source,
@@ -291,13 +321,17 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             addr,
             data,
             rpc_url,
-        } => test_update_account_calls(addr, data, rpc_url).await,
+        } => 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,
-        } => swap_proof_commitments_cmd(proof_path, witness_path)
-            .map(|e| serde_json::to_string(&e).unwrap()),
+        } => swap_proof_commitments_cmd(
+            proof_path.unwrap_or(DEFAULT_PROOF.into()),
+            witness_path.unwrap_or(DEFAULT_WITNESS.into()),
+        )
+        .map(|e| serde_json::to_string(&e).unwrap()),
+
         #[cfg(not(target_arch = "wasm32"))]
         Commands::Prove {
             witness,
@@ -308,20 +342,24 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             proof_type,
             check_mode,
         } => prove(
-            witness,
-            compiled_circuit,
-            pk_path,
-            Some(proof_path),
+            witness.unwrap_or(DEFAULT_WITNESS.into()),
+            compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
+            pk_path.unwrap_or(DEFAULT_PK.into()),
+            Some(proof_path.unwrap_or(DEFAULT_PROOF.into())),
             srs_path,
             proof_type,
-            check_mode,
+            check_mode.unwrap_or(DEFAULT_CHECKMODE.parse()?),
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
         Commands::MockAggregate {
             aggregation_snarks,
             logrows,
             split_proofs,
-        } => mock_aggregate(aggregation_snarks, logrows, split_proofs),
+        } => mock_aggregate(
+            aggregation_snarks,
+            logrows.unwrap_or(DEFAULT_AGGREGATED_LOGROWS.parse()?),
+            split_proofs.unwrap_or(DEFAULT_SPLIT.parse()?),
+        ),
         Commands::SetupAggregate {
             sample_snarks,
             vk_path,
@@ -333,13 +371,13 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             commitment,
         } => setup_aggregate(
             sample_snarks,
-            vk_path,
-            pk_path,
+            vk_path.unwrap_or(DEFAULT_VK_AGGREGATED.into()),
+            pk_path.unwrap_or(DEFAULT_PK_AGGREGATED.into()),
             srs_path,
-            logrows,
-            split_proofs,
-            disable_selector_compression,
-            commitment,
+            logrows.unwrap_or(DEFAULT_AGGREGATED_LOGROWS.parse()?),
+            split_proofs.unwrap_or(DEFAULT_SPLIT.parse()?),
+            disable_selector_compression.unwrap_or(DEFAULT_DISABLE_SELECTOR_COMPRESSION.parse()?),
+            commitment.into(),
         ),
         Commands::Aggregate {
             proof_path,
@@ -352,15 +390,15 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             split_proofs,
             commitment,
         } => aggregate(
-            proof_path,
+            proof_path.unwrap_or(DEFAULT_PROOF_AGGREGATED.into()),
             aggregation_snarks,
-            pk_path,
+            pk_path.unwrap_or(DEFAULT_PK_AGGREGATED.into()),
             srs_path,
             transcript,
-            logrows,
-            check_mode,
-            split_proofs,
-            commitment,
+            logrows.unwrap_or(DEFAULT_AGGREGATED_LOGROWS.parse()?),
+            check_mode.unwrap_or(DEFAULT_CHECKMODE.parse()?),
+            split_proofs.unwrap_or(DEFAULT_SPLIT.parse()?),
+            commitment.into(),
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
         Commands::Verify {
@@ -369,8 +407,14 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             vk_path,
             srs_path,
             reduced_srs,
-        } => verify(proof_path, settings_path, vk_path, srs_path, reduced_srs)
-            .map(|e| serde_json::to_string(&e).unwrap()),
+        } => verify(
+            proof_path.unwrap_or(DEFAULT_PROOF.into()),
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+            vk_path.unwrap_or(DEFAULT_VK.into()),
+            srs_path,
+            reduced_srs.unwrap_or(DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION.parse()?),
+        )
+        .map(|e| serde_json::to_string(&e).unwrap()),
         Commands::VerifyAggr {
             proof_path,
             vk_path,
@@ -379,12 +423,12 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             logrows,
             commitment,
         } => verify_aggr(
-            proof_path,
-            vk_path,
+            proof_path.unwrap_or(DEFAULT_PROOF_AGGREGATED.into()),
+            vk_path.unwrap_or(DEFAULT_VK_AGGREGATED.into()),
             srs_path,
-            logrows,
-            reduced_srs,
-            commitment,
+            logrows.unwrap_or(DEFAULT_AGGREGATED_LOGROWS.parse()?),
+            reduced_srs.unwrap_or(DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION.parse()?),
+            commitment.into(),
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
         #[cfg(not(target_arch = "wasm32"))]
@@ -396,9 +440,9 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             private_key,
         } => {
             deploy_evm(
-                sol_code_path,
+                sol_code_path.unwrap_or(DEFAULT_SOL_CODE.into()),
                 rpc_url,
-                addr_path,
+                addr_path.unwrap_or(DEFAULT_CONTRACT_ADDRESS.into()),
                 optimizer_runs,
                 private_key,
                 "Halo2Verifier",
@@ -414,9 +458,9 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             private_key,
         } => {
             deploy_evm(
-                sol_code_path,
+                sol_code_path.unwrap_or(DEFAULT_VK_SOL.into()),
                 rpc_url,
-                addr_path,
+                addr_path.unwrap_or(DEFAULT_CONTRACT_ADDRESS_VK.into()),
                 optimizer_runs,
                 private_key,
                 "Halo2VerifyingKey",
@@ -434,11 +478,11 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             private_key,
         } => {
             deploy_da_evm(
-                data,
-                settings_path,
-                sol_code_path,
+                data.unwrap_or(DEFAULT_DATA.into()),
+                settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+                sol_code_path.unwrap_or(DEFAULT_SOL_CODE_DA.into()),
                 rpc_url,
-                addr_path,
+                addr_path.unwrap_or(DEFAULT_CONTRACT_ADDRESS_DA.into()),
                 optimizer_runs,
                 private_key,
             )
@@ -451,7 +495,16 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             rpc_url,
             addr_da,
             addr_vk,
-        } => verify_evm(proof_path, addr_verifier, rpc_url, addr_da, addr_vk).await,
+        } => {
+            verify_evm(
+                proof_path.unwrap_or(DEFAULT_PROOF.into()),
+                addr_verifier,
+                rpc_url,
+                addr_da,
+                addr_vk,
+            )
+            .await
+        }
     }
 }
 
@@ -586,7 +639,7 @@ pub(crate) async fn get_srs_cmd(
     } else if let Some(settings_p) = settings_path {
         if settings_p.exists() {
             let settings = GraphSettings::load(&settings_p)?;
-            settings.run_args.commitment
+            settings.run_args.commitment.into()
         } else {
             return Err(err_string.into());
         }
@@ -637,7 +690,7 @@ pub(crate) fn table(model: PathBuf, run_args: RunArgs) -> Result<String, Box<dyn
     Ok(String::new())
 }
 
-pub(crate) async fn gen_witness(
+pub(crate) fn gen_witness(
     compiled_circuit_path: PathBuf,
     data: PathBuf,
     output: Option<PathBuf>,
@@ -660,33 +713,30 @@ pub(crate) async fn gen_witness(
     };
 
     #[cfg(not(target_arch = "wasm32"))]
-    let mut input = circuit.load_graph_input(&data).await?;
+    let mut input = circuit.load_graph_input(&data)?;
     #[cfg(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 start_time = Instant::now();
     let witness = if settings.module_requires_polycommit() {
-        if get_srs_path(
-            settings.run_args.logrows,
-            srs_path.clone(),
-            settings.run_args.commitment,
-        )
-        .exists()
-        {
-            match settings.run_args.commitment {
+        if get_srs_path(settings.run_args.logrows, srs_path.clone(), commitment).exists() {
+            match Commitments::from(settings.run_args.commitment) {
                 Commitments::KZG => {
                     let srs: ParamsKZG<Bn256> = load_params_prover::<KZGCommitmentScheme<Bn256>>(
                         srs_path.clone(),
                         settings.run_args.logrows,
-                        settings.run_args.commitment,
+                        commitment,
                     )?;
                     circuit.forward::<KZGCommitmentScheme<_>>(
                         &mut input,
                         vk.as_ref(),
                         Some(&srs),
                         true,
+                        true,
                     )?
                 }
                 Commitments::IPA => {
@@ -694,22 +744,29 @@ pub(crate) async fn gen_witness(
                         load_params_prover::<IPACommitmentScheme<G1Affine>>(
                             srs_path.clone(),
                             settings.run_args.logrows,
-                            settings.run_args.commitment,
+                            commitment,
                         )?;
                     circuit.forward::<IPACommitmentScheme<_>>(
                         &mut input,
                         vk.as_ref(),
                         Some(&srs),
                         true,
+                        true,
                     )?
                 }
             }
         } else {
             warn!("SRS for poly commit does not exist (will be ignored)");
-            circuit.forward::<KZGCommitmentScheme<Bn256>>(&mut input, vk.as_ref(), None, true)?
+            circuit.forward::<KZGCommitmentScheme<Bn256>>(
+                &mut input,
+                vk.as_ref(),
+                None,
+                true,
+                true,
+            )?
         }
     } else {
-        circuit.forward::<KZGCommitmentScheme<Bn256>>(&mut input, vk.as_ref(), None, true)?
+        circuit.forward::<KZGCommitmentScheme<Bn256>>(&mut input, vk.as_ref(), None, true, true)?
     };
 
     // print each variable tuple (symbol, value) as symbol=value
@@ -892,7 +949,7 @@ pub(crate) fn calibrate(
     data: PathBuf,
     settings_path: PathBuf,
     target: CalibrationTarget,
-    lookup_safety_margin: i128,
+    lookup_safety_margin: i64,
     scales: Option<Vec<crate::Scale>>,
     scale_rebase_multiplier: Vec<u32>,
     only_range_check_rebase: bool,
@@ -1008,6 +1065,7 @@ pub(crate) fn calibrate(
             param_scale,
             scale_rebase_multiplier,
             div_rebasing,
+            lookup_range: (i64::MIN, i64::MAX),
             ..settings.run_args.clone()
         };
 
@@ -1043,7 +1101,13 @@ pub(crate) fn calibrate(
                     .map_err(|e| format!("failed to load circuit inputs: {}", e))?;
 
                 let forward_res = circuit
-                    .forward::<KZGCommitmentScheme<Bn256>>(&mut data.clone(), None, None, true)
+                    .forward::<KZGCommitmentScheme<Bn256>>(
+                        &mut data.clone(),
+                        None,
+                        None,
+                        true,
+                        false,
+                    )
                     .map_err(|e| format!("failed to forward: {}", e))?;
 
                 // push result to the hashmap
@@ -1058,7 +1122,7 @@ pub(crate) fn calibrate(
 
         match forward_res {
             Ok(_) => (),
-            // typically errors will be due to the circuit overflowing the i128 limit
+            // typically errors will be due to the circuit overflowing the i64 limit
             Err(e) => {
                 error!("forward pass failed: {:?}", e);
                 pb.inc(1);
@@ -1233,22 +1297,14 @@ pub(crate) fn calibrate(
     );
 
     if matches!(target, CalibrationTarget::Resources { col_overflow: true }) {
-        let lookup_log_rows = ((best_params.run_args.lookup_range.1
-            - best_params.run_args.lookup_range.0) as f32)
-            .log2()
-            .ceil() as u32
-            + 1;
-        let mut reduction = std::cmp::max(
-            (best_params
-                .model_instance_shapes
-                .iter()
-                .map(|x| x.iter().product::<usize>())
-                .sum::<usize>() as f32)
-                .log2()
-                .ceil() as u32
-                + 1,
-            lookup_log_rows,
-        );
+        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 mut reduction = std::cmp::max(lookup_log_rows, module_log_row);
+        reduction = std::cmp::max(reduction, instance_logrows);
+        reduction = std::cmp::max(reduction, dynamic_lookup_logrows);
         reduction = std::cmp::max(reduction, crate::graph::MIN_LOGROWS);
 
         info!(
@@ -1303,17 +1359,19 @@ pub(crate) fn create_evm_verifier(
     render_vk_seperately: bool,
 ) -> Result<String, Box<dyn Error>> {
     check_solc_requirement();
-    let circuit_settings = GraphSettings::load(&settings_path)?;
+
+    let settings = GraphSettings::load(&settings_path)?;
+    let commitment: Commitments = settings.run_args.commitment.into();
     let params = load_params_verifier::<KZGCommitmentScheme<Bn256>>(
         srs_path,
-        circuit_settings.run_args.logrows,
-        circuit_settings.run_args.commitment,
+        settings.run_args.logrows,
+        commitment,
     )?;
 
-    let num_instance = circuit_settings.total_instances();
+    let num_instance = settings.total_instances();
     let num_instance: usize = num_instance.iter().sum::<usize>();
 
-    let vk = load_vk::<KZGCommitmentScheme<Bn256>, GraphCircuit>(vk_path, circuit_settings)?;
+    let vk = load_vk::<KZGCommitmentScheme<Bn256>, GraphCircuit>(vk_path, settings)?;
     trace!("params computed");
 
     let generator = halo2_solidity_verifier::SolidityGenerator::new(
@@ -1347,17 +1405,18 @@ pub(crate) fn create_evm_vk(
     abi_path: PathBuf,
 ) -> Result<String, Box<dyn Error>> {
     check_solc_requirement();
-    let circuit_settings = GraphSettings::load(&settings_path)?;
+    let settings = GraphSettings::load(&settings_path)?;
+    let commitment: Commitments = settings.run_args.commitment.into();
     let params = load_params_verifier::<KZGCommitmentScheme<Bn256>>(
         srs_path,
-        circuit_settings.run_args.logrows,
-        circuit_settings.run_args.commitment,
+        settings.run_args.logrows,
+        commitment,
     )?;
 
-    let num_instance = circuit_settings.total_instances();
+    let num_instance = settings.total_instances();
     let num_instance: usize = num_instance.iter().sum::<usize>();
 
-    let vk = load_vk::<KZGCommitmentScheme<Bn256>, GraphCircuit>(vk_path, circuit_settings)?;
+    let vk = load_vk::<KZGCommitmentScheme<Bn256>, GraphCircuit>(vk_path, settings)?;
     trace!("params computed");
 
     let generator = halo2_solidity_verifier::SolidityGenerator::new(
@@ -1626,8 +1685,9 @@ pub(crate) fn setup(
     }
 
     let logrows = circuit.settings().run_args.logrows;
+    let commitment: Commitments = circuit.settings().run_args.commitment.into();
 
-    let pk = match circuit.settings().run_args.commitment {
+    let pk = match commitment {
         Commitments::KZG => {
             let params = load_params_prover::<KZGCommitmentScheme<Bn256>>(
                 srs_path,
@@ -1736,7 +1796,8 @@ pub(crate) fn prove(
     let transcript: TranscriptType = proof_type.into();
     let proof_split_commits: Option<ProofSplitCommit> = data.into();
 
-    let commitment = circuit_settings.run_args.commitment;
+    let commitment = circuit_settings.run_args.commitment.into();
+    let logrows = circuit_settings.run_args.logrows;
     // creates and verifies the proof
     let mut snark = match commitment {
         Commitments::KZG => {
@@ -1745,7 +1806,7 @@ pub(crate) fn prove(
 
             let params = load_params_prover::<KZGCommitmentScheme<Bn256>>(
                 srs_path,
-                circuit_settings.run_args.logrows,
+                logrows,
                 Commitments::KZG,
             )?;
             match strategy {
@@ -2187,8 +2248,9 @@ pub(crate) fn verify(
     let circuit_settings = GraphSettings::load(&settings_path)?;
 
     let logrows = circuit_settings.run_args.logrows;
+    let commitment = circuit_settings.run_args.commitment.into();
 
-    match circuit_settings.run_args.commitment {
+    match commitment {
         Commitments::KZG => {
             let proof = Snark::load::<KZGCommitmentScheme<Bn256>>(&proof_path)?;
             let params: ParamsKZG<Bn256> = if reduced_srs {

src/fieldutils.rs

@@ -11,8 +11,8 @@ pub fn i32_to_felt<F: PrimeField>(x: i32) -> F {
     }
 }
 
-/// Converts an i128 to a PrimeField element.
-pub fn i128_to_felt<F: PrimeField>(x: i128) -> F {
+/// Converts an i64 to a PrimeField element.
+pub fn i64_to_felt<F: PrimeField>(x: i64) -> F {
     if x >= 0 {
         F::from_u128(x as u128)
     } else {
@@ -37,7 +37,7 @@ pub fn felt_to_i32<F: PrimeField + PartialOrd + Field>(x: F) -> 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(i128::MAX as u128) {
+    if x > F::from_u128(i64::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());
@@ -50,18 +50,18 @@ pub fn felt_to_f64<F: PrimeField + PartialOrd + Field>(x: F) -> f64 {
     }
 }
 
-/// Converts a PrimeField element to an i128.
-pub fn felt_to_i128<F: PrimeField + PartialOrd + Field>(x: F) -> i128 {
-    if x > F::from_u128(i128::MAX as u128) {
+/// 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) {
         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 i128)
+        -(lower_128 as i64)
     } 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 i128
+        lower_128 as i64
     }
 }
 
@@ -79,10 +79,10 @@ mod test {
         let res: F = i32_to_felt(2_i32.pow(17));
         assert_eq!(res, F::from(131072));
 
-        let res: F = i128_to_felt(-15i128);
+        let res: F = i64_to_felt(-15i64);
         assert_eq!(res, -F::from(15));
 
-        let res: F = i128_to_felt(2_i128.pow(17));
+        let res: F = i64_to_felt(2_i64.pow(17));
         assert_eq!(res, F::from(131072));
     }
 
@@ -96,10 +96,10 @@ mod test {
     }
 
     #[test]
-    fn felttoi128() {
-        for x in -(2i128.pow(20))..(2i128.pow(20)) {
-            let fieldx: F = i128_to_felt::<F>(x);
-            let xf: i128 = felt_to_i128::<F>(fieldx);
+    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);
             assert_eq!(x, xf);
         }
     }

src/graph/input.rs

@@ -1,7 +1,7 @@
 use super::quantize_float;
 use super::GraphError;
 use crate::circuit::InputType;
-use crate::fieldutils::i128_to_felt;
+use crate::fieldutils::i64_to_felt;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::tensor::Tensor;
 use crate::EZKL_BUF_CAPACITY;
@@ -21,8 +21,6 @@ use std::io::BufWriter;
 use std::io::Read;
 use std::panic::UnwindSafe;
 #[cfg(not(target_arch = "wasm32"))]
-use std::thread;
-#[cfg(not(target_arch = "wasm32"))]
 use tract_onnx::tract_core::{
     tract_data::{prelude::Tensor as TractTensor, TVec},
     value::TValue,
@@ -130,7 +128,7 @@ impl FileSourceInner {
     /// Convert to a field element
     pub fn to_field(&self, scale: crate::Scale) -> Fp {
         match self {
-            FileSourceInner::Float(f) => i128_to_felt(quantize_float(f, 0.0, scale).unwrap()),
+            FileSourceInner::Float(f) => i64_to_felt(quantize_float(f, 0.0, scale).unwrap()),
             FileSourceInner::Bool(f) => {
                 if *f {
                     Fp::one()
@@ -152,7 +150,7 @@ impl FileSourceInner {
                     0.0
                 }
             }
-            FileSourceInner::Field(f) => crate::fieldutils::felt_to_i128(*f) as f64,
+            FileSourceInner::Field(f) => crate::fieldutils::felt_to_i64(*f) as f64,
         }
     }
 }
@@ -234,21 +232,15 @@ impl PostgresSource {
             )
         };
 
-        let res: Vec<pg_bigdecimal::PgNumeric> = thread::spawn(move || {
-            let mut client = Client::connect(&config, NoTls).unwrap();
-            let mut res: Vec<pg_bigdecimal::PgNumeric> = Vec::new();
-            // extract rows from query
-            for row in client.query(&query, &[]).unwrap() {
-                // extract features from row
-                for i in 0..row.len() {
-                    res.push(row.get(i));
-                }
+        let mut client = Client::connect(&config, NoTls)?;
+        let mut res: Vec<pg_bigdecimal::PgNumeric> = Vec::new();
+        // extract rows from query
+        for row in client.query(&query, &[])? {
+            // extract features from row
+            for i in 0..row.len() {
+                res.push(row.get(i));
             }
-            res
-        })
-        .join()
-        .map_err(|_| "failed to fetch data from postgres")?;
-
+        }
         Ok(vec![res])
     }
 

src/graph/mod.rs

@@ -39,7 +39,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error as PlonkError},
 };
 use halo2curves::bn256::{self, Fr as Fp, G1Affine};
-use halo2curves::ff::PrimeField;
+use halo2curves::ff::{Field, PrimeField};
 #[cfg(not(target_arch = "wasm32"))]
 use lazy_static::lazy_static;
 use log::{debug, error, trace, warn};
@@ -62,13 +62,13 @@ pub use vars::*;
 use crate::pfsys::field_to_string;
 
 /// The safety factor for the range of the lookup table.
-pub const RANGE_MULTIPLIER: i128 = 2;
+pub const RANGE_MULTIPLIER: i64 = 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: i128 = (MAX_NUM_LOOKUP_COLS as i128) * 2_i128.pow(MAX_PUBLIC_SRS);
+pub const MAX_LOOKUP_ABS: i64 = (MAX_NUM_LOOKUP_COLS as i64) * 2_i64.pow(MAX_PUBLIC_SRS);
 
 #[cfg(not(target_arch = "wasm32"))]
 lazy_static! {
@@ -175,11 +175,11 @@ pub struct GraphWitness {
     /// Any hashes of outputs generated during the forward pass
     pub processed_outputs: Option<ModuleForwardResult>,
     /// max lookup input
-    pub max_lookup_inputs: i128,
+    pub max_lookup_inputs: i64,
     /// max lookup input
-    pub min_lookup_inputs: i128,
+    pub min_lookup_inputs: i64,
     /// max range check size
-    pub max_range_size: i128,
+    pub max_range_size: i64,
 }
 
 impl GraphWitness {
@@ -483,7 +483,22 @@ pub struct GraphSettings {
 }
 
 impl GraphSettings {
-    fn model_constraint_logrows(&self) -> u32 {
+    /// Calc the number of rows required for lookup tables
+    pub fn lookup_log_rows(&self) -> u32 {
+        ((self.run_args.lookup_range.1 - self.run_args.lookup_range.0) as f32)
+            .log2()
+            .ceil() as u32
+    }
+
+    /// Calc the number of rows required for lookup tables
+    pub fn lookup_log_rows_with_blinding(&self) -> u32 {
+        ((self.run_args.lookup_range.1 - self.run_args.lookup_range.0) as f32
+            + RESERVED_BLINDING_ROWS 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()
             .ceil() as u32
@@ -495,14 +510,31 @@ impl GraphSettings {
             .ceil() as u32
     }
 
+    /// calculate the number of rows required for the dynamic lookup and shuffle
+    pub fn dynamic_lookup_and_shuffle_logrows_with_blinding(&self) -> u32 {
+        (self.total_dynamic_col_size as f64
+            + self.total_shuffle_col_size 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
     }
 
-    fn module_constraint_logrows(&self) -> u32 {
+    /// calculate the number of rows required for the module constraints
+    pub fn module_constraint_logrows(&self) -> u32 {
         (self.module_sizes.max_constraints() as f64).log2().ceil() as u32
     }
 
+    /// calculate the number of rows required for the module constraints
+    pub fn module_constraint_logrows_with_blinding(&self) -> u32 {
+        (self.module_sizes.max_constraints() as f64 + RESERVED_BLINDING_ROWS as f64)
+            .log2()
+            .ceil() as u32
+    }
+
     fn constants_logrows(&self) -> u32 {
         (self.total_const_size as f64 / self.run_args.num_inner_cols as f64)
             .log2()
@@ -529,6 +561,14 @@ impl GraphSettings {
         std::cmp::max((sum as f64).log2().ceil() as u32, 1)
     }
 
+    /// calculate the log2 of the total number of instances
+    pub fn log2_total_instances_with_blinding(&self) -> u32 {
+        let sum = self.total_instances().iter().sum::<usize>() + RESERVED_BLINDING_ROWS;
+
+        // max between 1 and the log2 of the sums
+        std::cmp::max((sum as f64).log2().ceil() as u32, 1)
+    }
+
     /// save params to file
     pub fn save(&self, path: &std::path::PathBuf) -> Result<(), std::io::Error> {
         // buf writer
@@ -918,7 +958,7 @@ impl GraphCircuit {
 
     ///
     #[cfg(not(target_arch = "wasm32"))]
-    pub async fn load_graph_input(
+    pub fn load_graph_input(
         &mut self,
         data: &GraphData,
     ) -> Result<Vec<Tensor<Fp>>, Box<dyn std::error::Error>> {
@@ -928,7 +968,6 @@ impl GraphCircuit {
         debug!("input scales: {:?}", scales);
 
         self.process_data_source(&data.input_data, shapes, scales, input_types)
-            .await
     }
 
     #[cfg(target_arch = "wasm32")]
@@ -952,7 +991,7 @@ impl GraphCircuit {
 
     #[cfg(not(target_arch = "wasm32"))]
     /// Process the data source for the model
-    async fn process_data_source(
+    fn process_data_source(
         &mut self,
         data: &DataSource,
         shapes: Vec<Vec<usize>>,
@@ -965,8 +1004,16 @@ impl GraphCircuit {
                 for (i, shape) in shapes.iter().enumerate() {
                     per_item_scale.extend(vec![scales[i]; shape.iter().product::<usize>()]);
                 }
-                self.load_on_chain_data(source.clone(), &shapes, per_item_scale)
-                    .await
+
+                // start runtime and fetch data
+                let runtime = tokio::runtime::Builder::new_current_thread()
+                    .enable_all()
+                    .build()?;
+
+                runtime.block_on(async {
+                    self.load_on_chain_data(source.clone(), &shapes, per_item_scale)
+                        .await
+                })
             }
             DataSource::File(file_data) => {
                 self.load_file_data(file_data, &shapes, scales, input_types)
@@ -1051,14 +1098,14 @@ impl GraphCircuit {
         Ok(data)
     }
 
-    fn calc_safe_lookup_range(min_max_lookup: Range, lookup_safety_margin: i128) -> Range {
+    fn calc_safe_lookup_range(min_max_lookup: Range, lookup_safety_margin: i64) -> Range {
         (
             lookup_safety_margin * min_max_lookup.0,
             lookup_safety_margin * min_max_lookup.1,
         )
     }
 
-    fn calc_num_cols(range_len: i128, max_logrows: u32) -> usize {
+    fn calc_num_cols(range_len: i64, 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)
     }
@@ -1066,7 +1113,7 @@ impl GraphCircuit {
     fn table_size_logrows(
         &self,
         safe_lookup_range: Range,
-        max_range_size: i128,
+        max_range_size: i64,
     ) -> Result<u32, Box<dyn std::error::Error>> {
         // pick the range with the largest absolute size safe_lookup_range or max_range_size
         let safe_range = std::cmp::max(
@@ -1085,9 +1132,9 @@ impl GraphCircuit {
     pub fn calc_min_logrows(
         &mut self,
         min_max_lookup: Range,
-        max_range_size: i128,
+        max_range_size: i64,
         max_logrows: Option<u32>,
-        lookup_safety_margin: i128,
+        lookup_safety_margin: i64,
     ) -> Result<(), Box<dyn std::error::Error>> {
         // load the max logrows
         let max_logrows = max_logrows.unwrap_or(MAX_PUBLIC_SRS);
@@ -1126,7 +1173,7 @@ impl GraphCircuit {
         );
 
         // These are upper limits, going above these is wasteful, but they are not hard limits
-        let model_constraint_logrows = self.settings().model_constraint_logrows();
+        let model_constraint_logrows = self.settings().model_constraint_logrows_with_blinding();
         let min_bits = self.table_size_logrows(safe_lookup_range, max_range_size)?;
         let constants_logrows = self.settings().constants_logrows();
         max_logrows = std::cmp::min(
@@ -1181,7 +1228,7 @@ impl GraphCircuit {
         &self,
         k: u32,
         safe_lookup_range: Range,
-        max_range_size: i128,
+        max_range_size: i64,
     ) -> 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
@@ -1240,6 +1287,7 @@ impl GraphCircuit {
         vk: Option<&VerifyingKey<G1Affine>>,
         srs: Option<&Scheme::ParamsProver>,
         witness_gen: bool,
+        check_lookup: bool,
     ) -> Result<GraphWitness, Box<dyn std::error::Error>> {
         let original_inputs = inputs.to_vec();
 
@@ -1288,7 +1336,7 @@ impl GraphCircuit {
 
         let mut model_results =
             self.model()
-                .forward(inputs, &self.settings().run_args, witness_gen)?;
+                .forward(inputs, &self.settings().run_args, witness_gen, check_lookup)?;
 
         if visibility.output.requires_processing() {
             let module_outlets = visibility.output.overwrites_inputs();
@@ -1451,7 +1499,8 @@ impl GraphCircuit {
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
-struct CircuitSize {
+/// The configuration for the graph circuit
+pub struct CircuitSize {
     num_instances: usize,
     num_advice_columns: usize,
     num_fixed: usize,
@@ -1461,7 +1510,8 @@ struct CircuitSize {
 }
 
 impl CircuitSize {
-    pub fn from_cs(cs: &ConstraintSystem<Fp>, logrows: u32) -> Self {
+    ///
+    pub fn from_cs<F: Field>(cs: &ConstraintSystem<F>, logrows: u32) -> Self {
         CircuitSize {
             num_instances: cs.num_instance_columns(),
             num_advice_columns: cs.num_advice_columns(),

src/graph/model.rs

@@ -65,11 +65,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: i128,
+    pub max_lookup_inputs: i64,
     /// The minimum value of any input to a lookup operation.
-    pub min_lookup_inputs: i128,
+    pub min_lookup_inputs: i64,
     /// The max range check size
-    pub max_range_size: i128,
+    pub max_range_size: i64,
 }
 
 impl From<DummyPassRes> for ForwardResult {
@@ -117,11 +117,11 @@ pub struct DummyPassRes {
     /// range checks
     pub range_checks: HashSet<Range>,
     /// max lookup inputs
-    pub max_lookup_inputs: i128,
+    pub max_lookup_inputs: i64,
     /// min lookup inputs
-    pub min_lookup_inputs: i128,
+    pub min_lookup_inputs: i64,
     /// min range check
-    pub max_range_size: i128,
+    pub max_range_size: i64,
     /// outputs
     pub outputs: Vec<Tensor<Fp>>,
 }
@@ -538,7 +538,7 @@ impl Model {
             })
             .collect::<Result<Vec<_>, Box<dyn Error>>>()?;
 
-        let res = self.dummy_layout(run_args, &inputs, false)?;
+        let res = self.dummy_layout(run_args, &inputs, false, false)?;
 
         // if we're using percentage tolerance, we need to add the necessary range check ops for it.
 
@@ -582,12 +582,13 @@ impl Model {
         model_inputs: &[Tensor<Fp>],
         run_args: &RunArgs,
         witness_gen: bool,
+        check_lookup: bool,
     ) -> Result<ForwardResult, Box<dyn Error>> {
         let valtensor_inputs: Vec<ValTensor<Fp>> = model_inputs
             .iter()
             .map(|x| x.map(|elem| ValType::Value(Value::known(elem))).into())
             .collect();
-        let res = self.dummy_layout(run_args, &valtensor_inputs, witness_gen)?;
+        let res = self.dummy_layout(run_args, &valtensor_inputs, witness_gen, check_lookup)?;
         Ok(res.into())
     }
 
@@ -803,13 +804,18 @@ impl Model {
                     let input_state_idx = input_state_idx(&input_mappings);
 
                     let mut output_mappings = vec![];
-                    for mapping in b.output_mapping.iter() {
+                    for (i, mapping) in b.output_mapping.iter().enumerate() {
                         let mut mappings = vec![];
                         if let Some(outlet) = mapping.last_value_slot {
                             mappings.push(OutputMapping::Single {
                                 outlet,
                                 is_state: mapping.state,
                             });
+                        } else if mapping.state {
+                            mappings.push(OutputMapping::Single {
+                                outlet: i,
+                                is_state: mapping.state,
+                            });
                         }
                         if let Some(last) = mapping.scan {
                             mappings.push(OutputMapping::Stacked {
@@ -818,6 +824,7 @@ impl Model {
                                 is_state: false,
                             });
                         }
+
                         output_mappings.push(mappings);
                     }
 
@@ -1194,6 +1201,20 @@ impl Model {
             .collect();
 
         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"))]
+            region.debug_report();
+            debug!("input indices: {:?}", node.inputs());
+            debug!("output scales: {:?}", node.out_scales());
+            debug!(
+                "input scales: {:?}",
+                node.inputs()
+                    .iter()
+                    .map(|(idx, outlet)| self.graph.nodes[idx].out_scales()[*outlet])
+                    .collect_vec()
+            );
+
             let mut values: Vec<ValTensor<Fp>> = if !node.is_input() {
                 node.inputs()
                     .iter()
@@ -1205,25 +1226,11 @@ impl Model {
                 // we re-assign inputs, always from the 0 outlet
                 vec![results.get(idx).ok_or(GraphError::MissingResults)?[0].clone()]
             };
-
-            debug!("laying out {}: {}", idx, node.as_str(),);
-            // Then number of columns in the circuits
-            #[cfg(not(target_arch = "wasm32"))]
-            region.debug_report();
-            debug!("dims: {:?}", node.out_dims());
+            debug!("output dims: {:?}", node.out_dims());
             debug!(
-                "input_dims {:?}",
+                "input dims {:?}",
                 values.iter().map(|v| v.dims()).collect_vec()
             );
-            debug!("output scales: {:?}", node.out_scales());
-            debug!("input indices: {:?}", node.inputs());
-            debug!(
-                "input scales: {:?}",
-                node.inputs()
-                    .iter()
-                    .map(|(idx, outlet)| self.graph.nodes[idx].out_scales()[*outlet])
-                    .collect_vec()
-            );
 
             match &node {
                 NodeType::Node(n) => {
@@ -1264,8 +1271,8 @@ impl Model {
                     let num_iter = number_of_iterations(&input_mappings, input_dims.collect());
 
                     debug!(
-                        "{} iteration(s) in a subgraph with inputs {:?} and sources {:?}",
-                        num_iter, inputs, model.graph.inputs
+                        "{} iteration(s) in a subgraph with inputs {:?}, sources {:?}, and outputs {:?}",
+                        num_iter, inputs, model.graph.inputs, model.graph.outputs
                     );
 
                     let mut full_results: Vec<ValTensor<Fp>> = vec![];
@@ -1297,6 +1304,7 @@ impl Model {
                         let res = model.layout_nodes(config, region, &mut subgraph_results)?;
 
                         let mut outlets = BTreeMap::new();
+                        let mut stacked_outlets = BTreeMap::new();
 
                         for (mappings, outlet_res) in output_mappings.iter().zip(res) {
                             for mapping in mappings {
@@ -1309,25 +1317,42 @@ impl Model {
                                             let stacked_res = full_results[*outlet]
                                                 .clone()
                                                 .concat_axis(outlet_res.clone(), axis)?;
-
-                                            outlets.insert(outlet, stacked_res);
-                                        } else {
-                                            outlets.insert(outlet, outlet_res.clone());
+                                            stacked_outlets.insert(outlet, stacked_res);
                                         }
+                                        outlets.insert(outlet, outlet_res.clone());
                                     }
                                 }
                             }
                         }
 
-                        full_results = outlets.into_values().collect_vec();
+                        // now extend with stacked elements
+                        let mut pre_stacked_outlets = outlets.clone();
+                        pre_stacked_outlets.extend(stacked_outlets);
+
+                        let outlets = outlets.into_values().collect_vec();
+
+                        full_results = pre_stacked_outlets.into_values().collect_vec();
 
                         let output_states = output_state_idx(output_mappings);
                         let input_states = input_state_idx(&input_mappings);
 
-                        assert_eq!(input_states.len(), output_states.len());
+                        assert_eq!(
+                            input_states.len(),
+                            output_states.len(),
+                            "input and output states must be the same length, got {:?} and {:?}",
+                            input_mappings,
+                            output_mappings
+                        );
 
                         for (input_idx, output_idx) in input_states.iter().zip(output_states) {
-                            values[*input_idx] = full_results[output_idx].clone();
+                            assert_eq!(
+                                values[*input_idx].dims(),
+                                outlets[output_idx].dims(),
+                                "input and output dims must be the same, got {:?} and {:?}",
+                                values[*input_idx].dims(),
+                                outlets[output_idx].dims()
+                            );
+                            values[*input_idx] = outlets[output_idx].clone();
                         }
                     }
 
@@ -1368,6 +1393,7 @@ impl Model {
         run_args: &RunArgs,
         inputs: &[ValTensor<Fp>],
         witness_gen: bool,
+        check_lookup: bool,
     ) -> Result<DummyPassRes, Box<dyn Error>> {
         debug!("calculating num of constraints using dummy model layout...");
 
@@ -1386,7 +1412,8 @@ impl Model {
             vars: ModelVars::new_dummy(),
         };
 
-        let mut region = RegionCtx::new_dummy(0, run_args.num_inner_cols, witness_gen);
+        let mut region =
+            RegionCtx::new_dummy(0, run_args.num_inner_cols, witness_gen, check_lookup);
 
         let outputs = self.layout_nodes(&mut model_config, &mut region, &mut results)?;
 

src/graph/modules.rs

@@ -314,7 +314,6 @@ impl GraphModules {
                     let commitments = inputs.iter().fold(vec![], |mut acc, x| {
                         let res = PolyCommitChip::commit::<Scheme>(
                             x.to_vec(),
-                            vk.cs().degree() as u32,
                             (vk.cs().blinding_factors() + 1) as u32,
                             srs,
                         );

src/graph/node.rs

@@ -14,7 +14,6 @@ use crate::circuit::Op;
 use crate::circuit::Unknown;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::graph::new_op_from_onnx;
-use crate::tensor::Tensor;
 use crate::tensor::TensorError;
 use halo2curves::bn256::Fr as Fp;
 #[cfg(not(target_arch = "wasm32"))]
@@ -61,20 +60,6 @@ impl Op<Fp> for Rescaled {
     fn as_any(&self) -> &dyn std::any::Any {
         self
     }
-    fn f(&self, x: &[Tensor<Fp>]) -> Result<crate::circuit::ForwardResult<Fp>, TensorError> {
-        if self.scale.len() != x.len() {
-            return Err(TensorError::DimMismatch("rescaled inputs".to_string()));
-        }
-
-        let mut rescaled_inputs = vec![];
-        let inputs = &mut x.to_vec();
-        for (i, ri) in inputs.iter_mut().enumerate() {
-            let mult_tensor = Tensor::from([Fp::from(self.scale[i].1 as u64)].into_iter());
-            let res = (ri.clone() * mult_tensor)?;
-            rescaled_inputs.push(res);
-        }
-        Op::<Fp>::f(&*self.inner, &rescaled_inputs)
-    }
 
     fn as_string(&self) -> String {
         format!("RESCALED INPUT ({})", self.inner.as_string())
@@ -215,13 +200,6 @@ impl Op<Fp> for RebaseScale {
     fn as_any(&self) -> &dyn std::any::Any {
         self
     }
-    fn f(&self, x: &[Tensor<Fp>]) -> Result<crate::circuit::ForwardResult<Fp>, TensorError> {
-        let mut res = Op::<Fp>::f(&*self.inner, x)?;
-        let rebase_res = Op::<Fp>::f(&self.rebase_op, &[res.output])?;
-        res.output = rebase_res.output;
-
-        Ok(res)
-    }
 
     fn as_string(&self) -> String {
         format!(
@@ -389,13 +367,6 @@ impl From<Box<dyn Op<Fp>>> for SupportedOp {
 }
 
 impl Op<Fp> for SupportedOp {
-    fn f(
-        &self,
-        inputs: &[Tensor<Fp>],
-    ) -> Result<crate::circuit::ForwardResult<Fp>, crate::tensor::TensorError> {
-        self.as_op().f(inputs)
-    }
-
     fn layout(
         &self,
         config: &mut crate::circuit::BaseConfig<Fp>,

src/graph/utilities.rs

@@ -52,16 +52,16 @@ 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<i128, TensorError> {
+pub fn quantize_float(elem: &f64, shift: f64, scale: crate::Scale) -> Result<i64, TensorError> {
     let mult = scale_to_multiplier(scale);
-    let max_value = ((i128::MAX as f64 - shift) / mult).round(); // the maximum value that can be represented w/o sig bit truncation
+    let max_value = ((i64::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 i128;
+    let scaled = (mult * *elem + shift).round() as i64;
 
     Ok(scaled)
 }
@@ -72,7 +72,7 @@ pub fn quantize_float(elem: &f64, shift: f64, scale: crate::Scale) -> Result<i12
 /// * `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_i128(felt);
+    let int_rep = crate::fieldutils::felt_to_i64(felt);
     let multiplier = scale_to_multiplier(scale);
     int_rep as f64 / multiplier - shift
 }
@@ -509,7 +509,7 @@ pub fn new_op_from_onnx(
             // if param_visibility.is_public() {
             if let Some(c) = inputs[1].opkind().get_mutable_constant() {
                 inputs[1].decrement_use();
-                deleted_indices.push(inputs.len() - 1);
+                deleted_indices.push(1);
                 op = SupportedOp::Linear(crate::circuit::ops::poly::PolyOp::ScatterND {
                     constant_idx: Some(c.raw_values.map(|x| x as usize)),
                 })
@@ -545,7 +545,7 @@ pub fn new_op_from_onnx(
             // if param_visibility.is_public() {
             if let Some(c) = inputs[1].opkind().get_mutable_constant() {
                 inputs[1].decrement_use();
-                deleted_indices.push(inputs.len() - 1);
+                deleted_indices.push(1);
                 op = SupportedOp::Linear(crate::circuit::ops::poly::PolyOp::GatherND {
                     batch_dims,
                     indices: Some(c.raw_values.map(|x| x as usize)),
@@ -582,7 +582,7 @@ pub fn new_op_from_onnx(
             // if param_visibility.is_public() {
             if let Some(c) = inputs[1].opkind().get_mutable_constant() {
                 inputs[1].decrement_use();
-                deleted_indices.push(inputs.len() - 1);
+                deleted_indices.push(1);
                 op = SupportedOp::Linear(crate::circuit::ops::poly::PolyOp::GatherElements {
                     dim: axis,
                     constant_idx: Some(c.raw_values.map(|x| x as usize)),
@@ -734,6 +734,19 @@ pub fn new_op_from_onnx(
 
             SupportedOp::Linear(PolyOp::Sum { axes })
         }
+        "Reduce<MeanOfSquares>" => {
+            if inputs.len() != 1 {
+                return Err(Box::new(GraphError::InvalidDims(
+                    idx,
+                    "mean of squares".to_string(),
+                )));
+            };
+            let op = load_op::<Reduce>(node.op(), idx, node.op().name().to_string())?;
+            let axes = op.axes.into_iter().collect();
+
+            SupportedOp::Linear(PolyOp::MeanOfSquares { axes })
+        }
+
         "Max" => {
             // Extract the max value
             // first find the input that is a constant
@@ -1106,17 +1119,7 @@ pub fn new_op_from_onnx(
                 .ok_or(GraphError::MissingParams("stride".to_string()))?;
             let padding = match &pool_spec.padding {
                 PaddingSpec::Explicit(b, a) | PaddingSpec::ExplicitOnnxPool(b, a, _) => {
-                    if b.len() == 2 && a.len() == 2 {
-                        [(b[0], b[1]), (a[0], a[1])]
-                    } else if b.len() == 1 && a.len() == 1 {
-                        [(b[0], b[0]), (a[0], a[0])]
-                    } else if b.len() == 1 && a.len() == 2 {
-                        [(b[0], b[0]), (a[0], a[1])]
-                    } else if b.len() == 2 && a.len() == 1 {
-                        [(b[0], b[1]), (a[0], a[0])]
-                    } else {
-                        return Err(Box::new(GraphError::MissingParams("padding".to_string())));
-                    }
+                    b.iter().zip(a.iter()).map(|(b, a)| (*b, *a)).collect()
                 }
                 _ => {
                     return Err(Box::new(GraphError::MissingParams("padding".to_string())));
@@ -1124,26 +1127,10 @@ pub fn new_op_from_onnx(
             };
             let kernel_shape = &pool_spec.kernel_shape;
 
-            let (stride_h, stride_w) = if stride.len() == 1 {
-                (1, stride[0])
-            } else if stride.len() == 2 {
-                (stride[0], stride[1])
-            } else {
-                return Err(Box::new(GraphError::MissingParams("stride".to_string())));
-            };
-
-            let (kernel_height, kernel_width) = if kernel_shape.len() == 1 {
-                (1, kernel_shape[0])
-            } else if kernel_shape.len() == 2 {
-                (kernel_shape[0], kernel_shape[1])
-            } else {
-                return Err(Box::new(GraphError::MissingParams("kernel".to_string())));
-            };
-
-            SupportedOp::Hybrid(HybridOp::MaxPool2d {
+            SupportedOp::Hybrid(HybridOp::MaxPool {
                 padding,
-                stride: (stride_h, stride_w),
-                pool_dims: (kernel_height, kernel_width),
+                stride: stride.to_vec(),
+                pool_dims: kernel_shape.to_vec(),
             })
         }
         "Ceil" => SupportedOp::Nonlinear(LookupOp::Ceil {
@@ -1165,7 +1152,7 @@ pub fn new_op_from_onnx(
             // if param_visibility.is_public() {
             if let Some(c) = inputs[1].opkind().get_mutable_constant() {
                 inputs[1].decrement_use();
-                deleted_indices.push(inputs.len() - 1);
+                deleted_indices.push(1);
                 if c.raw_values.len() > 1 {
                     unimplemented!("only support scalar pow")
                 }
@@ -1205,15 +1192,7 @@ pub fn new_op_from_onnx(
             }
 
             let stride = match conv_node.pool_spec.strides.clone() {
-                Some(s) => {
-                    if s.len() == 1 {
-                        (s[0], s[0])
-                    } else if s.len() == 2 {
-                        (s[0], s[1])
-                    } else {
-                        return Err(Box::new(GraphError::MissingParams("strides".to_string())));
-                    }
-                }
+                Some(s) => s.to_vec(),
                 None => {
                     return Err(Box::new(GraphError::MissingParams("strides".to_string())));
                 }
@@ -1221,17 +1200,7 @@ pub fn new_op_from_onnx(
 
             let padding = match &conv_node.pool_spec.padding {
                 PaddingSpec::Explicit(b, a) | PaddingSpec::ExplicitOnnxPool(b, a, _) => {
-                    if b.len() == 2 && a.len() == 2 {
-                        [(b[0], b[1]), (a[0], a[1])]
-                    } else if b.len() == 1 && a.len() == 1 {
-                        [(b[0], b[0]), (a[0], a[0])]
-                    } else if b.len() == 1 && a.len() == 2 {
-                        [(b[0], b[0]), (a[0], a[1])]
-                    } else if b.len() == 2 && a.len() == 1 {
-                        [(b[0], b[1]), (a[0], a[0])]
-                    } else {
-                        return Err(Box::new(GraphError::MissingParams("padding".to_string())));
-                    }
+                    b.iter().zip(a.iter()).map(|(b, a)| (*b, *a)).collect()
                 }
                 _ => {
                     return Err(Box::new(GraphError::MissingParams("padding".to_string())));
@@ -1286,33 +1255,20 @@ pub fn new_op_from_onnx(
             }
 
             let stride = match deconv_node.pool_spec.strides.clone() {
-                Some(s) => (s[0], s[1]),
+                Some(s) => s.to_vec(),
                 None => {
                     return Err(Box::new(GraphError::MissingParams("strides".to_string())));
                 }
             };
             let padding = match &deconv_node.pool_spec.padding {
                 PaddingSpec::Explicit(b, a) | PaddingSpec::ExplicitOnnxPool(b, a, _) => {
-                    if b.len() == 2 && a.len() == 2 {
-                        [(b[0], b[1]), (a[0], a[1])]
-                    } else if b.len() == 1 && a.len() == 1 {
-                        [(b[0], b[0]), (a[0], a[0])]
-                    } else if b.len() == 1 && a.len() == 2 {
-                        [(b[0], b[0]), (a[0], a[1])]
-                    } else if b.len() == 2 && a.len() == 1 {
-                        [(b[0], b[1]), (a[0], a[0])]
-                    } else {
-                        return Err(Box::new(GraphError::MissingParams("padding".to_string())));
-                    }
+                    b.iter().zip(a.iter()).map(|(b, a)| (*b, *a)).collect()
                 }
                 _ => {
                     return Err(Box::new(GraphError::MissingParams("padding".to_string())));
                 }
             };
 
-            let output_padding: (usize, usize) =
-                (deconv_node.adjustments[0], deconv_node.adjustments[1]);
-
             // if bias exists then rescale it to the input + kernel scale
             if input_scales.len() == 3 {
                 let bias_scale = input_scales[2];
@@ -1331,7 +1287,7 @@ pub fn new_op_from_onnx(
 
             SupportedOp::Linear(PolyOp::DeConv {
                 padding,
-                output_padding,
+                output_padding: deconv_node.adjustments.to_vec(),
                 stride,
             })
         }
@@ -1432,46 +1388,17 @@ pub fn new_op_from_onnx(
                 .ok_or(GraphError::MissingParams("stride".to_string()))?;
             let padding = match &pool_spec.padding {
                 PaddingSpec::Explicit(b, a) | PaddingSpec::ExplicitOnnxPool(b, a, _) => {
-                    if b.len() == 2 && a.len() == 2 {
-                        [(b[0], b[1]), (a[0], a[1])]
-                    } else if b.len() == 1 && a.len() == 1 {
-                        [(b[0], b[0]), (a[0], a[0])]
-                    } else if b.len() == 1 && a.len() == 2 {
-                        [(b[0], b[0]), (a[0], a[1])]
-                    } else if b.len() == 2 && a.len() == 1 {
-                        [(b[0], b[1]), (a[0], a[0])]
-                    } else {
-                        return Err(Box::new(GraphError::MissingParams("padding".to_string())));
-                    }
+                    b.iter().zip(a.iter()).map(|(b, a)| (*b, *a)).collect()
                 }
                 _ => {
                     return Err(Box::new(GraphError::MissingParams("padding".to_string())));
                 }
             };
-            let kernel_shape = &pool_spec.kernel_shape;
-
-            let (stride_h, stride_w) = if stride.len() == 1 {
-                (1, stride[0])
-            } else if stride.len() == 2 {
-                (stride[0], stride[1])
-            } else {
-                return Err(Box::new(GraphError::MissingParams("stride".to_string())));
-            };
-
-            let (kernel_height, kernel_width) = if kernel_shape.len() == 1 {
-                (1, kernel_shape[0])
-            } else if kernel_shape.len() == 2 {
-                (kernel_shape[0], kernel_shape[1])
-            } else {
-                return Err(Box::new(GraphError::MissingParams(
-                    "kernel shape".to_string(),
-                )));
-            };
 
             SupportedOp::Hybrid(HybridOp::SumPool {
                 padding,
-                stride: (stride_h, stride_w),
-                kernel_shape: (kernel_height, kernel_width),
+                stride: stride.to_vec(),
+                kernel_shape: pool_spec.kernel_shape.to_vec(),
                 normalized: sumpool_node.normalize,
             })
         }
@@ -1498,29 +1425,7 @@ pub fn new_op_from_onnx(
                 )));
             }
 
-            let padding_len = pad_node.pads.len();
-
-            // we only support symmetrical padding that affects the last 2 dims (height and width params)
-            for (i, pad_params) in pad_node.pads.iter().enumerate() {
-                if (i < padding_len - 2) && ((pad_params.0 != 0) || (pad_params.1 != 0)) {
-                    return Err(Box::new(GraphError::MisformedParams(
-                        "ezkl currently only supports padding height and width dimensions"
-                            .to_string(),
-                    )));
-                }
-            }
-
-            let padding = [
-                (
-                    pad_node.pads[padding_len - 2].0,
-                    pad_node.pads[padding_len - 1].0,
-                ),
-                (
-                    pad_node.pads[padding_len - 2].1,
-                    pad_node.pads[padding_len - 1].1,
-                ),
-            ];
-            SupportedOp::Linear(PolyOp::Pad(padding))
+            SupportedOp::Linear(PolyOp::Pad(pad_node.pads.to_vec()))
         }
         "RmAxis" | "Reshape" | "AddAxis" => {
             // Extract the slope layer hyperparams
@@ -1570,7 +1475,7 @@ pub fn quantize_tensor<F: PrimeField + TensorType + PartialOrd>(
     visibility: &Visibility,
 ) -> Result<Tensor<F>, Box<dyn std::error::Error>> {
     let mut value: Tensor<F> = const_value.par_enum_map(|_, x| {
-        Ok::<_, TensorError>(crate::fieldutils::i128_to_felt::<F>(quantize_float(
+        Ok::<_, TensorError>(crate::fieldutils::i64_to_felt::<F>(quantize_float(
             &(x).into(),
             0.0,
             scale,

src/lib.rs

@@ -23,6 +23,7 @@
 )]
 // we allow this for our dynamic range based indexing scheme
 #![allow(clippy::single_range_in_vec_init)]
+#![feature(stmt_expr_attributes)]
 
 //! A library for turning computational graphs, such as neural networks, into ZK-circuits.
 //!
@@ -114,6 +115,12 @@ pub enum Commitments {
     IPA,
 }
 
+impl From<Option<Commitments>> for Commitments {
+    fn from(value: Option<Commitments>) -> Self {
+        value.unwrap_or(Commitments::KZG)
+    }
+}
+
 impl FromStr for Commitments {
     type Err = String;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -183,7 +190,7 @@ pub struct RunArgs {
     #[arg(long, default_value = "1")]
     pub scale_rebase_multiplier: u32,
     /// The min and max elements in the lookup table input column
-    #[arg(short = 'B', long, value_parser = parse_key_val::<i128, i128>, default_value = "-32768->32768")]
+    #[arg(short = 'B', long, value_parser = parse_key_val::<i64, i64>, default_value = "-32768->32768")]
     pub lookup_range: Range,
     /// The log_2 number of rows
     #[arg(short = 'K', long, default_value = "17")]
@@ -194,13 +201,13 @@ pub struct RunArgs {
     /// Hand-written parser for graph variables, eg. batch_size=1
     #[arg(short = 'V', long, value_parser = parse_key_val::<String, usize>, default_value = "batch_size->1", value_delimiter = ',')]
     pub variables: Vec<(String, usize)>,
-    /// Flags whether inputs are public, private, hashed
+    /// Flags whether inputs are public, private, fixed, hashed, polycommit
     #[arg(long, default_value = "private")]
     pub input_visibility: Visibility,
-    /// Flags whether outputs are public, private, hashed
+    /// Flags whether outputs are public, private, fixed, hashed, polycommit
     #[arg(long, default_value = "public")]
     pub output_visibility: Visibility,
-    /// Flags whether params are public, private, hashed
+    /// Flags whether params are fixed, private, hashed, polycommit
     #[arg(long, default_value = "private")]
     pub param_visibility: Visibility,
     #[arg(long, default_value = "false")]
@@ -214,7 +221,7 @@ pub struct RunArgs {
     pub check_mode: CheckMode,
     /// commitment scheme
     #[arg(long, default_value = "kzg")]
-    pub commitment: Commitments,
+    pub commitment: Option<Commitments>,
 }
 
 impl Default for RunArgs {
@@ -234,7 +241,7 @@ impl Default for RunArgs {
             div_rebasing: false,
             rebase_frac_zero_constants: false,
             check_mode: CheckMode::UNSAFE,
-            commitment: Commitments::KZG,
+            commitment: None,
         }
     }
 }
@@ -242,6 +249,12 @@ impl Default for RunArgs {
 impl RunArgs {
     ///
     pub fn validate(&self) -> Result<(), Box<dyn std::error::Error>> {
+        if self.param_visibility == Visibility::Public {
+            return Err(
+                "params cannot be public instances, you are probably trying to use `fixed` or `kzgcommit`"
+                    .into(),
+            );
+        }
         if self.scale_rebase_multiplier < 1 {
             return Err("scale_rebase_multiplier must be >= 1".into());
         }

src/pfsys/evm/aggregation_kzg.rs

@@ -1,4 +1,8 @@
+#[cfg(not(target_arch = "wasm32"))]
+use crate::graph::CircuitSize;
 use crate::pfsys::{Snark, SnarkWitness};
+#[cfg(not(target_arch = "wasm32"))]
+use colored_json::ToColoredJson;
 use halo2_proofs::circuit::AssignedCell;
 use halo2_proofs::plonk::{self};
 use halo2_proofs::{
@@ -16,6 +20,8 @@ use halo2_wrong_ecc::{
 use halo2curves::bn256::{Bn256, Fq, Fr, G1Affine};
 use halo2curves::ff::PrimeField;
 use itertools::Itertools;
+#[cfg(not(target_arch = "wasm32"))]
+use log::debug;
 use log::trace;
 use rand::rngs::OsRng;
 use snark_verifier::loader::native::NativeLoader;
@@ -193,6 +199,23 @@ impl AggregationConfig {
         let main_gate_config = MainGate::<F>::configure(meta);
         let range_config =
             RangeChip::<F>::configure(meta, &main_gate_config, composition_bits, overflow_bits);
+
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            let circuit_size = CircuitSize::from_cs(meta, 23);
+
+            // not wasm
+
+            debug!(
+                "circuit size: \n {}",
+                circuit_size
+                    .as_json()
+                    .unwrap()
+                    .to_colored_json_auto()
+                    .unwrap()
+            );
+        }
+
         AggregationConfig {
             main_gate_config,
             range_config,

src/tensor/metal/tensor_ops.metal

@@ -0,0 +1,31 @@
+[[kernel]]
+void add(
+  constant long *inA [[buffer(0)]],
+  constant long *inB [[buffer(1)]],
+  device long *result [[buffer(2)]],
+  uint index [[thread_position_in_grid]])
+{
+  result[index] = inA[index] + inB[index];
+}
+
+
+[[kernel]]
+void sub(
+  constant long *inA [[buffer(0)]],
+  constant long *inB [[buffer(1)]],
+  device long *result [[buffer(2)]],
+  uint index [[thread_position_in_grid]])
+{
+  result[index] = inA[index] - inB[index];
+}
+
+
+[[kernel]]
+void mul(
+  constant long *inA [[buffer(0)]],
+  constant long *inB [[buffer(1)]],
+  device long *result [[buffer(2)]],
+  uint index [[thread_position_in_grid]])
+{
+  result[index] = inA[index] * inB[index];
+}

src/tensor/mod.rs

@@ -5,7 +5,7 @@ pub mod val;
 /// A wrapper around a tensor of Halo2 Value types.
 pub mod var;
 
-use halo2curves::ff::PrimeField;
+use halo2curves::{bn256::Fr, ff::PrimeField};
 use maybe_rayon::{
     prelude::{
         IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator,
@@ -17,9 +17,12 @@ use serde::{Deserialize, Serialize};
 pub use val::*;
 pub use var::*;
 
+#[cfg(feature = "metal")]
+use instant::Instant;
+
 use crate::{
     circuit::utils,
-    fieldutils::{felt_to_i32, i128_to_felt, i32_to_felt},
+    fieldutils::{felt_to_i32, felt_to_i64, i32_to_felt, i64_to_felt},
     graph::Visibility,
 };
 
@@ -30,12 +33,18 @@ use halo2_proofs::{
     poly::Rotation,
 };
 use itertools::Itertools;
+#[cfg(feature = "metal")]
+use metal::{Device, MTLResourceOptions, MTLSize};
 use std::error::Error;
 use std::fmt::Debug;
 use std::iter::Iterator;
 use std::ops::{Add, Deref, DerefMut, Div, Mul, Neg, Range, Sub};
 use std::{cmp::max, ops::Rem};
 use thiserror::Error;
+
+#[cfg(feature = "metal")]
+use std::collections::HashMap;
+
 /// A wrapper for tensor related errors.
 #[derive(Debug, Error)]
 pub enum TensorError {
@@ -60,6 +69,31 @@ pub enum TensorError {
     /// Unsupported operation
     #[error("Unsupported operation on a tensor type")]
     Unsupported,
+    /// Overflow
+    #[error("Unsigned integer overflow or underflow error in op: {0}")]
+    Overflow(String),
+}
+
+#[cfg(feature = "metal")]
+const LIB_DATA: &[u8] = include_bytes!("metal/tensor_ops.metallib");
+
+#[cfg(feature = "metal")]
+lazy_static::lazy_static! {
+    static ref DEVICE: Device = Device::system_default().expect("no device found");
+
+    static ref LIB: metal::Library = DEVICE.new_library_with_data(LIB_DATA).unwrap();
+
+    static ref QUEUE: metal::CommandQueue = DEVICE.new_command_queue();
+
+    static ref PIPELINES: HashMap<String, metal::ComputePipelineState> = {
+        let mut map = HashMap::new();
+        for name in ["add", "sub", "mul"] {
+            let function = LIB.get_function(name, None).unwrap();
+            let pipeline = DEVICE.new_compute_pipeline_state_with_function(&function).unwrap();
+            map.insert(name.to_string(), pipeline);
+        }
+        map
+    };
 }
 
 /// The (inner) type of tensor elements.
@@ -142,7 +176,7 @@ impl TensorType for f64 {
 }
 
 tensor_type!(bool, Bool, false, true);
-tensor_type!(i128, Int128, 0, 1);
+tensor_type!(i64, Int64, 0, 1);
 tensor_type!(i32, Int32, 0, 1);
 tensor_type!(usize, USize, 0, 1);
 tensor_type!((), Empty, (), ());
@@ -308,6 +342,94 @@ impl<T: TensorType> DerefMut for Tensor<T> {
         self.inner.deref_mut()
     }
 }
+/// Convert to i64 trait
+pub trait IntoI64 {
+    /// Convert to i64
+    fn into_i64(self) -> i64;
+
+    /// From i64
+    fn from_i64(i: i64) -> Self;
+}
+
+impl IntoI64 for i64 {
+    fn into_i64(self) -> i64 {
+        self
+    }
+    fn from_i64(i: i64) -> i64 {
+        i
+    }
+}
+
+impl IntoI64 for i32 {
+    fn into_i64(self) -> i64 {
+        self as i64
+    }
+    fn from_i64(i: i64) -> Self {
+        i as i32
+    }
+}
+
+impl IntoI64 for usize {
+    fn into_i64(self) -> i64 {
+        self as i64
+    }
+    fn from_i64(i: i64) -> Self {
+        i as usize
+    }
+}
+
+impl IntoI64 for f32 {
+    fn into_i64(self) -> i64 {
+        self as i64
+    }
+    fn from_i64(i: i64) -> Self {
+        i as f32
+    }
+}
+
+impl IntoI64 for f64 {
+    fn into_i64(self) -> i64 {
+        self as i64
+    }
+    fn from_i64(i: i64) -> Self {
+        i as f64
+    }
+}
+
+impl IntoI64 for () {
+    fn into_i64(self) -> i64 {
+        0
+    }
+    fn from_i64(_: i64) -> Self {
+        ()
+    }
+}
+
+impl IntoI64 for Fr {
+    fn into_i64(self) -> i64 {
+        felt_to_i64(self)
+    }
+    fn from_i64(i: i64) -> Self {
+        i64_to_felt::<Fr>(i)
+    }
+}
+
+impl<F: PrimeField + IntoI64> IntoI64 for Value<F> {
+    fn into_i64(self) -> i64 {
+        let mut res = vec![];
+        self.map(|x| res.push(x.into_i64()));
+
+        if res.len() == 0 {
+            0
+        } else {
+            res[0]
+        }
+    }
+
+    fn from_i64(i: i64) -> Self {
+        Value::known(F::from_i64(i))
+    }
+}
 
 impl<T: PartialEq + TensorType> PartialEq for Tensor<T> {
     fn eq(&self, other: &Tensor<T>) -> bool {
@@ -424,10 +546,10 @@ impl<F: PrimeField + TensorType + Clone> From<Tensor<i32>> for Tensor<Value<F>>
     }
 }
 
-impl<F: PrimeField + TensorType + Clone> From<Tensor<i128>> for Tensor<Value<F>> {
-    fn from(t: Tensor<i128>) -> Tensor<Value<F>> {
+impl<F: PrimeField + TensorType + Clone> From<Tensor<i64>> for Tensor<Value<F>> {
+    fn from(t: Tensor<i64>) -> Tensor<Value<F>> {
         let mut ta: Tensor<Value<F>> =
-            Tensor::from((0..t.len()).map(|i| Value::known(i128_to_felt::<F>(t[i]))));
+            Tensor::from((0..t.len()).map(|i| Value::known(i64_to_felt::<F>(t[i]))));
         // safe to unwrap as we know the dims are correct
         ta.reshape(t.dims()).unwrap();
         ta
@@ -934,6 +1056,7 @@ impl<T: Clone + TensorType> Tensor<T> {
     pub fn move_axis(&mut self, source: usize, destination: usize) -> Result<Self, TensorError> {
         assert!(source < self.dims.len());
         assert!(destination < self.dims.len());
+
         let mut new_dims = self.dims.clone();
         new_dims.remove(source);
         new_dims.insert(destination, self.dims[source]);
@@ -965,6 +1088,8 @@ impl<T: Clone + TensorType> Tensor<T> {
                     old_coord[source - 1] = *c;
                 } else if (i < source && source < destination)
                     || (i < destination && source > destination)
+                    || (i > source && source > destination)
+                    || (i > destination && source < destination)
                 {
                     old_coord[i] = *c;
                 } else if i > source && source < destination {
@@ -977,7 +1102,10 @@ impl<T: Clone + TensorType> Tensor<T> {
                     ));
                 }
             }
-            output.set(&coord, self.get(&old_coord));
+
+            let value = self.get(&old_coord);
+
+            output.set(&coord, value);
         }
 
         Ok(output)
@@ -1208,6 +1336,97 @@ impl<T: Clone + TensorType> Tensor<T> {
     }
 }
 
+#[cfg(feature = "metal")]
+#[allow(unsafe_code)]
+/// Perform a tensor operation on the GPU using Metal.
+pub fn metal_tensor_op<T: Clone + TensorType + IntoI64 + Send + Sync>(
+    v: &Tensor<T>,
+    w: &Tensor<T>,
+    op: &str,
+) -> Tensor<T> {
+    assert_eq!(v.dims(), w.dims());
+
+    log::trace!("------------------------------------------------");
+
+    let start = Instant::now();
+    let v = v
+        .par_enum_map(|_, x| Ok::<_, TensorError>(x.into_i64()))
+        .unwrap();
+    let w = w
+        .par_enum_map(|_, x| Ok::<_, TensorError>(x.into_i64()))
+        .unwrap();
+    log::trace!("Time to map tensors: {:?}", start.elapsed());
+
+    objc::rc::autoreleasepool(|| {
+        // create function pipeline.
+        // this compiles the function, so a pipline can't be created in performance sensitive code.
+
+        let pipeline = &PIPELINES[op];
+
+        let length = v.len() as u64;
+        let size = length * core::mem::size_of::<i64>() as u64;
+        assert_eq!(v.len(), w.len());
+
+        let start = Instant::now();
+
+        let buffer_a = DEVICE.new_buffer_with_data(
+            unsafe { std::mem::transmute(v.as_ptr()) },
+            size,
+            MTLResourceOptions::StorageModeShared,
+        );
+        let buffer_b = DEVICE.new_buffer_with_data(
+            unsafe { std::mem::transmute(w.as_ptr()) },
+            size,
+            MTLResourceOptions::StorageModeShared,
+        );
+        let buffer_result = DEVICE.new_buffer(
+            size, // the operation will return an array with the same size.
+            MTLResourceOptions::StorageModeShared,
+        );
+
+        log::trace!("Time to load buffers: {:?}", start.elapsed());
+
+        // for sending commands, a command buffer is needed.
+        let start = Instant::now();
+        let command_buffer = QUEUE.new_command_buffer();
+        log::trace!("Time to load command buffer: {:?}", start.elapsed());
+        // to write commands into a buffer an encoder is needed, in our case a compute encoder.
+        let start = Instant::now();
+        let compute_encoder = command_buffer.new_compute_command_encoder();
+        compute_encoder.set_compute_pipeline_state(&pipeline);
+        compute_encoder.set_buffers(
+            0,
+            &[Some(&buffer_a), Some(&buffer_b), Some(&buffer_result)],
+            &[0; 3],
+        );
+        log::trace!("Time to load compute encoder: {:?}", start.elapsed());
+
+        // specify thread count and organization
+        let start = Instant::now();
+        let grid_size = MTLSize::new(length, 1, 1);
+        let threadgroup_size = MTLSize::new(length, 1, 1);
+        compute_encoder.dispatch_threads(grid_size, threadgroup_size);
+        log::trace!("Time to dispatch threads: {:?}", start.elapsed());
+
+        // end encoding and execute commands
+        let start = Instant::now();
+        compute_encoder.end_encoding();
+        command_buffer.commit();
+
+        command_buffer.wait_until_completed();
+        log::trace!("Time to commit: {:?}", start.elapsed());
+
+        let start = Instant::now();
+        let ptr = buffer_result.contents() as *const i64;
+        let len = buffer_result.length() as usize / std::mem::size_of::<i64>();
+        let slice = unsafe { core::slice::from_raw_parts(ptr, len) };
+        let res = Tensor::new(Some(&slice.to_vec()), &v.dims()).unwrap();
+        log::trace!("Time to get result: {:?}", start.elapsed());
+
+        res.map(|x| T::from_i64(x))
+    })
+}
+
 impl<T: Clone + TensorType> Tensor<Tensor<T>> {
     /// Flattens a tensor of tensors
     /// ```
@@ -1229,7 +1448,9 @@ impl<T: Clone + TensorType> Tensor<Tensor<T>> {
     }
 }
 
-impl<T: TensorType + Add<Output = T> + std::marker::Send + std::marker::Sync> Add for Tensor<T> {
+impl<T: TensorType + Add<Output = T> + std::marker::Send + std::marker::Sync + IntoI64> Add
+    for Tensor<T>
+{
     type Output = Result<Tensor<T>, TensorError>;
     /// Adds tensors.
     /// # Arguments
@@ -1279,14 +1500,24 @@ impl<T: TensorType + Add<Output = T> + std::marker::Send + std::marker::Sync> Ad
     /// ```
     fn add(self, rhs: Self) -> Self::Output {
         let broadcasted_shape = get_broadcasted_shape(self.dims(), rhs.dims()).unwrap();
-        let mut lhs = self.expand(&broadcasted_shape).unwrap();
+        let lhs = self.expand(&broadcasted_shape).unwrap();
         let rhs = rhs.expand(&broadcasted_shape).unwrap();
 
-        lhs.par_iter_mut().zip(rhs).for_each(|(o, r)| {
-            *o = o.clone() + r;
-        });
+        #[cfg(feature = "metal")]
+        let res = metal_tensor_op(&lhs, &rhs, "add");
 
-        Ok(lhs)
+        #[cfg(not(feature = "metal"))]
+        let res = {
+            let mut res: Tensor<T> = lhs
+                .par_iter()
+                .zip(rhs)
+                .map(|(o, r)| o.clone() + r)
+                .collect();
+            res.reshape(&broadcasted_shape).unwrap();
+            res
+        };
+
+        Ok(res)
     }
 }
 
@@ -1309,6 +1540,7 @@ impl<T: TensorType + Neg<Output = T> + std::marker::Send + std::marker::Sync> Ne
     /// ```
     fn neg(self) -> Self {
         let mut output = self;
+
         output.par_iter_mut().for_each(|x| {
             *x = x.clone().neg();
         });
@@ -1316,7 +1548,9 @@ impl<T: TensorType + Neg<Output = T> + std::marker::Send + std::marker::Sync> Ne
     }
 }
 
-impl<T: TensorType + Sub<Output = T> + std::marker::Send + std::marker::Sync> Sub for Tensor<T> {
+impl<T: TensorType + Sub<Output = T> + std::marker::Send + std::marker::Sync + IntoI64> Sub
+    for Tensor<T>
+{
     type Output = Result<Tensor<T>, TensorError>;
     /// Subtracts tensors.
     /// # Arguments
@@ -1367,18 +1601,30 @@ impl<T: TensorType + Sub<Output = T> + std::marker::Send + std::marker::Sync> Su
     /// ```
     fn sub(self, rhs: Self) -> Self::Output {
         let broadcasted_shape = get_broadcasted_shape(self.dims(), rhs.dims()).unwrap();
-        let mut lhs = self.expand(&broadcasted_shape).unwrap();
+        let lhs = self.expand(&broadcasted_shape).unwrap();
         let rhs = rhs.expand(&broadcasted_shape).unwrap();
 
-        lhs.par_iter_mut().zip(rhs).for_each(|(o, r)| {
-            *o = o.clone() - r;
-        });
+        #[cfg(feature = "metal")]
+        let res = metal_tensor_op(&lhs, &rhs, "sub");
 
-        Ok(lhs)
+        #[cfg(not(feature = "metal"))]
+        let res = {
+            let mut res: Tensor<T> = lhs
+                .par_iter()
+                .zip(rhs)
+                .map(|(o, r)| o.clone() - r)
+                .collect();
+            res.reshape(&broadcasted_shape).unwrap();
+            res
+        };
+
+        Ok(res)
     }
 }
 
-impl<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::Sync> Mul for Tensor<T> {
+impl<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::Sync + IntoI64> Mul
+    for Tensor<T>
+{
     type Output = Result<Tensor<T>, TensorError>;
     /// Elementwise multiplies tensors.
     /// # Arguments
@@ -1427,18 +1673,28 @@ impl<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::Sync> Mu
     /// ```
     fn mul(self, rhs: Self) -> Self::Output {
         let broadcasted_shape = get_broadcasted_shape(self.dims(), rhs.dims()).unwrap();
-        let mut lhs = self.expand(&broadcasted_shape).unwrap();
+        let lhs = self.expand(&broadcasted_shape).unwrap();
         let rhs = rhs.expand(&broadcasted_shape).unwrap();
 
-        lhs.par_iter_mut().zip(rhs).for_each(|(o, r)| {
-            *o = o.clone() * r;
-        });
+        #[cfg(feature = "metal")]
+        let res = metal_tensor_op(&lhs, &rhs, "mul");
 
-        Ok(lhs)
+        #[cfg(not(feature = "metal"))]
+        let res = {
+            let mut res: Tensor<T> = lhs
+                .par_iter()
+                .zip(rhs)
+                .map(|(o, r)| o.clone() * r)
+                .collect();
+            res.reshape(&broadcasted_shape).unwrap();
+            res
+        };
+
+        Ok(res)
     }
 }
 
-impl<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::Sync> Tensor<T> {
+impl<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::Sync + IntoI64> Tensor<T> {
     /// Elementwise raise a tensor to the nth power.
     /// # Arguments
     ///
@@ -1652,4 +1908,66 @@ mod tests {
         let b = Tensor::<i32>::new(Some(&[1, 4]), &[2, 1]).unwrap();
         assert_eq!(a.get_slice(&[0..2, 0..1]).unwrap(), b);
     }
+
+    #[test]
+    #[cfg(feature = "metal")]
+    fn tensor_metal_int() {
+        let a = Tensor::<i64>::new(Some(&[1, 2, 3, 4]), &[2, 2]).unwrap();
+        let b = Tensor::<i64>::new(Some(&[1, 2, 3, 4]), &[2, 2]).unwrap();
+        let c = metal_tensor_op(&a, &b, "add");
+        assert_eq!(c, Tensor::new(Some(&[2, 4, 6, 8]), &[2, 2]).unwrap());
+
+        let c = metal_tensor_op(&a, &b, "sub");
+        assert_eq!(c, Tensor::new(Some(&[0, 0, 0, 0]), &[2, 2]).unwrap());
+
+        let c = metal_tensor_op(&a, &b, "mul");
+        assert_eq!(c, Tensor::new(Some(&[1, 4, 9, 16]), &[2, 2]).unwrap());
+    }
+
+    #[test]
+    #[cfg(feature = "metal")]
+    fn tensor_metal_felt() {
+        use halo2curves::bn256::Fr;
+
+        let a = Tensor::<Fr>::new(
+            Some(&[Fr::from(1), Fr::from(2), Fr::from(3), Fr::from(4)]),
+            &[2, 2],
+        )
+        .unwrap();
+        let b = Tensor::<Fr>::new(
+            Some(&[Fr::from(1), Fr::from(2), Fr::from(3), Fr::from(4)]),
+            &[2, 2],
+        )
+        .unwrap();
+
+        let c = metal_tensor_op(&a, &b, "add");
+        assert_eq!(
+            c,
+            Tensor::<Fr>::new(
+                Some(&[Fr::from(2), Fr::from(4), Fr::from(6), Fr::from(8)]),
+                &[2, 2],
+            )
+            .unwrap()
+        );
+
+        let c = metal_tensor_op(&a, &b, "sub");
+        assert_eq!(
+            c,
+            Tensor::<Fr>::new(
+                Some(&[Fr::from(0), Fr::from(0), Fr::from(0), Fr::from(0)]),
+                &[2, 2],
+            )
+            .unwrap()
+        );
+
+        let c = metal_tensor_op(&a, &b, "mul");
+        assert_eq!(
+            c,
+            Tensor::<Fr>::new(
+                Some(&[Fr::from(1), Fr::from(4), Fr::from(9), Fr::from(16)]),
+                &[2, 2],
+            )
+            .unwrap()
+        );
+    }
 }

src/tensor/val.rs

@@ -1,3 +1,5 @@
+use core::{iter::FilterMap, slice::Iter};
+
 use crate::circuit::region::ConstantsMap;
 
 use super::{
@@ -314,6 +316,12 @@ impl<F: PrimeField + TensorType + PartialOrd> From<Tensor<AssignedCell<F, F>>> f
 }
 
 impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
+    /// Allocate a new [ValTensor::Value] from the given [Tensor] of [i64].
+    pub fn from_i64_tensor(t: Tensor<i64>) -> ValTensor<F> {
+        let inner = t.map(|x| ValType::Value(Value::known(i64_to_felt(x))));
+        inner.into()
+    }
+
     /// Allocate a new [ValTensor::Instance] from the ConstraintSystem with the given tensor `dims`, optionally enabling `equality`.
     pub fn new_instance(
         cs: &mut ConstraintSystem<F>,
@@ -450,10 +458,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
     /// Returns the number of constants in the [ValTensor].
     pub fn create_constants_map_iterator(
         &self,
-    ) -> core::iter::FilterMap<
-        core::slice::Iter<'_, ValType<F>>,
-        fn(&ValType<F>) -> Option<(F, ValType<F>)>,
-    > {
+    ) -> FilterMap<Iter<'_, ValType<F>>, fn(&ValType<F>) -> Option<(F, ValType<F>)>> {
         match self {
             ValTensor::Value { inner, .. } => inner.iter().filter_map(|x| {
                 if let ValType::Constant(v) = x {
@@ -516,9 +521,9 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
     }
 
     /// Calls `int_evals` on the inner tensor.
-    pub fn get_int_evals(&self) -> Result<Tensor<i128>, Box<dyn Error>> {
+    pub fn get_int_evals(&self) -> Result<Tensor<i64>, Box<dyn Error>> {
         // finally convert to vector of integers
-        let mut integer_evals: Vec<i128> = vec![];
+        let mut integer_evals: Vec<i64> = vec![];
         match self {
             ValTensor::Value {
                 inner: v, dims: _, ..
@@ -526,25 +531,25 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
                 // we have to push to an externally created vector or else vaf.map() returns an evaluation wrapped in Value<> (which we don't want)
                 let _ = v.map(|vaf| match vaf {
                     ValType::Value(v) => v.map(|f| {
-                        integer_evals.push(crate::fieldutils::felt_to_i128(f));
+                        integer_evals.push(crate::fieldutils::felt_to_i64(f));
                     }),
                     ValType::AssignedValue(v) => v.map(|f| {
-                        integer_evals.push(crate::fieldutils::felt_to_i128(f.evaluate()));
+                        integer_evals.push(crate::fieldutils::felt_to_i64(f.evaluate()));
                     }),
                     ValType::PrevAssigned(v) | ValType::AssignedConstant(v, ..) => {
                         v.value_field().map(|f| {
-                            integer_evals.push(crate::fieldutils::felt_to_i128(f.evaluate()));
+                            integer_evals.push(crate::fieldutils::felt_to_i64(f.evaluate()));
                         })
                     }
                     ValType::Constant(v) => {
-                        integer_evals.push(crate::fieldutils::felt_to_i128(v));
+                        integer_evals.push(crate::fieldutils::felt_to_i64(v));
                         Value::unknown()
                     }
                 });
             }
             _ => return Err(Box::new(TensorError::WrongMethod)),
         };
-        let mut tensor: Tensor<i128> = integer_evals.into_iter().into();
+        let mut tensor: Tensor<i64> = integer_evals.into_iter().into();
         match tensor.reshape(self.dims()) {
             _ => {}
         };
@@ -874,13 +879,13 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
         };
         Ok(())
     }
-    /// Calls `pad` on the inner [Tensor].
-    pub fn pad(&mut self, padding: [(usize, usize); 2]) -> Result<(), TensorError> {
+    /// Calls `pad_spatial_dims` on the inner [Tensor].
+    pub fn pad(&mut self, padding: Vec<(usize, usize)>, offset: usize) -> Result<(), TensorError> {
         match self {
             ValTensor::Value {
                 inner: v, dims: d, ..
             } => {
-                *v = pad(v, padding)?;
+                *v = pad(v, padding, offset)?;
                 *d = v.dims().to_vec();
             }
             ValTensor::Instance { .. } => {

src/wasm.rs

@@ -1,8 +1,9 @@
+use crate::circuit::modules::polycommit::PolyCommitChip;
 use crate::circuit::modules::poseidon::spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH};
 use crate::circuit::modules::poseidon::PoseidonChip;
 use crate::circuit::modules::Module;
-use crate::fieldutils::felt_to_i128;
-use crate::fieldutils::i128_to_felt;
+use crate::fieldutils::felt_to_i64;
+use crate::fieldutils::i64_to_felt;
 use crate::graph::modules::POSEIDON_LEN_GRAPH;
 use crate::graph::quantize_float;
 use crate::graph::scale_to_multiplier;
@@ -112,7 +113,7 @@ pub fn feltToInt(
     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_i128(felt))
+        serde_json::to_vec(&felt_to_i64(felt))
             .map_err(|e| JsError::new(&format!("Failed to serialize integer: {}", e)))?,
     ))
 }
@@ -126,7 +127,7 @@ pub fn feltToFloat(
 ) -> 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_i128(felt);
+    let int_rep = felt_to_i64(felt);
     let multiplier = scale_to_multiplier(scale);
     Ok(int_rep as f64 / multiplier)
 }
@@ -140,13 +141,51 @@ pub fn floatToFelt(
 ) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
     let int_rep =
         quantize_float(&input, 0.0, scale).map_err(|e| JsError::new(&format!("{}", e)))?;
-    let felt = i128_to_felt(int_rep);
+    let felt = i64_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)]
@@ -236,7 +275,7 @@ pub fn genWitness(
         .map_err(|e| JsError::new(&format!("{}", e)))?;
 
     let witness = circuit
-        .forward::<KZGCommitmentScheme<Bn256>>(&mut input, None, None, false)
+        .forward::<KZGCommitmentScheme<Bn256>>(&mut input, None, None, false, false)
         .map_err(|e| JsError::new(&format!("{}", e)))?;
 
     serde_json::to_vec(&witness)
@@ -337,8 +376,10 @@ pub fn verify(
 
     let orig_n = 1 << circuit_settings.run_args.logrows;
 
+    let commitment = circuit_settings.run_args.commitment.into();
+
     let mut reader = std::io::BufReader::new(&srs[..]);
-    let result = match circuit_settings.run_args.commitment {
+    let result = match commitment {
         Commitments::KZG => {
             let params: ParamsKZG<Bn256> =
                 halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader)
@@ -419,6 +460,8 @@ pub fn verifyAggr(
 
     let commit = Commitments::from_str(commitment).map_err(|e| JsError::new(&format!("{}", e)))?;
 
+    let orig_n = 1 << logrows;
+
     let mut reader = std::io::BufReader::new(&srs[..]);
     let result = match commit {
         Commitments::KZG => {
@@ -433,7 +476,7 @@ pub fn verifyAggr(
                     KZGSingleStrategy<_>,
                     _,
                     EvmTranscript<G1Affine, _, _, _>,
-                >(&proof, &params, &vk, strategy, logrows),
+                >(&proof, &params, &vk, strategy, orig_n),
 
                 TranscriptType::Poseidon => {
                     verify_proof_circuit::<
@@ -442,7 +485,7 @@ pub fn verifyAggr(
                         KZGSingleStrategy<_>,
                         _,
                         PoseidonTranscript<NativeLoader, _>,
-                    >(&proof, &params, &vk, strategy, logrows)
+                    >(&proof, &params, &vk, strategy, orig_n)
                 }
             }
         }
@@ -458,7 +501,7 @@ pub fn verifyAggr(
                     IPASingleStrategy<_>,
                     _,
                     EvmTranscript<G1Affine, _, _, _>,
-                >(&proof, &params, &vk, strategy, logrows),
+                >(&proof, &params, &vk, strategy, orig_n),
                 TranscriptType::Poseidon => {
                     verify_proof_circuit::<
                         VerifierIPA<_>,
@@ -466,7 +509,7 @@ pub fn verifyAggr(
                         IPASingleStrategy<_>,
                         _,
                         PoseidonTranscript<NativeLoader, _>,
-                    >(&proof, &params, &vk, strategy, logrows)
+                    >(&proof, &params, &vk, strategy, orig_n)
                 }
             }
         }
@@ -519,8 +562,9 @@ pub fn prove(
 
     // read in kzg params
     let mut reader = std::io::BufReader::new(&srs[..]);
+    let commitment = circuit.settings().run_args.commitment.into();
     // creates and verifies the proof
-    let proof = match circuit.settings().run_args.commitment {
+    let proof = match commitment {
         Commitments::KZG => {
             let params: ParamsKZG<Bn256> =
                 halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader)

tests/integration_tests.rs

@@ -3,7 +3,7 @@
 mod native_tests {
 
     use ezkl::circuit::Tolerance;
-    use ezkl::fieldutils::{felt_to_i128, i128_to_felt};
+    use ezkl::fieldutils::{felt_to_i64, i64_to_felt};
     // use ezkl::circuit::table::RESERVED_BLINDING_ROWS_PAD;
     use ezkl::graph::input::{FileSource, FileSourceInner, GraphData};
     use ezkl::graph::{DataSource, GraphSettings, GraphWitness};
@@ -122,7 +122,7 @@ mod native_tests {
         let settings: GraphSettings = serde_json::from_str(&settings).unwrap();
         let logrows = settings.run_args.logrows;
 
-        download_srs(logrows, settings.run_args.commitment);
+        download_srs(logrows, settings.run_args.commitment.into());
     }
 
     fn mv_test_(test_dir: &str, test: &str) {
@@ -200,7 +200,7 @@ mod native_tests {
         "1l_tiny_div",
     ];
 
-    const TESTS: [&str; 91] = [
+    const TESTS: [&str; 93] = [
         "1l_mlp", //0
         "1l_slice",
         "1l_concat",
@@ -296,6 +296,8 @@ mod native_tests {
         "reducel1",
         "reducel2", // 89
         "1l_lppool",
+        "lstm_large",  // 91
+        "lstm_medium", // 92
     ];
 
     const WASM_TESTS: [&str; 46] = [
@@ -534,7 +536,7 @@ mod native_tests {
             }
         });
 
-            seq!(N in 0..=90 {
+            seq!(N in 0..=92 {
 
             #(#[test_case(TESTS[N])])*
             #[ignore]
@@ -622,7 +624,7 @@ mod native_tests {
             #(#[test_case(TESTS[N])])*
             fn mock_large_batch_public_outputs_(test: &str) {
                 // currently variable output rank is not supported in ONNX
-                if test != "gather_nd" {
+                if test != "gather_nd" && test != "lstm_large"  && test != "lstm_medium" {
                     crate::native_tests::init_binary();
                     let test_dir = TempDir::new(test).unwrap();
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
@@ -898,7 +900,7 @@ mod native_tests {
             seq!(N in 0..=45 {
 
                 #(#[test_case(WASM_TESTS[N])])*
-                fn prove_and_verify_with_overflow_(test: &str) {
+                fn kzg_prove_and_verify_with_overflow_(test: &str) {
                     crate::native_tests::init_binary();
                     // crate::native_tests::init_wasm();
                     let test_dir = TempDir::new(test).unwrap();
@@ -907,11 +909,24 @@ mod native_tests {
                     prove_and_verify(path, test.to_string(), "safe", "private", "private", "public", 1, None, true, "single", Commitments::KZG, 2);
                     #[cfg(not(feature = "icicle"))]
                     run_js_tests(path, test.to_string(), "testWasm", false);
-                    // test_dir.close().unwrap();
+                    test_dir.close().unwrap();
                 }
 
                 #(#[test_case(WASM_TESTS[N])])*
-                fn prove_and_verify_with_overflow_fixed_params_(test: &str) {
+                fn kzg_prove_and_verify_with_overflow_hashed_inputs_(test: &str) {
+                    crate::native_tests::init_binary();
+                    // crate::native_tests::init_wasm();
+                    let test_dir = TempDir::new(test).unwrap();
+                    env_logger::init();
+                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
+                    prove_and_verify(path, test.to_string(), "safe", "hashed", "private", "public", 1, None, true, "single", Commitments::KZG, 2);
+                    #[cfg(not(feature = "icicle"))]
+                    run_js_tests(path, test.to_string(), "testWasm", false);
+                    test_dir.close().unwrap();
+                }
+
+                #(#[test_case(WASM_TESTS[N])])*
+                fn kzg_prove_and_verify_with_overflow_fixed_params_(test: &str) {
                     crate::native_tests::init_binary();
                     // crate::native_tests::init_wasm();
                     let test_dir = TempDir::new(test).unwrap();
@@ -1359,7 +1374,7 @@ mod native_tests {
             let witness = witness.clone();
             let outputs = witness.outputs.clone();
 
-            // get values as i128
+            // get values as i64
             let output_perturbed_safe: Vec<Vec<halo2curves::bn256::Fr>> = outputs
                 .iter()
                 .map(|sv| {
@@ -1369,10 +1384,10 @@ mod native_tests {
                             let perturbation = if v == &halo2curves::bn256::Fr::zero() {
                                 halo2curves::bn256::Fr::zero()
                             } else {
-                                i128_to_felt(
-                                    (felt_to_i128(*v) as f32
+                                i64_to_felt(
+                                    (felt_to_i64(*v) as f32
                                         * (rand::thread_rng().gen_range(-0.01..0.01) * tolerance))
-                                        as i128,
+                                        as i64,
                                 )
                             };
 
@@ -1382,7 +1397,7 @@ mod native_tests {
                 })
                 .collect::<Vec<_>>();
 
-            // get values as i128
+            // get values as i64
             let output_perturbed_bad: Vec<Vec<halo2curves::bn256::Fr>> = outputs
                 .iter()
                 .map(|sv| {
@@ -1392,10 +1407,10 @@ mod native_tests {
                             let perturbation = if v == &halo2curves::bn256::Fr::zero() {
                                 halo2curves::bn256::Fr::from(2)
                             } else {
-                                i128_to_felt(
-                                    (felt_to_i128(*v) as f32
+                                i64_to_felt(
+                                    (felt_to_i64(*v) as f32
                                         * (rand::thread_rng().gen_range(0.02..0.1) * tolerance))
-                                        as i128,
+                                        as i64,
                                 )
                             };
                             *v + perturbation
@@ -1970,7 +1985,7 @@ mod native_tests {
             .expect("failed to parse settings file");
 
         // get_srs for the graph_settings_num_instances
-        download_srs(1, graph_settings.run_args.commitment);
+        download_srs(1, graph_settings.run_args.commitment.into());
 
         let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([

tests/py_integration_tests.rs

@@ -56,33 +56,38 @@ mod py_tests {
             // source .env/bin/activate
             // pip install -r requirements.txt
             // maturin develop --release --features python-bindings
-
+            // first install tf2onnx as it has protobuf conflict with onnx
+            let status = Command::new("pip")
+                .args(["install", "tf2onnx==1.16.1"])
+                .status()
+                .expect("failed to execute process");
+            assert!(status.success());
             // now install torch, pandas, numpy, seaborn, jupyter
             let status = Command::new("pip")
                 .args([
                     "install",
-                    "torch-geometric==2.5.0",
-                    "torch==2.0.1",
-                    "torchvision==0.15.2",
-                    "pandas==2.0.3",
-                    "numpy==1.23",
-                    "seaborn==0.12.2",
-                    "jupyter==1.0.0",
-                    "onnx==1.14.0",
-                    "kaggle==1.5.15",
-                    "py-solc-x==1.1.1",
-                    "web3==6.5.0",
-                    "librosa==0.10.0.post2",
-                    "keras==2.12.0",
-                    "tensorflow==2.12.0",
-                    "tensorflow-datasets==4.9.3",
-                    "tf2onnx==1.14.0",
-                    "pytorch-lightning==2.0.6",
+                    "torch-geometric==2.5.2",
+                    "torch==2.2.2",
+                    "torchvision==0.17.2",
+                    "pandas==2.2.1",
+                    "numpy==1.26.4",
+                    "seaborn==0.13.2",
+                    "notebook==7.1.2",
+                    "nbconvert==7.16.3",
+                    "onnx==1.16.0",
+                    "kaggle==1.6.8",
+                    "py-solc-x==2.0.2",
+                    "web3==6.16.0",
+                    "librosa==0.10.1",
+                    "keras==3.1.1",
+                    "tensorflow==2.16.1",
+                    "tensorflow-datasets==4.9.4",
+                    "pytorch-lightning==2.2.1",
                     "sk2torch==1.2.0",
-                    "scikit-learn==1.3.1",
-                    "xgboost==1.7.6",
-                    "hummingbird-ml==0.4.9",
-                    "lightgbm==4.0.0",
+                    "scikit-learn==1.4.1.post1",
+                    "xgboost==2.0.3",
+                    "hummingbird-ml==0.4.11",
+                    "lightgbm==4.3.0",
                 ])
                 .status()
                 .expect("failed to execute process");
@@ -118,7 +123,7 @@ mod py_tests {
         }
     }
 
-    const TESTS: [&str; 32] = [
+    const TESTS: [&str; 33] = [
         "proof_splitting.ipynb", // 0
         "variance.ipynb",
         "mnist_gan.ipynb",
@@ -152,6 +157,7 @@ mod py_tests {
         "generalized_inverse.ipynb",
         "mnist_classifier.ipynb", // 30
         "world_rotation.ipynb",
+        "logistic_regression.ipynb",
     ];
 
     macro_rules! test_func {
@@ -164,7 +170,7 @@ mod py_tests {
             use super::*;
 
 
-            seq!(N in 0..=31 {
+            seq!(N in 0..=32 {
 
             #(#[test_case(TESTS[N])])*
             fn run_notebook_(test: &str) {

tests/wasm.rs

@@ -1,21 +1,29 @@
 #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
 #[cfg(test)]
 mod wasm32 {
+    use ezkl::circuit::modules::polycommit::PolyCommitChip;
     use ezkl::circuit::modules::poseidon::spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH};
     use ezkl::circuit::modules::poseidon::PoseidonChip;
     use ezkl::circuit::modules::Module;
     use ezkl::graph::modules::POSEIDON_LEN_GRAPH;
-    use ezkl::graph::GraphWitness;
+    use ezkl::graph::GraphCircuit;
+    use ezkl::graph::{GraphSettings, GraphWitness};
     use ezkl::pfsys;
     use ezkl::wasm::{
         bufferToVecOfFelt, compiledCircuitValidation, encodeVerifierCalldata, feltToBigEndian,
         feltToFloat, feltToInt, feltToLittleEndian, genPk, genVk, genWitness, inputValidation,
-        pkValidation, poseidonHash, proofValidation, prove, settingsValidation, srsValidation,
-        u8_array_to_u128_le, verify, vkValidation, witnessValidation,
+        kzgCommit, pkValidation, poseidonHash, proofValidation, prove, settingsValidation,
+        srsValidation, u8_array_to_u128_le, verify, verifyAggr, vkValidation, witnessValidation,
     };
+    use halo2_proofs::plonk::VerifyingKey;
+    use halo2_proofs::poly::commitment::CommitmentScheme;
+    use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+    use halo2_proofs::poly::kzg::commitment::ParamsKZG;
     use halo2_solidity_verifier::encode_calldata;
+    use halo2curves::bn256::Bn256;
     use halo2curves::bn256::{Fr, G1Affine};
     use snark_verifier::util::arithmetic::PrimeField;
+    use wasm_bindgen::JsError;
     #[cfg(feature = "web")]
     pub use wasm_bindgen_rayon::init_thread_pool;
     use wasm_bindgen_test::*;
@@ -27,10 +35,29 @@ mod wasm32 {
     pub const NETWORK: &[u8] = include_bytes!("../tests/wasm/network.onnx");
     pub const INPUT: &[u8] = include_bytes!("../tests/wasm/input.json");
     pub const PROOF: &[u8] = include_bytes!("../tests/wasm/proof.json");
+    pub const PROOF_AGGR: &[u8] = include_bytes!("../tests/wasm/proof_aggr.json");
     pub const SETTINGS: &[u8] = include_bytes!("../tests/wasm/settings.json");
     pub const PK: &[u8] = include_bytes!("../tests/wasm/pk.key");
     pub const VK: &[u8] = include_bytes!("../tests/wasm/vk.key");
+    pub const VK_AGGR: &[u8] = include_bytes!("../tests/wasm/vk_aggr.key");
     pub const SRS: &[u8] = include_bytes!("../tests/wasm/kzg");
+    pub const SRS1: &[u8] = include_bytes!("../tests/wasm/kzg1.srs");
+
+    #[wasm_bindgen_test]
+    async fn can_verify_aggr() {
+        let value = verifyAggr(
+            wasm_bindgen::Clamped(PROOF_AGGR.to_vec()),
+            wasm_bindgen::Clamped(VK_AGGR.to_vec()),
+            21,
+            wasm_bindgen::Clamped(SRS1.to_vec()),
+            "kzg",
+        )
+        .map_err(|_| "failed")
+        .unwrap();
+
+        // should not fail
+        assert!(value);
+    }
 
     #[wasm_bindgen_test]
     async fn verify_encode_verifier_calldata() {
@@ -71,6 +98,45 @@ mod wasm32 {
         assert_eq!(calldata, reference_calldata);
     }
 
+    #[wasm_bindgen_test]
+    fn verify_kzg_commit() {
+        // create a vector of field elements Vec<Fr> and assign it to the message variable
+        let mut message: Vec<Fr> = vec![];
+        for i in 0..32 {
+            message.push(Fr::from(i as u64));
+        }
+        let message_ser = serde_json::to_vec(&message).unwrap();
+
+        let settings: GraphSettings = serde_json::from_slice(&SETTINGS).unwrap();
+        let mut reader = std::io::BufReader::new(SRS);
+        let params: ParamsKZG<Bn256> =
+            halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader).unwrap();
+        let mut reader = std::io::BufReader::new(VK);
+        let vk = VerifyingKey::<G1Affine>::read::<_, GraphCircuit>(
+            &mut reader,
+            halo2_proofs::SerdeFormat::RawBytes,
+            settings.clone(),
+        )
+        .unwrap();
+        let commitment_ser = kzgCommit(
+            wasm_bindgen::Clamped(message_ser),
+            wasm_bindgen::Clamped(VK.to_vec()),
+            wasm_bindgen::Clamped(SETTINGS.to_vec()),
+            wasm_bindgen::Clamped(SRS.to_vec()),
+        )
+        .map_err(|_| "failed")
+        .unwrap();
+        let commitment: Vec<halo2curves::bn256::G1Affine> =
+            serde_json::from_slice(&commitment_ser[..]).unwrap();
+        let reference_commitment = PolyCommitChip::commit::<KZGCommitmentScheme<Bn256>>(
+            message,
+            (vk.cs().blinding_factors() + 1) as u32,
+            &params,
+        );
+
+        assert_eq!(commitment, reference_commitment);
+    }
+
     #[wasm_bindgen_test]
     async fn verify_field_serialization_roundtrip() {
         for i in 0..32 {
@@ -84,10 +150,10 @@ mod wasm32 {
                 .unwrap();
             assert_eq!(floating_point, (i as f64) / 4.0);
 
-            let integer: i128 =
+            let integer: i64 =
                 serde_json::from_slice(&feltToInt(clamped.clone()).map_err(|_| "failed").unwrap())
                     .unwrap();
-            assert_eq!(integer, i as i128);
+            assert_eq!(integer, i as i64);
 
             let hex_string = format!("{:?}", field_element.clone());
             let returned_string: String = feltToBigEndian(clamped.clone())

tests/wasm/settings.json

@@ -24,8 +24,7 @@
         "param_visibility": "Private",
         "div_rebasing": false,
         "rebase_frac_zero_constants": false,
-        "check_mode": "UNSAFE",
-        "commitment": "KZG"
+        "check_mode": "UNSAFE"
     },
     "num_rows": 16,
     "total_dynamic_col_size": 0,