ci: update version string in docs

.github/workflows/benchmarks.yml

@@ -12,10 +12,10 @@ jobs:
       contents: read
     runs-on: self-hosted
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -29,10 +29,10 @@ jobs:
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -46,10 +46,10 @@ jobs:
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -63,10 +63,10 @@ jobs:
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -80,10 +80,10 @@ jobs:
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -97,10 +97,10 @@ jobs:
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -114,10 +114,10 @@ jobs:
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -131,10 +131,10 @@ jobs:
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -148,10 +148,10 @@ jobs:
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -165,10 +165,10 @@ jobs:
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -182,10 +182,10 @@ jobs:
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
           override: true

.github/workflows/engine.yml

@@ -24,15 +24,15 @@ jobs:
     runs-on: ubuntu-latest
     if: startsWith(github.ref, 'refs/tags/')
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: jetli/wasm-pack-action@0d096b08b4e5a7de8c28de67e11e945404e9eefa  #v0.4.0
+      - uses: jetli/wasm-pack-action@v0.4.0
         with:
           # Pin to version 0.12.1
           version: 'v0.12.1'
@@ -40,17 +40,13 @@ jobs:
         run: rustup target add wasm32-unknown-unknown
 
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2025-02-17-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
       - name: Install binaryen
         run: |
           set -e
           curl -L https://github.com/WebAssembly/binaryen/releases/download/version_116/binaryen-version_116-x86_64-linux.tar.gz | tar xzf -
           export PATH=$PATH:$PWD/binaryen-version_116/bin
           wasm-opt --version
-      - name: Build wasm files for both web and nodejs compilation targets
-        run: |
-            wasm-pack build --release --target nodejs --out-dir ./pkg/nodejs . -- -Z build-std="panic_abort,std"
-            wasm-pack build --release --target web --out-dir ./pkg/web . -- -Z build-std="panic_abort,std" --features web
       - name: Create package.json in pkg folder
         shell: bash
         run: |
@@ -176,7 +172,7 @@ jobs:
           curl -s "https://raw.githubusercontent.com/zkonduit/ezkljs-engine/main/README.md" > ./pkg/README.md
 
       - name: Set up Node.js
-        uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7  #v3.8.2
+        uses: actions/setup-node@v3
         with:
           node-version: "18.12.1"
           registry-url: "https://registry.npmjs.org"
@@ -201,7 +197,7 @@ jobs:
         RELEASE_TAG: ${{ github.ref_name }}
     if: startsWith(github.ref, 'refs/tags/')
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
       - name: Update version in package.json
@@ -230,13 +226,13 @@ jobs:
           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
+          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@eae0cfeb286e66ffb5155f1a79b90583a127a68b  #v2.4.1
+        uses: pnpm/action-setup@v2
         with:
           version: 8
       - name: Set up Node.js
-        uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7  #v3.8.2
+        uses: actions/setup-node@v3
         with:
           node-version: "18.12.1"
           registry-url: "https://registry.npmjs.org"
@@ -247,4 +243,4 @@ jobs:
           pnpm run build
           pnpm publish --no-git-checks
         env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}  

.github/workflows/large-tests.yml

@@ -10,12 +10,12 @@ jobs:
       contents: read
     runs-on: kaiju
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - name: nanoGPT Mock

.github/workflows/pypi-gpu.yml

@@ -28,36 +28,34 @@ jobs:
     env:
       RELEASE_TAG: ${{ github.ref_name }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
+      - uses: actions/setup-python@v4
         with:
           python-version: 3.12
           architecture: x64
 
-      - name: Set pyproject.toml version to match github tag and rename ezkl to ezkl-gpu
+      - name: Set pyproject.toml version to match github tag
         shell: bash
         run: |
             mv pyproject.toml pyproject.toml.orig
-            sed "s/ezkl/ezkl-gpu/" pyproject.toml.orig > pyproject.toml.tmp
-            sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" pyproject.toml.tmp > pyproject.toml
+            sed "s/ezkl/ezkl-gpu/" pyproject.toml.orig >pyproject.toml
+            sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" pyproject.toml.orig >pyproject.toml
 
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly-2023-06-27
           override: true
           components: rustfmt, clippy
 
-      - name: Set Cargo.toml version to match github tag and rename ezkl to ezkl-gpu
+      - name: Set Cargo.toml version to match github tag
         shell: bash
-        # the ezkl substitution here looks for the first instance of name = "ezkl" and changes it to "ezkl-gpu"
         run: |
           mv Cargo.toml Cargo.toml.orig
-          sed "0,/name = \"ezkl\"/s/name = \"ezkl\"/name = \"ezkl-gpu\"/" Cargo.toml.orig > Cargo.toml.tmp
-          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.toml.tmp > Cargo.toml
+          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.toml.orig >Cargo.toml
           mv Cargo.lock Cargo.lock.orig
-          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig > Cargo.lock
+          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig >Cargo.lock
 
       - name: Install required libraries
         shell: bash
@@ -65,7 +63,7 @@ jobs:
           sudo apt-get update && sudo apt-get install -y openssl pkg-config libssl-dev
 
       - name: Build wheels
-        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
+        uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
           manylinux: auto
@@ -78,7 +76,7 @@ jobs:
           pip install ezkl-gpu --no-index --find-links dist --force-reinstall
 
       - name: Upload wheels
-        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08  #v4.6.0
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
@@ -94,7 +92,7 @@ jobs:
     # needs: [ macos, windows, linux, linux-cross, musllinux, musllinux-cross ]
     needs: [linux]
     steps:
-      - uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16  #v4.1.8
+      - uses: actions/download-artifact@v3
         with:
           name: wheels
       - name: List Files
@@ -106,14 +104,14 @@ jobs:
       # publishes to PyPI
       - name: Publish package distributions to PyPI
         continue-on-error: true
-        uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc  #v1.12.4
+        uses: pypa/gh-action-pypi-publish@unstable/v1
         with:
-          packages-dir: ./wheels
+          packages-dir: ./
 
       # publishes to TestPyPI
       - name: Publish package distribution to TestPyPI
         continue-on-error: true
-        uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc  #v1.12.4
+        uses: pypa/gh-action-pypi-publish@unstable/v1
         with:
           repository-url: https://test.pypi.org/legacy/
-          packages-dir: ./wheels
+          packages-dir: ./

.github/workflows/pypi.yml

@@ -26,10 +26,10 @@ jobs:
     env:
         RELEASE_TAG: ${{ github.ref_name }}
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
-        with:
+      - uses: actions/checkout@v4
+        with: 
           persist-credentials: false
-      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
+      - uses: actions/setup-python@v4
         with:
           python-version: 3.12
           architecture: x64
@@ -48,21 +48,21 @@ jobs:
           mv Cargo.lock Cargo.lock.orig
           sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig >Cargo.lock
 
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
 
       - name: Build wheels
         if: matrix.target == 'universal2-apple-darwin'
-        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
+        uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
           args: --release --out dist --features python-bindings
       - name: Build wheels
         if: matrix.target == 'x86_64'
-        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
+        uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
           args: --release --out dist --features python-bindings
@@ -73,9 +73,9 @@ jobs:
           python -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08  #v4.6.0
+        uses: actions/upload-artifact@v3
         with:
-          name: dist-macos-${{ matrix.target }}
+          name: wheels
           path: dist
 
   windows:
@@ -87,10 +87,10 @@ jobs:
       matrix:
         target: [x64, x86]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
-        with:
+      - uses: actions/checkout@v4
+        with: 
           persist-credentials: false
-      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
+      - uses: actions/setup-python@v4
         with:
           python-version: 3.12
           architecture: ${{ matrix.target }}
@@ -113,14 +113,14 @@ jobs:
           mv Cargo.lock Cargo.lock.orig
           sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig >Cargo.lock
 
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
 
       - name: Build wheels
-        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
+        uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
           args: --release --out dist --features python-bindings
@@ -130,9 +130,9 @@ jobs:
           python -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08  #v4.6.0 #v4.6.0
+        uses: actions/upload-artifact@v3
         with:
-          name: dist-windows-${{ matrix.target }}
+          name: wheels
           path: dist
 
   linux:
@@ -144,10 +144,10 @@ jobs:
       matrix:
         target: [x86_64]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
-        with:
+      - uses: actions/checkout@v4
+        with: 
           persist-credentials: false
-      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
+      - uses: actions/setup-python@v4
         with:
           python-version: 3.12
           architecture: x64
@@ -176,7 +176,7 @@ jobs:
           sudo apt-get update && sudo apt-get install -y openssl pkg-config libssl-dev
 
       - name: Build wheels
-        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
+        uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
           manylinux: auto
@@ -203,9 +203,9 @@ jobs:
           python -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08  #v4.6.0
+        uses: actions/upload-artifact@v3
         with:
-          name: dist-linux-${{ matrix.target }}
+          name: wheels
           path: dist
 
   musllinux:
@@ -218,10 +218,10 @@ jobs:
         target:
           - x86_64-unknown-linux-musl
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
-        with:
+      - uses: actions/checkout@v4
+        with: 
           persist-credentials: false
-      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
+      - uses: actions/setup-python@v4
         with:
           python-version: 3.12
           architecture: x64
@@ -250,7 +250,7 @@ jobs:
           sudo apt-get update && sudo apt-get install -y pkg-config libssl-dev
 
       - name: Build wheels
-        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
+        uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
           manylinux: musllinux_1_2
@@ -271,9 +271,9 @@ jobs:
             python3 -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08  #v4.6.0
+        uses: actions/upload-artifact@v3
         with:
-          name: dist-musllinux-${{ matrix.target }}
+          name: wheels
           path: dist
 
   musllinux-cross:
@@ -287,10 +287,10 @@ jobs:
           - target: aarch64-unknown-linux-musl
             arch: aarch64
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
-        with:
+      - uses: actions/checkout@v4
+        with: 
           persist-credentials: false
-      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
+      - uses: actions/setup-python@v4
         with:
           python-version: 3.12
 
@@ -313,13 +313,13 @@ jobs:
           sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig >Cargo.lock
 
       - name: Build wheels
-        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
+        uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.platform.target }}
           manylinux: musllinux_1_2
           args: --release --out dist --features python-bindings
 
-      - uses: uraimo/run-on-arch-action@5397f9e30a9b62422f302092631c99ae1effcd9e  #v2.8.1
+      - uses: uraimo/run-on-arch-action@v2.8.1
         name: Install built wheel
         with:
           arch: ${{ matrix.platform.arch }}
@@ -334,9 +334,9 @@ jobs:
             python3 -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08  #v4.6.0
+        uses: actions/upload-artifact@v3
         with:
-          name: dist-musllinux-${{ matrix.platform.target }}
+          name: wheels
           path: dist
 
   pypi-publish:
@@ -347,26 +347,24 @@ jobs:
     if: "startsWith(github.ref, 'refs/tags/')"
     needs: [macos, windows, linux, musllinux, musllinux-cross]
     steps:
-      - uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16  #v4.1.8
+      - uses: actions/download-artifact@v3
         with:
-          pattern: dist-*
-          merge-multiple: true
-          path: wheels
+          name: wheels
       - name: List Files
         run: ls -R
-
+      
       # # publishes to TestPyPI
       # - name: Publish package distribution to TestPyPI
-      #   uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc  #v1.12.4
+      #   uses: pypa/gh-action-pypi-publish@unstable/v1
       #   with:
       #     repository-url: https://test.pypi.org/legacy/
       #     packages-dir: ./
 
       # publishes to PyPI
       - name: Publish package distributions to PyPI
-        uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc  #v1.12.4
+        uses: pypa/gh-action-pypi-publish@unstable/v1
         with:
-          packages-dir: ./wheels
+          packages-dir: ./
 
 
   doc-publish:
@@ -377,7 +375,7 @@ jobs:
     needs: pypi-publish
     steps:
       - uses: actions/checkout@v4
-        with:
+        with: 
           persist-credentials: false
       - name: Trigger RTDs build
         uses: dfm/rtds-action@v1

.github/workflows/release.yml

@@ -30,7 +30,7 @@ jobs:
 
       - name: Create Github Release
         id: create-release
-        uses: softprops/action-gh-release@c95fe1489396fe8a9eb87c0abf8aa5b2ef267fda  #v2.2.1
+        uses: softprops/action-gh-release@v1
         with:
           token: ${{ secrets.RELEASE_TOKEN }}
           tag_name: ${{ env.EZKL_VERSION }}
@@ -49,14 +49,14 @@ jobs:
       RUST_BACKTRACE: 1
       PCRE2_SYS_STATIC: 1
     steps:
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
-        with:
+        uses: actions/checkout@v4
+        with: 
           persist-credentials: false
 
 
@@ -90,7 +90,7 @@ jobs:
           echo "ASSET=build-artifacts/ezkl-linux-gpu.tar.gz" >> $GITHUB_ENV
 
       - name: Upload release archive
-        uses: actions/upload-release-asset@e8f9f06c4b078e705bd2ea027f0926603fc9b4d5  #v1.0.2
+        uses: actions/upload-release-asset@v1.0.2
         env:
           GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
         with:
@@ -119,33 +119,33 @@ jobs:
         include:
           - build: windows-msvc
             os: windows-latest
-            rust: nightly-2025-02-17
+            rust: nightly-2024-07-18
             target: x86_64-pc-windows-msvc
           - build: macos
             os: macos-13
-            rust: nightly-2025-02-17
+            rust: nightly-2024-07-18
             target: x86_64-apple-darwin
           - build: macos-aarch64
             os: macos-13
-            rust: nightly-2025-02-17
+            rust: nightly-2024-07-18
             target: aarch64-apple-darwin
           - build: linux-musl
             os: ubuntu-22.04
-            rust: nightly-2025-02-17
+            rust: nightly-2024-07-18
             target: x86_64-unknown-linux-musl
           - build: linux-gnu
             os: ubuntu-22.04
-            rust: nightly-2025-02-17
+            rust: nightly-2024-07-18
             target: x86_64-unknown-linux-gnu
           - build: linux-aarch64
             os: ubuntu-22.04
-            rust: nightly-2025-02-17
+            rust: nightly-2024-07-18
             target: aarch64-unknown-linux-gnu
 
     steps:
       - name: Checkout repo
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
-        with:
+        uses: actions/checkout@v4
+        with: 
           persist-credentials: false
 
       - name: Get release version from tag
@@ -170,7 +170,7 @@ jobs:
           fi
 
       - name: Install Rust
-        uses: dtolnay/rust-toolchain@4f94fbe7e03939b0e674bcc9ca609a16088f63ff  #nightly branch, TODO: update when required
+        uses: dtolnay/rust-toolchain@nightly
         with:
           target: ${{ matrix.target }}
 
@@ -196,7 +196,7 @@ jobs:
           echo "target flag is: ${{ env.TARGET_FLAGS }}"
           echo "target dir is: ${{ env.TARGET_DIR }}"
 
-      - name: Build release binary (no asm or metal)
+      - name: Build release binary (no asm or metal) 
         if: matrix.build != 'linux-gnu' && matrix.build != 'macos-aarch64'
         run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry
 
@@ -233,7 +233,7 @@ jobs:
           echo "ASSET=build-artifacts/ezkl-win.zip" >> $GITHUB_ENV
 
       - name: Upload release archive
-        uses: actions/upload-release-asset@e8f9f06c4b078e705bd2ea027f0926603fc9b4d5  #v1.0.2
+        uses: actions/upload-release-asset@v1.0.2
         env:
           GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
         with:

.github/workflows/rust.yml

@@ -20,37 +20,32 @@ env:
 
 jobs:
   fr-age-test:
-    needs: [build, library-tests, docs, python-tests, python-integration-tests]
     permissions:
       contents: read
     runs-on: large-self-hosted
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@v1
-        with:
-          crate: cargo-nextest
-          locked: true
       - name: fr age Mock
-        run: cargo nextest run --release --verbose tests::large_mock_::large_tests_6_expects -- --include-ignored
+        run: cargo test --release --verbose tests::large_mock_::large_tests_6_expects -- --include-ignored
 
   build:
     permissions:
       contents: read
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - name: Build
@@ -61,12 +56,12 @@ jobs:
       contents: read
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - name: Docs
@@ -77,15 +72,15 @@ jobs:
       contents: read
     runs-on: ubuntu-latest-32-cores
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
@@ -102,21 +97,25 @@ jobs:
   #   env:
   #     ENABLE_ICICLE_GPU: true
   #   steps:
-  #     - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+  #     - uses: actions/checkout@v4
   # with:
   #   persist-credentials: false
-  #     - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+  #     - uses: actions-rs/toolchain@v1
   #       with:
-  #         toolchain: nightly-2025-02-17
+  #         toolchain: nightly-2024-07-18
   #         override: true
   #         components: rustfmt, clippy
-  #     - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+  #     - uses: baptiste0928/cargo-install@v1
   #       with:
   #         crate: cargo-nextest
   #         locked: true
-  #     - uses: mwilliamson/setup-wasmtime-action@bf814d7d8fc3c3a77dfe114bd9fb8a2c575f6ad6  #v2.0.0
+  #     - uses: mwilliamson/setup-wasmtime-action@v2
   #       with:
   #         wasmtime-version: "3.0.1"
+  #     - name: Install wasm32-wasi
+  #       run: rustup target add wasm32-wasi
+  #     - name: Install cargo-wasi
+  #       run: cargo install cargo-wasi
   #     # - name: Matmul overflow (wasi)
   #     #   run: cargo wasi test matmul_col_ultra_overflow -- --include-ignored --nocapture
   #     # - name: Conv overflow (wasi)
@@ -135,81 +134,89 @@ jobs:
       contents: read
     runs-on: non-gpu
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
-      - uses: mwilliamson/setup-wasmtime-action@bf814d7d8fc3c3a77dfe114bd9fb8a2c575f6ad6  #v2.0.0
+      - uses: mwilliamson/setup-wasmtime-action@v2
         with:
           wasmtime-version: "3.0.1"
+      - name: Install wasm32-wasi
+        run: rustup target add wasm32-wasi
+      - name: Install cargo-wasi
+        run: cargo install cargo-wasi
       # - name: Matmul overflow (wasi)
       #   run: cargo wasi test matmul_col_ultra_overflow -- --include-ignored --nocapture
       # - name: Conv overflow (wasi)
       #   run: cargo wasi test conv_col_ultra_overflow -- --include-ignored --nocapture
       - name: lookup overflow
-        run: cargo nextest run --release lookup_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
+        run: cargo nextest run  --release lookup_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
       - name: Matmul overflow
-        run: RUST_LOG=debug cargo nextest run --release matmul_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
+        run: RUST_LOG=debug cargo nextest run matmul_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
       - name: Conv overflow
-        run: RUST_LOG=debug cargo nextest run --release conv_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
+        run: RUST_LOG=debug cargo nextest run conv_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
       - name: Conv + relu overflow
-        run: cargo nextest run --release conv_relu_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
+        run: cargo nextest run  --release conv_relu_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
 
   ultra-overflow-tests:
     permissions:
       contents: read
     runs-on: non-gpu
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
-      - uses: mwilliamson/setup-wasmtime-action@bf814d7d8fc3c3a77dfe114bd9fb8a2c575f6ad6  #v2.0.0
+      - uses: mwilliamson/setup-wasmtime-action@v2
         with:
           wasmtime-version: "3.0.1"
+      - name: Install wasm32-wasi
+        run: rustup target add wasm32-wasi
+      - name: Install cargo-wasi
+        run: cargo install cargo-wasi
       # - name: Matmul overflow (wasi)
       #   run: cargo wasi test matmul_col_ultra_overflow -- --include-ignored --nocapture
       # - name: Conv overflow (wasi)
       #   run: cargo wasi test conv_col_ultra_overflow -- --include-ignored --nocapture
       - name: lookup overflow
-        run: cargo nextest run lookup_ultra_overflow --no-capture -- --include-ignored
+        run: cargo nextest run  --release lookup_ultra_overflow --no-capture -- --include-ignored
       - name: Matmul overflow
         run: RUST_LOG=debug cargo nextest run matmul_col_ultra_overflow --no-capture -- --include-ignored
       - name: Conv overflow
-        run: RUST_LOG=debug cargo nextest run --release conv_col_ultra_overflow --no-capture -- --include-ignored
+        run: RUST_LOG=debug cargo nextest run conv_col_ultra_overflow --no-capture -- --include-ignored
       - name: Conv + relu overflow
-        run: cargo nextest run --release conv_relu_col_ultra_overflow --no-capture -- --include-ignored
+        run: cargo nextest run  --release conv_relu_col_ultra_overflow --no-capture -- --include-ignored
 
   model-serialization:
     permissions:
       contents: read
     runs-on: ubuntu-latest-16-cores
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
@@ -219,27 +226,27 @@ jobs:
   wasm32-tests:
     permissions:
       contents: read
-    runs-on: non-gpu
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: jetli/wasm-pack-action@0d096b08b4e5a7de8c28de67e11e945404e9eefa  #v0.4.0
+      - uses: jetli/wasm-pack-action@v0.4.0
         with:
           # Pin to version 0.12.1
           version: "v0.12.1"
-      - uses: nanasess/setup-chromedriver@e93e57b843c0c92788f22483f1a31af8ee48db25  #v2.3.0
+      - uses: nanasess/setup-chromedriver@v2
         # with:
         #   chromedriver-version: "115.0.5790.102"
       - name: Install wasm32-unknown-unknown
         run: rustup target add wasm32-unknown-unknown
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2025-02-17-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
       - name: Run wasm verifier tests
         # on mac:
         #   AR=/opt/homebrew/opt/llvm/bin/llvm-ar CC=/opt/homebrew/opt/llvm/bin/clang wasm-pack test --firefox --headless -- -Z build-std="panic_abort,std" --features web
@@ -249,67 +256,68 @@ jobs:
     permissions:
       contents: read
     runs-on: non-gpu
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
       # - name: The Worm Mock
-      #   run: cargo nextest run --verbose tests::large_mock_::large_tests_5_expects -- --include-ignored
-      - name: Large 1D Conv Mock
-        run: cargo nextest run --verbose tests::large_mock_::large_tests_7_expects -- --include-ignored
-      - name: MNIST Gan Mock
-        run: cargo nextest run --verbose tests::large_mock_::large_tests_4_expects -- --include-ignored
-      - name: NanoGPT Mock
-        run: cargo nextest run --verbose tests::large_mock_::large_tests_1_expects -- --include-ignored
-      - name: Self Attention Mock
-        run: cargo nextest run --verbose tests::large_mock_::large_tests_0_expects -- --include-ignored
-      - name: Multihead Attention Mock
-        run: cargo nextest run --verbose tests::large_mock_::large_tests_2_expects -- --include-ignored
-      - name: public outputs
-        run: cargo nextest run --verbose tests::mock_public_outputs_ --test-threads 32
-      - name: public inputs
-        run: cargo nextest run --verbose tests::mock_public_inputs_ --test-threads 32
-      - name: fixed params
-        run: cargo nextest run --verbose tests::mock_fixed_params_ --test-threads 32
+      #   run: cargo nextest run --release --verbose tests::large_mock_::large_tests_5_expects -- --include-ignored
       - name: public outputs and bounded lookup log
-        run: cargo nextest run --verbose tests::mock_bounded_lookup_log --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_bounded_lookup_log --test-threads 32
+      - name: public outputs and tolerance > 0
+        run: cargo nextest run --release --verbose tests::mock_tolerance_public_outputs_ --test-threads 32
       - name: public outputs + batch size == 10
-        run: cargo nextest run --verbose tests::mock_large_batch_public_outputs_ --test-threads 16
+        run: cargo nextest run --release --verbose tests::mock_large_batch_public_outputs_ --test-threads 16
       - name: kzg inputs
-        run: cargo nextest run --verbose tests::mock_kzg_input_::t  --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_kzg_input_::t  --test-threads 32
       - name: kzg params
-        run: cargo nextest run --verbose tests::mock_kzg_params_::t  --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_kzg_params_::t  --test-threads 32
       - name: kzg outputs
-        run: cargo nextest run --verbose tests::mock_kzg_output_::t  --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_kzg_output_::t  --test-threads 32
       - name: kzg inputs + params + outputs
-        run: cargo nextest run --verbose tests::mock_kzg_all_::t  --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_kzg_all_::t  --test-threads 32
       - name: Mock fixed inputs
-        run: cargo nextest run --verbose tests::mock_fixed_inputs_ --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_fixed_inputs_ --test-threads 32
       - name: Mock fixed outputs
-        run: cargo nextest run --verbose tests::mock_fixed_outputs --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_fixed_outputs --test-threads 32
       - name: Mock accuracy calibration
-        run: cargo nextest run --verbose tests::mock_accuracy_cal_tests::a
+        run: cargo nextest run --release --verbose tests::mock_accuracy_cal_tests::a
       - name: hashed inputs
-        run: cargo nextest run --verbose tests::mock_hashed_input_::t  --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_hashed_input_::t  --test-threads 32
       - name: hashed params
-        run: cargo nextest run --verbose tests::mock_hashed_params_::t  --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_hashed_params_::t  --test-threads 32
       - name: hashed params public inputs
-        run: cargo nextest run --verbose tests::mock_hashed_params_public_inputs_::t  --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_hashed_params_public_inputs_::t  --test-threads 32
       - name: hashed outputs
-        run: cargo nextest run --verbose tests::mock_hashed_output_::t  --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_hashed_output_::t  --test-threads 32
       - name: hashed inputs + params + outputs
-        run: cargo nextest run --verbose tests::mock_hashed_all_::t  --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_hashed_all_::t  --test-threads 32
       - name: hashed inputs + fixed params
-        run: cargo nextest run --verbose tests::mock_hashed_output_fixed_params_::t  --test-threads 32
+        run: cargo nextest run --release --verbose tests::mock_hashed_output_fixed_params_::t  --test-threads 32
+      - name: MNIST Gan Mock
+        run: cargo nextest run --release --verbose tests::large_mock_::large_tests_4_expects -- --include-ignored
+      - name: NanoGPT Mock
+        run: cargo nextest run --release --verbose tests::large_mock_::large_tests_1_expects -- --include-ignored
+      - name: Self Attention Mock
+        run: cargo nextest run --release --verbose tests::large_mock_::large_tests_0_expects -- --include-ignored
+      - name: Multihead Attention Mock
+        run: cargo nextest run --release --verbose tests::large_mock_::large_tests_2_expects -- --include-ignored
+      - name: public outputs
+        run: cargo nextest run --release --verbose tests::mock_public_outputs_ --test-threads 32
+      - name: public inputs
+        run: cargo nextest run --release --verbose tests::mock_public_inputs_ --test-threads 32
+      - name: fixed params
+        run: cargo nextest run --release --verbose tests::mock_fixed_params_ --test-threads 32
 
   prove-and-verify-evm-tests:
     permissions:
@@ -317,32 +325,32 @@ jobs:
     runs-on: non-gpu
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v3
         with:
           persist-credentials: false
       - name: Use pnpm 8
-        uses: pnpm/action-setup@eae0cfeb286e66ffb5155f1a79b90583a127a68b  #v2.4.1
+        uses: pnpm/action-setup@v2
         with:
           version: 8
       - name: Use Node.js 18.12.1
-        uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7  #v3.8.2
+        uses: actions/setup-node@v3
         with:
           node-version: "18.12.1"
           cache: "pnpm"
       - name: "Add rust-src"
-        run: rustup component add rust-src --toolchain nightly-2025-02-17-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
       - name: Install dependencies for js tests and in-browser-evm-verifier package
         run: |
           pnpm install --frozen-lockfile
@@ -352,7 +360,7 @@ jobs:
           NODE_ENV: development
       - name: Build wasm package for nodejs target.
         run: |
-          wasm-pack build --target nodejs --out-dir ./in-browser-evm-verifier/nodejs . -- -Z build-std="panic_abort,std"
+          wasm-pack build --release --target nodejs --out-dir ./in-browser-evm-verifier/nodejs . -- -Z build-std="panic_abort,std"
       - name: Replace memory definition in nodejs
         run: |
           sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" in-browser-evm-verifier/nodejs/ezkl.js
@@ -366,35 +374,35 @@ jobs:
       - name: Install Anvil
         run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
       - name: KZG prove and verify tests (EVM + reusable verifier + col-overflow)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_prove_and_verify_reusable_verifier --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_prove_and_verify_reusable_verifier --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg all)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_kzg_all_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_kzg_all_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg inputs)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_kzg_input_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_kzg_input_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg params)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_kzg_params_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_kzg_params_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + on chain inputs)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_input_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + on chain outputs)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_output_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_output_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + on chain inputs & outputs)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_input_output_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_output_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + on chain inputs & kzg outputs + params)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_input_kzg_output_kzg_params_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_kzg_output_kzg_params_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + on chain outputs & kzg inputs + params)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_output_kzg_input_kzg_params_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_output_kzg_input_kzg_params_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + on chain all kzg)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_all_kzg_params_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_all_kzg_params_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + on chain inputs & outputs hashes)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_input_output_hashed_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_output_hashed_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + hashed inputs)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_hashed_input_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_hashed_input_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + hashed params)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_hashed_params_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_hashed_params_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + hashed outputs)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_hashed_output_prove_and_verify --test-threads 1
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_hashed_output_prove_and_verify --test-threads 1
 
   # prove-and-verify-tests-metal:
   #   permissions:
@@ -402,33 +410,33 @@ jobs:
   #   runs-on: macos-13
   #   # needs: [build, library-tests, docs]
   #   steps:
-  #     - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+  #     - uses: actions/checkout@v4
   #       with:
   #         persist-credentials: false
-  #     - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+  #     - uses: actions-rs/toolchain@v1
   #       with:
-  #         toolchain: nightly-2025-02-17
+  #         toolchain: nightly-2024-07-18
   #         override: true
   #         components: rustfmt, clippy
-  #     - uses: jetli/wasm-pack-action@0d096b08b4e5a7de8c28de67e11e945404e9eefa  #v0.4.0
+  #     - uses: jetli/wasm-pack-action@v0.4.0
   #       with:
   #         # Pin to version 0.12.1
   #         version: 'v0.12.1'
   #     - name: Add rust-src
-  #       run: rustup component add rust-src --toolchain nightly-2025-02-17
-  #     - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+  #       run: rustup component add rust-src --toolchain nightly-2024-07-18
+  #     - uses: actions/checkout@v3
   #       with:
   #         persist-credentials: false
   #     - name: Use pnpm 8
-  #       uses: pnpm/action-setup@eae0cfeb286e66ffb5155f1a79b90583a127a68b  #v2.4.1
+  #       uses: pnpm/action-setup@v2
   #       with:
   #         version: 8
-  #     - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+  #     - uses: baptiste0928/cargo-install@v1
   #       with:
   #         crate: cargo-nextest
   #         locked: true
   #     - name: KZG prove and verify tests (public outputs)
-  #       run: cargo nextest run --features macos-metal --verbose tests::kzg_prove_and_verify_::t --no-capture
+  #       run: cargo nextest run --release --features macos-metal --verbose tests::kzg_prove_and_verify_::t --no-capture
 
   prove-and-verify-tests:
     permissions:
@@ -436,15 +444,15 @@ jobs:
     runs-on: non-gpu
     needs: [build, library-tests, docs]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: jetli/wasm-pack-action@0d096b08b4e5a7de8c28de67e11e945404e9eefa  #v0.4.0
+      - uses: jetli/wasm-pack-action@v0.4.0
         with:
           # Pin to version 0.12.1
           version: "v0.12.1"
@@ -452,16 +460,16 @@ jobs:
         run: rustup target add wasm32-unknown-unknown
 
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2025-02-17-x86_64-unknown-linux-gnu
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
+      - uses: actions/checkout@v3
         with:
           persist-credentials: false
       - name: Use pnpm 8
-        uses: pnpm/action-setup@eae0cfeb286e66ffb5155f1a79b90583a127a68b  #v2.4.1
+        uses: pnpm/action-setup@v2
         with:
           version: 8
       - name: Use Node.js 18.12.1
-        uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7  #v3.8.2
+        uses: actions/setup-node@v3
         with:
           node-version: "18.12.1"
           cache: "pnpm"
@@ -471,83 +479,83 @@ jobs:
         env:
           CI: false
           NODE_ENV: development
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
       - name: Build wasm package for nodejs target.
         run: |
-          wasm-pack build --target nodejs --out-dir ./tests/wasm/nodejs . -- -Z build-std="panic_abort,std"
+          wasm-pack build --release --target nodejs --out-dir ./tests/wasm/nodejs . -- -Z build-std="panic_abort,std"
       - 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 --verbose tests::kzg_prove_and_verify_with_overflow_::w
+        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 --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_
+        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 --verbose tests::kzg_prove_and_verify_with_overflow_hashed_inputs_
+        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 --verbose tests::kzg_prove_and_verify_tight_lookup_::t
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_tight_lookup_::t
       - name: IPA prove and verify tests
-        run: cargo nextest run --verbose tests::ipa_prove_and_verify_::t --test-threads 1
+        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 --verbose tests::ipa_prove_and_verify_ipa_output
+        run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_ipa_output
       - name: KZG prove and verify tests single inner col
-        run: cargo nextest run --verbose tests::kzg_prove_and_verify_single_col
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_single_col
       - name: KZG prove and verify tests triple inner col
-        run: cargo nextest run --verbose tests::kzg_prove_and_verify_triple_col
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_triple_col
       - name: KZG prove and verify tests quadruple inner col
-        run: cargo nextest run --verbose tests::kzg_prove_and_verify_quadruple_col
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_quadruple_col
       - name: KZG prove and verify tests octuple inner col
-        run: cargo nextest run --verbose tests::kzg_prove_and_verify_octuple_col --test-threads 8
+        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 --verbose tests::kzg_prove_and_verify_kzg_output
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output
       - name: KZG prove and verify tests (public outputs)
-        run: cargo nextest run --verbose tests::kzg_prove_and_verify_::t
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t
       - name: KZG prove and verify tests (public inputs)
-        run: cargo nextest run --verbose tests::kzg_prove_and_verify_public_input
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input
       - name: KZG prove and verify tests (fixed params)
-        run: cargo nextest run --verbose tests::kzg_prove_and_verify_fixed_params
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params
       - name: KZG prove and verify tests (hashed outputs)
-        run: cargo nextest run --verbose tests::kzg_prove_and_verify_hashed
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed
 
   # prove-and-verify-tests-gpu:
   #   runs-on: GPU
   #   env:
   #     ENABLE_ICICLE_GPU: true
   #   steps:
-  #     - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+  #     - uses: actions/checkout@v4
   # with:
   #   persist-credentials: false
-  #     - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+  #     - uses: actions-rs/toolchain@v1
   #       with:
-  #         toolchain: nightly-2025-02-17
+  #         toolchain: nightly-2024-07-18
   #         override: true
   #         components: rustfmt, clippy
   #     - name: Add rust-src
-  #       run: rustup component add rust-src --toolchain nightly-2025-02-17-x86_64-unknown-linux-gnu
-  #     - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
-  #     - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+  #       run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
+  #     - uses: actions/checkout@v3
+  #     - uses: baptiste0928/cargo-install@v1
   #       with:
   #         crate: cargo-nextest
   #         locked: true
   #     - name: KZG prove and verify tests (kzg outputs)
-  #       run: cargo nextest run --verbose tests::kzg_prove_and_verify_kzg_output --features icicle --test-threads 1
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output --features icicle --test-threads 1
   #     - name: KZG prove and verify tests (public outputs + column overflow)
-  #       run: cargo nextest run --verbose tests::kzg_prove_and_verify_with_overflow_::w --features icicle  --test-threads 1
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w --features icicle  --test-threads 1
   #     - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
-  #       run: cargo nextest run --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_ --features icicle  --test-threads 1
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_ --features icicle  --test-threads 1
   #     - name: KZG prove and verify tests (public outputs)
-  #       run: cargo nextest run --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
   #     - name: KZG prove and verify tests (public outputs + column overflow)
-  #       run: cargo nextest run --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
   #     - name: KZG prove and verify tests (public inputs)
-  #       run: cargo nextest run --verbose tests::kzg_prove_and_verify_public_input --features icicle  --test-threads 1
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input --features icicle  --test-threads 1
   #     - name: KZG prove and verify tests (fixed params)
-  #       run: cargo nextest run --verbose tests::kzg_prove_and_verify_fixed_params --features icicle  --test-threads 1
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params --features icicle  --test-threads 1
   #     - name: KZG prove and verify tests (hashed outputs)
-  #       run: cargo nextest run --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1
 
   prove-and-verify-mock-aggr-tests:
     permissions:
@@ -555,35 +563,35 @@ jobs:
     runs-on: self-hosted
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: dtolnay/rust-toolchain@4f94fbe7e03939b0e674bcc9ca609a16088f63ff  #nightly branch, TODO: update when required
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
       - name: Mock aggr tests (KZG)
-        run: cargo nextest run --verbose tests_aggr::kzg_aggr_mock_prove_and_verify_  --test-threads 8
+        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_mock_prove_and_verify_  --test-threads 8
 
   # prove-and-verify-aggr-tests-gpu:
   #   runs-on: GPU
   #   env:
   #     ENABLE_ICICLE_GPU: true
   #   steps:
-  #     - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+  #     - uses: actions/checkout@v4
   # with:
   #   persist-credentials: false
-  #     - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+  #     - uses: actions-rs/toolchain@v1
   #       with:
-  #         toolchain: nightly-2025-02-17
+  #         toolchain: nightly-2024-07-18
   #         override: true
   #         components: rustfmt, clippy
-  #     - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+  #     - uses: baptiste0928/cargo-install@v1
   #       with:
   #         crate: cargo-nextest
   #         locked: true
@@ -596,20 +604,20 @@ jobs:
     runs-on: large-self-hosted
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
       - name: KZG tests
-        run: cargo nextest run --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 4 -- --include-ignored
+        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 4 -- --include-ignored
 
   prove-and-verify-aggr-evm-tests:
     permissions:
@@ -617,15 +625,15 @@ jobs:
     runs-on: large-self-hosted
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
@@ -634,7 +642,7 @@ jobs:
       - name: Install Anvil
         run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
       - name: KZG prove and verify aggr tests
-        run: cargo nextest run  --verbose tests_evm::kzg_evm_aggr_prove_and_verify_::t --test-threads 4 -- --include-ignored
+        run: cargo nextest run  --release --verbose tests_evm::kzg_evm_aggr_prove_and_verify_::t --test-threads 4 -- --include-ignored
 
   examples:
     permissions:
@@ -642,15 +650,15 @@ jobs:
     runs-on: ubuntu-latest-32-cores
     needs: [build, library-tests, docs]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
@@ -663,15 +671,15 @@ jobs:
     runs-on: non-gpu
     needs: [build, library-tests, docs]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
+      - uses: actions/setup-python@v4
         with:
           python-version: "3.12"
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - name: Install cmake
@@ -683,7 +691,7 @@ jobs:
       - name: Install Anvil
         run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
       - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --profile=test-runs
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
       - name: Run pytest
         run: source .env/bin/activate; pip install pytest-asyncio; pytest -vv
 
@@ -693,33 +701,33 @@ jobs:
     runs-on: non-gpu
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
+      - uses: actions/setup-python@v4
         with:
           python-version: "3.12"
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
       - name: Setup Virtual Env and Install python dependencies
         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 --profile=test-runs
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
       - name: Public inputs
-        run: source .env/bin/activate; cargo nextest run --verbose tests::accuracy_measurement_public_inputs_
+        run: source .env/bin/activate; cargo nextest run --release --verbose tests::accuracy_measurement_public_inputs_
       - name: fixed params
-        run: source .env/bin/activate; cargo nextest run --verbose tests::accuracy_measurement_fixed_params_
+        run: source .env/bin/activate; cargo nextest run --release --verbose tests::accuracy_measurement_fixed_params_
       - name: Public outputs
-        run: source .env/bin/activate; cargo nextest run --verbose tests::accuracy_measurement_public_outputs_
+        run: source .env/bin/activate; cargo nextest run --release --verbose tests::accuracy_measurement_public_outputs_
       - name: Public outputs + resources
-        run: source .env/bin/activate; cargo nextest run --verbose tests::resources_accuracy_measurement_public_outputs_
+        run: source .env/bin/activate; cargo nextest run --release --verbose tests::resources_accuracy_measurement_public_outputs_
 
   python-integration-tests:
     permissions:
@@ -744,18 +752,18 @@ jobs:
           # Maps tcp port 5432 on service container to the host
           - 5432:5432
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
+      - uses: actions/setup-python@v4
         with:
           python-version: "3.11"
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
@@ -768,11 +776,7 @@ jobs:
       - name: Setup Virtual Env and Install python dependencies
         run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt; python -m ensurepip --upgrade
       - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --profile=test-runs
-      - name: Cat and Dog notebook
-        run: source .env/bin/activate; cargo nextest run py_tests::tests::cat_and_dog_notebook_
-      - name: All notebooks
-        run: source .env/bin/activate; cargo nextest run py_tests::tests::run_notebook_ --test-threads 1
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
       - name: Voice tutorial
         run: source .env/bin/activate; cargo nextest run py_tests::tests::voice_
       - name: Neural bow
@@ -792,6 +796,8 @@ jobs:
       #     # now dump the contents of the file into a file called kaggle.json
       #     echo $KAGGLE_API_KEY > /home/ubuntu/.kaggle/kaggle.json
       #     chmod 600 /home/ubuntu/.kaggle/kaggle.json
+      - name: All notebooks
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::run_notebook_ --test-threads 1
       - name: NBEATS tutorial
         run: source .env/bin/activate; cargo nextest run py_tests::tests::nbeats_
       # - name: Reusable verifier tutorial
@@ -802,20 +808,20 @@ jobs:
       contents: read
     runs-on: macos-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3  #v3.3.0
+      - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
       - name: Run ios tests
-        run: CARGO_BUILD_TARGET=aarch64-apple-darwin RUSTUP_TOOLCHAIN=nightly-2025-02-17-aarch64-apple-darwin cargo test --test ios_integration_tests --features ios-bindings-test --no-default-features
+        run: CARGO_BUILD_TARGET=aarch64-apple-darwin RUSTUP_TOOLCHAIN=nightly-2024-07-18-aarch64-apple-darwin cargo test --test ios_integration_tests --features ios-bindings-test --no-default-features
 
   swift-package-tests:
     permissions:
@@ -824,12 +830,12 @@ jobs:
     needs: [ios-integration-tests]
 
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
       - name: Build EzklCoreBindings

.github/workflows/static-analysis.yml

@@ -12,12 +12,12 @@ jobs:
       contents: read
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
-      - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+      - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2025-02-17
+          toolchain: nightly-2024-07-18
           override: true
           components: rustfmt, clippy
 
@@ -30,3 +30,4 @@ jobs:
         run: zizmor .
 
 
+    

.github/workflows/swift-pm.yml

@@ -19,8 +19,8 @@ jobs:
 
     steps:
       - name: Checkout EZKL
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
-        with:
+        uses: actions/checkout@v3
+        with: 
           persist-credentials: false
 
       - name: Extract TAG from github.ref_name
@@ -34,7 +34,7 @@ jobs:
           echo "TAG=$NEW_TAG" >> $GITHUB_ENV
 
       - name: Install Rust (nightly)
-        uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
+        uses: actions-rs/toolchain@v1
         with:
           toolchain: nightly
           override: true

.github/workflows/tagging.yml

@@ -11,12 +11,12 @@ jobs:
       contents: write
 
     steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
       - name: Bump version and push tag
         id: tag_version
-        uses: mathieudutour/github-tag-action@a22cf08638b34d5badda920f9daf6e72c477b07b  #v6.2
+        uses: mathieudutour/github-tag-action@v6.2
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
 
@@ -46,7 +46,7 @@ jobs:
           git tag $RELEASE_TAG
 
       - name: Push changes
-        uses: ad-m/github-push-action@77c5b412c50b723d2a4fbc6d71fb5723bcd439aa  #master
+        uses: ad-m/github-push-action@master
         env:
           RELEASE_TAG: ${{ steps.tag_version.outputs.new_tag }}
         with:

Cargo.lock

@@ -944,7 +944,7 @@ dependencies = [
  "bitflags 2.5.0",
  "cexpr",
  "clang-sys",
- "itertools 0.11.0",
+ "itertools 0.12.1",
  "lazy_static",
  "lazycell",
  "log",
@@ -2397,7 +2397,7 @@ dependencies = [
 [[package]]
 name = "halo2_gadgets"
 version = "0.2.0"
-source = "git+https://github.com/zkonduit/halo2#f441c920be45f8f05d2c06a173d82e8885a5ed4d"
+source = "git+https://github.com/zkonduit/halo2#d7ecad83c7439fa1cb450ee4a89c2d0b45604ceb"
 dependencies = [
  "arrayvec 0.7.4",
  "bitvec",
@@ -2414,7 +2414,7 @@ dependencies = [
 [[package]]
 name = "halo2_proofs"
 version = "0.3.0"
-source = "git+https://github.com/zkonduit/halo2#f441c920be45f8f05d2c06a173d82e8885a5ed4d#f441c920be45f8f05d2c06a173d82e8885a5ed4d"
+source = "git+https://github.com/zkonduit/halo2#bf9d0057a82443be48c4779bbe14961c18fb5996#bf9d0057a82443be48c4779bbe14961c18fb5996"
 dependencies = [
  "bincode",
  "blake2b_simd",
@@ -3139,7 +3139,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
 dependencies = [
  "cfg-if",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]

Cargo.toml

@@ -3,7 +3,7 @@ cargo-features = ["profile-rustflags"]
 [package]
 name = "ezkl"
 version = "0.0.0"
-edition = "2024"
+edition = "2021"
 default-run = "ezkl"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -276,11 +276,10 @@ macos-metal = ["halo2_proofs/macos"]
 ios-metal = ["halo2_proofs/ios"]
 
 [patch.'https://github.com/zkonduit/halo2']
-halo2_proofs = { git = "https://github.com/zkonduit/halo2#f441c920be45f8f05d2c06a173d82e8885a5ed4d", package = "halo2_proofs" }
+halo2_proofs = { git = "https://github.com/zkonduit/halo2#bf9d0057a82443be48c4779bbe14961c18fb5996", package = "halo2_proofs" }
 
 [patch.'https://github.com/zkonduit/halo2#0654e92bdf725fd44d849bfef3643870a8c7d50b']
-halo2_proofs = { git = "https://github.com/zkonduit/halo2#f441c920be45f8f05d2c06a173d82e8885a5ed4d", package = "halo2_proofs" }
-
+halo2_proofs = { git = "https://github.com/zkonduit/halo2#bf9d0057a82443be48c4779bbe14961c18fb5996", package = "halo2_proofs" }
 
 [patch.crates-io]
 uniffi_testing = { git = "https://github.com/ElusAegis/uniffi-rs", branch = "feat/testing-feature-build-fix" }
@@ -289,13 +288,9 @@ uniffi_testing = { git = "https://github.com/ElusAegis/uniffi-rs", branch = "fea
 rustflags = ["-C", "relocation-model=pic"]
 lto = "fat"
 codegen-units = 1
-#panic = "abort"
+# panic = "abort"
 
 
-[profile.test-runs]
-inherits = "dev"
-opt-level = 3
-
 [package.metadata.wasm-pack.profile.release]
 wasm-opt = [
     "-O4",

README.md

@@ -150,13 +150,6 @@ Ezkl is unaudited, beta software undergoing rapid development. There may be bugs
 
 > NOTE: Because operations are quantized when they are converted from an onnx file to a zk-circuit, outputs in python and ezkl may differ slightly. 
 
-
-### Advanced security topics 
-
-Check out `docs/advanced_security` for more advanced information on potential threat vectors. 
-
-
-
 ### no warranty
 
 Copyright (c) 2024 Zkonduit Inc. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

benches/accum_conv.rs

@@ -73,8 +73,6 @@ impl Circuit<Fr> for MyCircuit {
                             padding: vec![(0, 0)],
                             stride: vec![1; 2],
                             group: 1,
-                            data_format: DataFormat::NCHW,
-                            kernel_format: KernelFormat::OIHW,
                         }),
                     )
                     .unwrap();

benches/accum_sumpool.rs

@@ -69,7 +69,6 @@ impl Circuit<Fr> for MyCircuit {
                             stride: vec![1, 1],
                             kernel_shape: vec![2, 2],
                             normalized: false,
-                            data_format: DataFormat::NCHW,
                         }),
                     )
                     .unwrap();

benches/poseidon.rs

@@ -23,6 +23,8 @@ use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 
+const L: usize = 10;
+
 #[derive(Clone, Debug)]
 struct MyCircuit {
     image: ValTensor<Fr>,
@@ -38,7 +40,7 @@ impl Circuit<Fr> for MyCircuit {
     }
 
     fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
-        PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>::configure(cs, ())
+        PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, 10>::configure(cs, ())
     }
 
     fn synthesize(
@@ -46,7 +48,7 @@ impl Circuit<Fr> for MyCircuit {
         config: Self::Config,
         mut layouter: impl Layouter<Fr>,
     ) -> Result<(), Error> {
-        let chip: PoseidonChip<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE> =
+        let chip: PoseidonChip<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, L> =
             PoseidonChip::new(config);
         chip.layout(&mut layouter, &[self.image.clone()], 0, &mut HashMap::new())?;
         Ok(())
@@ -57,7 +59,7 @@ fn runposeidon(c: &mut Criterion) {
     let mut group = c.benchmark_group("poseidon");
 
     for size in [64, 784, 2352, 12288].iter() {
-        let k = (PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>::num_rows(*size)
+        let k = (PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, L>::num_rows(*size)
             as f32)
             .log2()
             .ceil() as u32;
@@ -65,7 +67,7 @@ fn runposeidon(c: &mut Criterion) {
 
         let message = (0..*size).map(|_| Fr::random(OsRng)).collect::<Vec<_>>();
         let _output =
-            PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>::run(message.to_vec())
+            PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, L>::run(message.to_vec())
                 .unwrap();
 
         let mut image = Tensor::from(message.into_iter().map(Value::known));

benches/zero_finder.rs

@@ -22,7 +22,7 @@ fn generate_test_data(size: usize, zero_probability: f64) -> Vec<ValType> {
     let mut rng = rand::thread_rng();
     (0..size)
         .map(|_i| {
-            if rng.r#gen::<f64>() < zero_probability {
+            if rng.gen::<f64>() < zero_probability {
                 ValType::Constant(F::ZERO)
             } else {
                 ValType::Constant(F::ONE) // Or some other non-zero value

docs/advanced_security/public_commitments.md

@@ -1,41 +0,0 @@
-## EZKL Security Note: Public Commitments and Low-Entropy Data
-
-> **Disclaimer:** this a more technical post that requires some prior knowledge of how ZK proving systems like Halo2 operate, and in particular in how these APIs are constructed. For background reading we highly recommend the [Halo2 book](https://zcash.github.io/halo2/) and [Halo2 Club](https://halo2.club/).
-
-## Overview of commitments in EZKL
-
-A common design pattern in a zero knowledge (zk) application is thus:
-- A prover has some data which is used within a circuit.
-- This data, as it may be high-dimensional or somewhat private, is pre-committed to using some hash function.
-- The zk-circuit which forms the core of the application then proves (para-phrasing) a statement of the form:
->"I know some data D which when hashed corresponds to the pre-committed to value H + whatever else the circuit is proving over D". 
-
-From our own experience, we've implemented such patterns using snark-friendly hash functions like [Poseidon](https://www.poseidon-hash.info/), for which there is a relatively well vetted [implementation](https://docs.rs/halo2_gadgets/latest/halo2_gadgets/poseidon/index.html) in Halo2. Even then these hash functions can introduce lots of overhead and can be very expensive to generate proofs for if the dimensionality of the data D is large. 
-
-You can also implement such a pattern using Halo2's `Fixed` columns _if the privacy preservation of the pre-image is not necessary_. These are Halo2 columns (i.e in reality just polynomials) that are left unblinded (unlike the blinded `Advice` columns), and whose commitments are shared with the verifier by way of the verifying key for the application's zk-circuit. These commitments are much lower cost to generate than implementing a hashing function, such as Poseidon, within a circuit.
-
-> **Note:** Blinding is the process whereby a certain set of the final elements (i.e rows) of a Halo2 column are set to random field elements. This is the mechanism by which Halo2 achieves its zero knowledge properties for `Advice` columns. By contrast `Fixed` columns aren't zero-knowledge in that they are vulnerable to dictionary attacks in the same manner a hash function is. Given some set of known or popular data D an attacker can attempt to recover the pre-image of a hash by running D through the hash function to see if the outputs match a public commitment. These attacks aren't "possible" on blinded `Advice` columns.
-
-> **Further Note:** Note that without blinding, with access to `M` proofs, each of which contains an evaluation of the polynomial at a different point, an attacker can more easily recover a non blinded column's pre-image. This is because each proof generates a new query and evaluation of the polynomial represented by the column and as such with repetition a clearer picture can emerge of the column's pre-image. Thus unblinded columns should only be used for privacy preservation, in the manner of a hash, if the number of proofs generated against a fixed set of values is limited. More formally if M independent and _unique_ queries are generated; if M is equal to the degree + 1 of the polynomial represented by the column (i.e the unique lagrange interpolation of the values in the columns), then the column's pre-image can be recovered. As such as the logrows K increases, the more queries are required to recover the pre-image (as 2^K unique queries are required). This assumes that the entries in the column are not structured, as if they are then the number of queries required to recover the pre-image is reduced (eg. if all rows above a certain point are known to be nil).
-
-The annoyance in using `Fixed` columns comes from the fact that they require generating a new verifying key every time a new set of commitments is generated.
-
-> **Example:** Say for instance an application leverages a zero-knowledge circuit to prove the correct execution of a neural network. Every week the neural network is finetuned or retrained on new data. If the architecture remains the same then commiting to the new network parameters, along with a new proof of performance on a test set, would be an ideal setup. If we leverage `Fixed` columns to commit to the model parameters, each new commitment will require re-generating a  verifying key and sharing the new key with the verifier(s). This is not-ideal UX and can become expensive if the verifier is deployed on-chain. 
-
-An ideal commitment would thus have the low cost of a `Fixed`  column but wouldn't require regenerating a new verifying key for each new commitment.
-
-### Unblinded Advice Columns
-
-A first step in designing such a commitment is to allow for optionally unblinded `Advice` columns within the Halo2 API. These won't be included in the verifying key, AND are blinded with a constant factor `1` -- such that if someone knows the pre-image to the commitment, they can recover it by running it through the corresponding polynomial commitment scheme (in ezkl's case [KZG commitments](https://dankradfeist.de/ethereum/2020/06/16/kate-polynomial-commitments.html)). 
-
-This is implemented using the `polycommit` visibility parameter in the ezkl API.
-
-## The Vulnerability of Public Commitments
-
-
-Public commitments in EZKL (both Poseidon-hashed inputs and KZG commitments) can be vulnerable to brute-force attacks when input data has low entropy. A malicious actor could reveal committed data by searching through possible input values, compromising privacy in applications like anonymous credentials. This is particularly relevant when input data comes from known finite sets (e.g., names, dates).
-
-Example Risk: In an anonymous credential system using EZKL for ID verification, an attacker could match hashed outputs against a database of common identifying information to deanonymize users.
-
-
-

docs/advanced_security/quantization_backdoors.md

@@ -1,22 +0,0 @@
-# EZKL Security Note: Quantization-Induced Model Backdoors
-
-> Note: this only affects a situation where a party separate to an application's developer has access to the model's weights and can modify them. This is a common scenario in adversarial machine learning research, but can be less common in real-world applications. If you're building your models in house and deploying them yourself, this is less of a concern. If you're building a permisionless system where anyone can submit models, this is more of a concern.
-
-Models processed through EZKL's quantization step can harbor backdoors that are dormant in the original full-precision model but activate during quantization. These backdoors force specific outputs when triggered, with impact varying by application.
-
-Key Factors:
-
-- Larger models increase attack feasibility through more parameter capacity
-- Smaller quantization scales facilitate attacks by allowing greater weight modifications
-- Rebase ratio of 1 enables exploitation of convolutional layer consistency
-
-Limitations: 
-
-- Attack effectiveness depends on calibration settings and internal rescaling operations. 
-- Further research needed on backdoor persistence through witness/proof stages.
-- Can be mitigated by evaluating the quantized model (using `ezkl gen-witness`), rather than relying on the evaluation of the original model. 
-
-References:
-
-1. [Quantization Backdoors to Deep Learning Commercial Frameworks (Ma et al., 2021)](https://arxiv.org/abs/2108.09187)
-2. [Planting Undetectable Backdoors in Machine Learning Models (Goldwasser et al., 2022)](https://arxiv.org/abs/2204.06974)

docs/python/src/conf.py

@@ -1,7 +1,7 @@
 import ezkl
 
 project = 'ezkl'
-release = '0.0.0'
+release = '18.1.8'
 version = release
 
 

examples/conv2d_mnist/main.rs

@@ -32,7 +32,6 @@ use mnist::*;
 use rand::rngs::OsRng;
 use std::marker::PhantomData;
 
-
 mod params;
 
 const K: usize = 20;
@@ -209,8 +208,6 @@ where
                         padding: vec![(PADDING, PADDING); 2],
                         stride: vec![STRIDE; 2],
                         group: 1,
-                        data_format: DataFormat::NCHW,
-                        kernel_format: KernelFormat::OIHW,
                     };
                     let x = config
                         .layer_config

examples/notebooks/cat_and_dog_data.sh

@@ -1,13 +0,0 @@
-# download tess data
-# check if first argument has been set 
-if [ ! -z "$1" ]; then
-    DATA_DIR=$1
-else
-    DATA_DIR=data
-fi
-
-echo "Downloading data to $DATA_DIR"
-
-if [ ! -d "$DATA_DIR/CATDOG" ]; then
-    kaggle datasets download tongpython/cat-and-dog -p $DATA_DIR/CATDOG --unzip
-fi

examples/notebooks/generalized_inverse.ipynb

@@ -77,7 +77,6 @@
       "outputs": [],
       "source": [
         "gip_run_args = ezkl.PyRunArgs()\n",
-        "gip_run_args.ignore_range_check_inputs_outputs = True\n",
         "gip_run_args.input_visibility = \"polycommit\"  # matrix and generalized inverse commitments\n",
         "gip_run_args.output_visibility = \"fixed\"   # no parameters used\n",
         "gip_run_args.param_visibility = \"fixed\" # should be Tensor(True)"
@@ -336,9 +335,9 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.9.13"
+      "version": "3.9.15"
     }
   },
   "nbformat": 4,
   "nbformat_minor": 5
-}
+}

examples/notebooks/mean_postgres.ipynb

@@ -308,11 +308,8 @@
     "compiled_filename = os.path.join('lol.compiled')\n",
     "settings_filename = os.path.join('settings.json')\n",
     "\n",
-    "run_args = ezkl.PyRunArgs()\n",
-    "run_args.decomp_legs = 4\n",
-    "\n",
     "# Generate settings using ezkl\n",
-    "res = ezkl.gen_settings(onnx_filename, settings_filename, py_run_args=run_args)\n",
+    "res = ezkl.gen_settings(onnx_filename, settings_filename)\n",
     "\n",
     "assert res == True\n",
     "\n",

examples/notebooks/random_forest.ipynb

@@ -152,11 +152,9 @@
             "metadata": {},
             "outputs": [],
             "source": [
-                "run_args = ezkl.PyRunArgs()\n",
-                "# logrows\n",
-                "run_args.logrows = 20\n",
-                "\n",
-                "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
+                "!RUST_LOG=trace\n",
+                "# TODO: Dictionary outputs\n",
+                "res = ezkl.gen_settings(model_path, settings_path)\n",
                 "assert res == True\n"
             ]
         },
@@ -304,7 +302,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.9.13"
+            "version": "3.12.2"
         }
     },
     "nbformat": 4,

examples/notebooks/set_membership.ipynb

@@ -167,8 +167,6 @@
         "run_args = ezkl.PyRunArgs()\n",
         "# \"hashed/private\" means that the output of the hashing is not visible to the verifier and is instead fed into the computational graph\n",
         "run_args.input_visibility = \"hashed/private/0\"\n",
-        "# as the inputs are felts we turn off input range checks\n",
-        "run_args.ignore_range_check_inputs_outputs = True\n",
         "# we set it to fix the set we want to check membership for\n",
         "run_args.param_visibility = \"fixed\"\n",
         "# the output is public -- set membership fails if it is not = 0\n",
@@ -521,4 +519,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 5
-}
+}

examples/notebooks/solvency.ipynb

@@ -204,7 +204,6 @@
         "run_args = ezkl.PyRunArgs()\n",
         "# \"polycommit\" means that the output of the hashing is not visible to the verifier and is instead fed into the computational graph\n",
         "run_args.input_visibility = \"polycommit\"\n",
-        "run_args.ignore_range_check_inputs_outputs = True\n",
         "# the parameters are public\n",
         "run_args.param_visibility = \"fixed\"\n",
         "# the output is public (this is the inequality test)\n",
@@ -515,4 +514,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 5
-}
+}

examples/notebooks/univ3-da.ipynb

@@ -20,7 +20,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 2,
             "metadata": {},
             "outputs": [],
             "source": [
@@ -60,7 +60,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 3,
             "metadata": {},
             "outputs": [],
             "source": [
@@ -94,7 +94,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 4,
             "metadata": {},
             "outputs": [],
             "source": [
@@ -134,7 +134,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 44,
             "metadata": {},
             "outputs": [],
             "source": [
@@ -183,7 +183,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 6,
             "metadata": {},
             "outputs": [],
             "source": [
@@ -201,7 +201,6 @@
                 "run_args.input_visibility = \"public\"\n",
                 "run_args.param_visibility = \"private\"\n",
                 "run_args.output_visibility = \"public\"\n",
-                "run_args.decomp_legs=6\n",
                 "run_args.num_inner_cols = 1\n",
                 "run_args.variables = [(\"batch_size\", 1)]"
             ]

examples/onnx/1d_conv/input.json

@@ -1,106 +0,0 @@
-{
-  "input_data": [
-    [
-      8761,
-      7654,
-      8501,
-      2404,
-      6929,
-      8858,
-      5946,
-      3673,
-      4131,
-      3854,
-      8137,
-      8239,
-      9038,
-      6299,
-      1118,
-      9737,
-      208,
-      7954,
-      3691,
-      610,
-      3468,
-      3314,
-      8658,
-      8366,
-      2850,
-      477,
-      6114,
-      232,
-      4601,
-      7420,
-      5713,
-      2936,
-      6061,
-      2870,
-      8421,
-      177,
-      7107,
-      7382,
-      6115,
-      5487,
-      8502,
-      2559,
-      1875,
-      129,
-      8533,
-      8201,
-      8414,
-      4775,
-      9817,
-      3127,
-      8761,
-      7654,
-      8501,
-      2404,
-      6929,
-      8858,
-      5946,
-      3673,
-      4131,
-      3854,
-      8137,
-      8239,
-      9038,
-      6299,
-      1118,
-      9737,
-      208,
-      7954,
-      3691,
-      610,
-      3468,
-      3314,
-      8658,
-      8366,
-      2850,
-      477,
-      6114,
-      232,
-      4601,
-      7420,
-      5713,
-      2936,
-      6061,
-      2870,
-      8421,
-      177,
-      7107,
-      7382,
-      6115,
-      5487,
-      8502,
-      2559,
-      1875,
-      129,
-      8533,
-      8201,
-      8414,
-      4775,
-      9817,
-      3127
-    ]
-  ]
-}

examples/onnx/1l_div/settings.json

@@ -1 +0,0 @@
-{"run_args":{"input_scale":7,"param_scale":7,"scale_rebase_multiplier":1,"lookup_range":[-32768,32768],"logrows":17,"num_inner_cols":2,"variables":[["batch_size",1]],"input_visibility":"Private","output_visibility":"Public","param_visibility":"Private","rebase_frac_zero_constants":false,"check_mode":"UNSAFE","commitment":"KZG","decomp_base":16384,"decomp_legs":2,"bounded_log_lookup":false,"ignore_range_check_inputs_outputs":false},"num_rows":54,"total_assignments":109,"total_const_size":4,"total_dynamic_col_size":0,"max_dynamic_input_len":0,"num_dynamic_lookups":0,"num_shuffles":0,"total_shuffle_col_size":0,"model_instance_shapes":[[1,1]],"model_output_scales":[7],"model_input_scales":[7],"module_sizes":{"polycommit":[],"poseidon":[0,[0]]},"required_lookups":[],"required_range_checks":[[-1,1],[0,16383]],"check_mode":"UNSAFE","version":"0.0.0","num_blinding_factors":null,"timestamp":1739396322131,"input_types":["F32"],"output_types":["F32"]}

examples/onnx/integer_div/gen.py

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

examples/onnx/integer_div/input.json

@@ -1 +0,0 @@
-{"input_data": [[3, 4, 0, 9, 2, 6, 2, 5, 1, 5, 3, 5, 5, 7, 0, 2, 6, 1, 4, 4, 1, 9, 7, 7, 5, 8, 2, 0, 1, 5, 9, 8]]}

rust-toolchain

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

src/bin/ezkl.rs

@@ -28,8 +28,6 @@ use std::env;
 #[tokio::main(flavor = "current_thread")]
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 pub async fn main() {
-    use log::debug;
-
     let args = Cli::parse();
 
     if let Some(generator) = args.generator {
@@ -44,7 +42,7 @@ pub async fn main() {
         } else {
             info!("Running with CPU");
         }
-        debug!(
+        info!(
             "command: \n {}",
             &command.as_json().to_colored_json_auto().unwrap()
         );

src/bindings/python.rs

@@ -4,10 +4,11 @@ use crate::circuit::modules::poseidon::{
     PoseidonChip,
 };
 use crate::circuit::modules::Module;
-use crate::circuit::CheckMode;
 use crate::circuit::InputType;
+use crate::circuit::{CheckMode, Tolerance};
 use crate::commands::*;
 use crate::fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep};
+use crate::graph::modules::POSEIDON_LEN_GRAPH;
 use crate::graph::TestDataSource;
 use crate::graph::{
     quantize_float, scale_to_multiplier, GraphCircuit, GraphSettings, Model, Visibility,
@@ -155,6 +156,9 @@ impl pyo3::ToPyObject for PyG1Affine {
 #[derive(Clone)]
 #[gen_stub_pyclass]
 struct PyRunArgs {
+    #[pyo3(get, set)]
+    /// float: The tolerance for error on model outputs
+    pub tolerance: f32,
     #[pyo3(get, set)]
     /// int: The denominator in the fixed point representation used when quantizing inputs
     pub input_scale: crate::Scale,
@@ -203,9 +207,6 @@ struct PyRunArgs {
     /// bool: Should the circuit use unbounded lookups for log
     #[pyo3(get, set)]
     pub bounded_log_lookup: bool,
-    /// bool: Should the circuit use range checks for inputs and outputs (set to false if the input is a felt)
-    #[pyo3(get, set)]
-    pub ignore_range_check_inputs_outputs: bool,
 }
 
 /// default instantiation of PyRunArgs
@@ -222,6 +223,7 @@ impl From<PyRunArgs> for RunArgs {
     fn from(py_run_args: PyRunArgs) -> Self {
         RunArgs {
             bounded_log_lookup: py_run_args.bounded_log_lookup,
+            tolerance: Tolerance::from(py_run_args.tolerance),
             input_scale: py_run_args.input_scale,
             param_scale: py_run_args.param_scale,
             num_inner_cols: py_run_args.num_inner_cols,
@@ -237,7 +239,6 @@ impl From<PyRunArgs> for RunArgs {
             commitment: Some(py_run_args.commitment.into()),
             decomp_base: py_run_args.decomp_base,
             decomp_legs: py_run_args.decomp_legs,
-            ignore_range_check_inputs_outputs: py_run_args.ignore_range_check_inputs_outputs,
         }
     }
 }
@@ -246,6 +247,7 @@ impl Into<PyRunArgs> for RunArgs {
     fn into(self) -> PyRunArgs {
         PyRunArgs {
             bounded_log_lookup: self.bounded_log_lookup,
+            tolerance: self.tolerance.val,
             input_scale: self.input_scale,
             param_scale: self.param_scale,
             num_inner_cols: self.num_inner_cols,
@@ -261,7 +263,6 @@ impl Into<PyRunArgs> for RunArgs {
             commitment: self.commitment.into(),
             decomp_base: self.decomp_base,
             decomp_legs: self.decomp_legs,
-            ignore_range_check_inputs_outputs: self.ignore_range_check_inputs_outputs,
         }
     }
 }
@@ -332,8 +333,6 @@ enum PyInputType {
     Int,
     ///
     TDim,
-    ///
-    Unknown,
 }
 
 impl From<InputType> for PyInputType {
@@ -345,7 +344,6 @@ impl From<InputType> for PyInputType {
             InputType::F64 => PyInputType::F64,
             InputType::Int => PyInputType::Int,
             InputType::TDim => PyInputType::TDim,
-            InputType::Unknown => PyInputType::Unknown,
         }
     }
 }
@@ -359,7 +357,6 @@ impl From<PyInputType> for InputType {
             PyInputType::F64 => InputType::F64,
             PyInputType::Int => InputType::Int,
             PyInputType::TDim => InputType::TDim,
-            PyInputType::Unknown => InputType::Unknown,
         }
     }
 }
@@ -374,7 +371,6 @@ impl FromStr for PyInputType {
             "f64" => Ok(PyInputType::F64),
             "int" => Ok(PyInputType::Int),
             "tdim" => Ok(PyInputType::TDim),
-            "unknown" => Ok(PyInputType::Unknown),
             _ => Err("Invalid value for InputType".to_string()),
         }
     }
@@ -577,7 +573,10 @@ fn poseidon_hash(message: Vec<PyFelt>) -> PyResult<Vec<PyFelt>> {
         .map(crate::pfsys::string_to_field::<Fr>)
         .collect::<Vec<_>>();
 
-    let output = PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>::run(message.clone())
+    let output =
+        PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, POSEIDON_LEN_GRAPH>::run(
+            message.clone(),
+        )
         .map_err(|_| PyIOError::new_err("Failed to run poseidon"))?;
 
     let hash = output[0]
@@ -592,7 +591,7 @@ fn poseidon_hash(message: Vec<PyFelt>) -> PyResult<Vec<PyFelt>> {
 /// Arguments
 /// -------
 /// message: list[str]
-///     List of field elements represented as strings
+///     List of field elements represnted as strings
 ///
 /// vk_path: str
 ///     Path to the verification key
@@ -651,7 +650,7 @@ fn kzg_commit(
 /// Arguments
 /// -------
 /// message: list[str]
-///     List of field elements represented as strings
+///     List of field elements represnted as strings
 ///
 /// vk_path: str
 ///     Path to the verification key
@@ -1009,7 +1008,7 @@ fn gen_random_data(
 /// bool
 ///
 #[pyfunction(signature = (
-    data = String::from(DEFAULT_CALIBRATION_FILE),
+    data = PathBuf::from(DEFAULT_CALIBRATION_FILE),
     model = PathBuf::from(DEFAULT_MODEL),
     settings = PathBuf::from(DEFAULT_SETTINGS),
     target = CalibrationTarget::default(), // default is "resources
@@ -1021,7 +1020,7 @@ fn gen_random_data(
 #[gen_stub_pyfunction]
 fn calibrate_settings(
     py: Python,
-    data: String,
+    data: PathBuf,
     model: PathBuf,
     settings: PathBuf,
     target: CalibrationTarget,
@@ -1076,7 +1075,7 @@ fn calibrate_settings(
 ///     Python object containing the witness values
 ///
 #[pyfunction(signature = (
-    data=String::from(DEFAULT_DATA),
+    data=PathBuf::from(DEFAULT_DATA),
     model=PathBuf::from(DEFAULT_COMPILED_CIRCUIT),
     output=PathBuf::from(DEFAULT_WITNESS),
     vk_path=None,
@@ -1085,7 +1084,7 @@ fn calibrate_settings(
 #[gen_stub_pyfunction]
 fn gen_witness(
     py: Python,
-    data: String,
+    data: PathBuf,
     model: PathBuf,
     output: Option<PathBuf>,
     vk_path: Option<PathBuf>,
@@ -1754,7 +1753,7 @@ fn create_evm_vka(
 /// bool
 ///
 #[pyfunction(signature = (
-    input_data=String::from(DEFAULT_DATA),
+    input_data=PathBuf::from(DEFAULT_DATA),
     settings_path=PathBuf::from(DEFAULT_SETTINGS),
     sol_code_path=PathBuf::from(DEFAULT_SOL_CODE_DA),
     abi_path=PathBuf::from(DEFAULT_VERIFIER_DA_ABI),
@@ -1763,7 +1762,7 @@ fn create_evm_vka(
 #[gen_stub_pyfunction]
 fn create_evm_data_attestation(
     py: Python,
-    input_data: String,
+    input_data: PathBuf,
     settings_path: PathBuf,
     sol_code_path: PathBuf,
     abi_path: PathBuf,
@@ -1824,7 +1823,7 @@ fn create_evm_data_attestation(
 #[gen_stub_pyfunction]
 fn setup_test_evm_witness(
     py: Python,
-    data_path: String,
+    data_path: PathBuf,
     compiled_circuit_path: PathBuf,
     test_data: PathBuf,
     input_source: PyTestDataSource,
@@ -1902,7 +1901,7 @@ fn deploy_evm(
 fn deploy_da_evm(
     py: Python,
     addr_path: PathBuf,
-    input_data: String,
+    input_data: PathBuf,
     settings_path: PathBuf,
     sol_code_path: PathBuf,
     rpc_url: Option<String>,
@@ -1945,7 +1944,7 @@ fn deploy_da_evm(
 ///     does the verifier use data attestation ?
 ///
 /// addr_vk: str
-///     The address of the separate VK contract (if the verifier key is rendered as a separate contract)
+///     The addess of the separate VK contract (if the verifier key is rendered as a separate contract)
 /// Returns
 /// -------
 /// bool

src/bindings/wasm.rs

@@ -8,7 +8,10 @@ use crate::{
         Module,
     },
     fieldutils::{felt_to_integer_rep, integer_rep_to_felt},
-    graph::{quantize_float, scale_to_multiplier, GraphCircuit, GraphSettings},
+    graph::{
+        modules::POSEIDON_LEN_GRAPH, quantize_float, scale_to_multiplier, GraphCircuit,
+        GraphSettings,
+    },
 };
 use console_error_panic_hook;
 use halo2_proofs::{
@@ -228,7 +231,10 @@ pub fn poseidonHash(
     let message: Vec<Fr> = serde_json::from_slice(&message[..])
         .map_err(|e| JsError::new(&format!("Failed to deserialize message: {}", e)))?;
 
-    let output = PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>::run(message.clone())
+    let output =
+        PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, POSEIDON_LEN_GRAPH>::run(
+            message.clone(),
+        )
         .map_err(|e| JsError::new(&format!("{}", e)))?;
 
     Ok(wasm_bindgen::Clamped(serde_json::to_vec(&output).map_err(

src/circuit/modules/polycommit.rs

@@ -1,7 +1,7 @@
 /*
 An easy-to-use implementation of the Poseidon Hash in the form of a Halo2 Chip. While the Poseidon Hash function
 is already implemented in halo2_gadgets, there is no wrapper chip that makes it easy to use in other circuits.
-Thanks to https://github.com/summa-dev/summa-solvency/blob/master/zk_prover/src/chips/poseidon/hash.rs for the inspiration (and also helping us understand how to use this).
+Thanks to https://github.com/summa-dev/summa-solvency/blob/master/src/chips/poseidon/hash.rs for the inspiration (and also helping us understand how to use this).
 */
 
 use std::collections::HashMap;

src/circuit/modules/poseidon.rs

@@ -1,18 +1,20 @@
 /*
 An easy-to-use implementation of the Poseidon Hash in the form of a Halo2 Chip. While the Poseidon Hash function
 is already implemented in halo2_gadgets, there is no wrapper chip that makes it easy to use in other circuits.
-Thanks to https://github.com/summa-dev/summa-solvency/blob/master/zk_prover/src/chips/poseidon/hash.rs for the inspiration (and also helping us understand how to use this).
+Thanks to https://github.com/summa-dev/summa-solvency/blob/master/src/chips/poseidon/hash.rs for the inspiration (and also helping us understand how to use this).
 */
 
 pub mod poseidon_params;
 pub mod spec;
 
 // This chip adds a set of advice columns to the gadget Chip to store the inputs of the hash
-use halo2_gadgets::poseidon::{
-    primitives::VariableLength, primitives::*, Hash, Pow5Chip, Pow5Config,
-};
+use halo2_gadgets::poseidon::{primitives::*, Hash, Pow5Chip, Pow5Config};
+use halo2_proofs::arithmetic::Field;
 use halo2_proofs::halo2curves::bn256::Fr as Fp;
 use halo2_proofs::{circuit::*, plonk::*};
+// use maybe_rayon::prelude::{IndexedParallelIterator, IntoParallelRefIterator};
+use maybe_rayon::prelude::ParallelIterator;
+use maybe_rayon::slice::ParallelSlice;
 
 use std::marker::PhantomData;
 
@@ -38,17 +40,22 @@ pub struct PoseidonConfig<const WIDTH: usize, const RATE: usize> {
     pub pow5_config: Pow5Config<Fp, WIDTH, RATE>,
 }
 
-type InputAssignments = Vec<AssignedCell<Fp, Fp>>;
+type InputAssignments = (Vec<AssignedCell<Fp, Fp>>, AssignedCell<Fp, Fp>);
 
 /// PoseidonChip is a wrapper around the Pow5Chip that adds a set of advice columns to the gadget Chip to store the inputs of the hash
 #[derive(Debug, Clone)]
-pub struct PoseidonChip<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize> {
+pub struct PoseidonChip<
+    S: Spec<Fp, WIDTH, RATE> + Sync,
+    const WIDTH: usize,
+    const RATE: usize,
+    const L: usize,
+> {
     config: PoseidonConfig<WIDTH, RATE>,
     _marker: PhantomData<S>,
 }
 
-impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize>
-    PoseidonChip<S, WIDTH, RATE>
+impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, const L: usize>
+    PoseidonChip<S, WIDTH, RATE, L>
 {
     /// Creates a new PoseidonChip
     pub fn configure_with_cols(
@@ -75,8 +82,8 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize>
     }
 }
 
-impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize>
-    PoseidonChip<S, WIDTH, RATE>
+impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, const L: usize>
+    PoseidonChip<S, WIDTH, RATE, L>
 {
     /// Configuration of the PoseidonChip
     pub fn configure_with_optional_instance(
@@ -106,8 +113,8 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize>
     }
 }
 
-impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize> Module<Fp>
-    for PoseidonChip<S, WIDTH, RATE>
+impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize, const L: usize>
+    Module<Fp> for PoseidonChip<S, WIDTH, RATE, L>
 {
     type Config = PoseidonConfig<WIDTH, RATE>;
     type InputAssignments = InputAssignments;
@@ -176,81 +183,95 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize> Mod
         let res = layouter.assign_region(
             || "load message",
             |mut region| {
-                let assigned_message: Result<Vec<AssignedCell<Fp, Fp>>, _> = match &message {
-                    ValTensor::Value { inner: v, .. } => v
-                        .iter()
-                        .enumerate()
-                        .map(|(i, value)| {
-                            let x = i % WIDTH;
-                            let y = i / WIDTH;
+                let assigned_message: Result<Vec<AssignedCell<Fp, Fp>>, ModuleError> =
+                    match &message {
+                        ValTensor::Value { inner: v, .. } => {
+                            v.iter()
+                                .enumerate()
+                                .map(|(i, value)| {
+                                    let x = i % WIDTH;
+                                    let y = i / WIDTH;
 
-                            match value {
-                                ValType::Value(v) => region
-                                    .assign_advice(
-                                        || format!("load message_{}", i),
+                                    match value {
+                                        ValType::Value(v) => region
+                                            .assign_advice(
+                                                || format!("load message_{}", i),
+                                                self.config.hash_inputs[x],
+                                                y,
+                                                || *v,
+                                            )
+                                            .map_err(|e| e.into()),
+                                        ValType::PrevAssigned(v)
+                                        | ValType::AssignedConstant(v, ..) => Ok(v.clone()),
+                                        ValType::Constant(f) => {
+                                            if local_constants.contains_key(f) {
+                                                Ok(constants
+                                                    .get(f)
+                                                    .unwrap()
+                                                    .assigned_cell()
+                                                    .ok_or(ModuleError::ConstantNotAssigned)?)
+                                            } else {
+                                                let res = region.assign_advice_from_constant(
+                                                    || format!("load message_{}", i),
+                                                    self.config.hash_inputs[x],
+                                                    y,
+                                                    *f,
+                                                )?;
+
+                                                constants.insert(
+                                                    *f,
+                                                    ValType::AssignedConstant(res.clone(), *f),
+                                                );
+
+                                                Ok(res)
+                                            }
+                                        }
+                                        e => Err(ModuleError::WrongInputType(
+                                            format!("{:?}", e),
+                                            "AssignedValue".to_string(),
+                                        )),
+                                    }
+                                })
+                                .collect()
+                        }
+                        ValTensor::Instance {
+                            dims,
+                            inner: col,
+                            idx,
+                            initial_offset,
+                            ..
+                        } => {
+                            // this should never ever fail
+                            let num_elems = dims[*idx].iter().product::<usize>();
+                            (0..num_elems)
+                                .map(|i| {
+                                    let x = i % WIDTH;
+                                    let y = i / WIDTH;
+                                    region.assign_advice_from_instance(
+                                        || "pub input anchor",
+                                        *col,
+                                        initial_offset + i,
                                         self.config.hash_inputs[x],
                                         y,
-                                        || *v,
                                     )
-                                    .map_err(|e| e.into()),
-                                ValType::PrevAssigned(v) | ValType::AssignedConstant(v, ..) => {
-                                    Ok(v.clone())
-                                }
-                                ValType::Constant(f) => {
-                                    if local_constants.contains_key(f) {
-                                        Ok(constants
-                                            .get(f)
-                                            .unwrap()
-                                            .assigned_cell()
-                                            .ok_or(ModuleError::ConstantNotAssigned)?)
-                                    } else {
-                                        let res = region.assign_advice_from_constant(
-                                            || format!("load message_{}", i),
-                                            self.config.hash_inputs[x],
-                                            y,
-                                            *f,
-                                        )?;
+                                })
+                                .collect::<Result<Vec<_>, _>>()
+                                .map_err(|e| e.into())
+                        }
+                    };
 
-                                        constants
-                                            .insert(*f, ValType::AssignedConstant(res.clone(), *f));
+                let offset = message.len() / WIDTH + 1;
 
-                                        Ok(res)
-                                    }
-                                }
-                                e => Err(ModuleError::WrongInputType(
-                                    format!("{:?}", e),
-                                    "AssignedValue".to_string(),
-                                )),
-                            }
-                        })
-                        .collect(),
-                    ValTensor::Instance {
-                        dims,
-                        inner: col,
-                        idx,
-                        initial_offset,
-                        ..
-                    } => {
-                        // this should never ever fail
-                        let num_elems = dims[*idx].iter().product::<usize>();
-                        (0..num_elems)
-                            .map(|i| {
-                                let x = i % WIDTH;
-                                let y = i / WIDTH;
-                                region.assign_advice_from_instance(
-                                    || "pub input anchor",
-                                    *col,
-                                    initial_offset + i,
-                                    self.config.hash_inputs[x],
-                                    y,
-                                )
-                            })
-                            .collect::<Result<Vec<_>, _>>()
-                            .map_err(|e| e.into())
-                    }
-                };
+                let zero_val = region
+                    .assign_advice_from_constant(
+                        || "",
+                        self.config.hash_inputs[0],
+                        offset,
+                        Fp::ZERO,
+                    )
+                    .unwrap();
 
-                Ok(assigned_message?)
+                Ok((assigned_message?, zero_val))
             },
         );
         log::trace!(
@@ -271,7 +292,7 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize> Mod
         row_offset: usize,
         constants: &mut ConstantsMap<Fp>,
     ) -> Result<ValTensor<Fp>, ModuleError> {
-        let input_cells = self.layout_inputs(layouter, input, constants)?;
+        let (mut input_cells, zero_val) = self.layout_inputs(layouter, input, constants)?;
 
         // empty hash case
         if input_cells.is_empty() {
@@ -285,25 +306,52 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize> Mod
 
         let start_time = instant::Instant::now();
 
-        let pow5_chip = Pow5Chip::construct(self.config.pow5_config.clone());
-        // initialize the hasher
-        let hasher = Hash::<_, _, S, VariableLength, WIDTH, RATE>::init(
-            pow5_chip,
-            layouter.namespace(|| "block_hasher"),
-        )?;
+        let mut one_iter = false;
+        // do the Tree dance baby
+        while input_cells.len() > 1 || !one_iter {
+            let hashes: Result<Vec<AssignedCell<Fp, Fp>>, ModuleError> = input_cells
+                .chunks(L)
+                .enumerate()
+                .map(|(i, block)| {
+                    let _start_time = instant::Instant::now();
 
-        let hash: AssignedCell<Fp, Fp> = hasher.hash(
-            layouter.namespace(|| "hash"),
-            input_cells
-                .to_vec()
-                .try_into()
-                .map_err(|_| Error::Synthesis)?,
-        )?;
+                    let mut block = block.to_vec();
+                    let remainder = block.len() % L;
+
+                    if remainder != 0 {
+                        block.extend(vec![zero_val.clone(); L - remainder]);
+                    }
+
+                    let pow5_chip = Pow5Chip::construct(self.config.pow5_config.clone());
+                    // initialize the hasher
+                    let hasher = Hash::<_, _, S, ConstantLength<L>, WIDTH, RATE>::init(
+                        pow5_chip,
+                        layouter.namespace(|| "block_hasher"),
+                    )?;
+
+                    let hash = hasher.hash(
+                        layouter.namespace(|| "hash"),
+                        block.to_vec().try_into().map_err(|_| Error::Synthesis)?,
+                    );
+
+                    if i == 0 {
+                        log::trace!("block (L={:?}) took: {:?}", L, _start_time.elapsed());
+                    }
+
+                    hash
+                })
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|e| e.into());
+
+            log::trace!("hashes (N={:?}) took: {:?}", len, start_time.elapsed());
+            one_iter = true;
+            input_cells = hashes?;
+        }
 
         let duration = start_time.elapsed();
         log::trace!("layout (N={:?}) took: {:?}", len, duration);
 
-        let result = Tensor::from(vec![ValType::from(hash.clone())].into_iter());
+        let result = Tensor::from(input_cells.iter().map(|e| ValType::from(e.clone())));
 
         let output = match result[0].clone() {
             ValType::PrevAssigned(v) => v,
@@ -342,59 +390,69 @@ impl<S: Spec<Fp, WIDTH, RATE> + Sync, const WIDTH: usize, const RATE: usize> Mod
 
     ///
     fn run(message: Vec<Fp>) -> Result<Vec<Vec<Fp>>, ModuleError> {
-        let len = message.len();
-        if len == 0 {
-            return Ok(vec![vec![]]);
-        }
+        let mut hash_inputs = message;
+
+        let len = hash_inputs.len();
 
         let start_time = instant::Instant::now();
 
-        let hash = halo2_gadgets::poseidon::primitives::Hash::<
-            _,
-            S,
-            VariableLength,
-            { WIDTH },
-            { RATE },
-        >::init()
-        .hash(message);
+        let mut one_iter = false;
+        // do the Tree dance baby
+        while hash_inputs.len() > 1 || !one_iter {
+            let hashes: Vec<Fp> = hash_inputs
+                .par_chunks(L)
+                .map(|block| {
+                    let mut block = block.to_vec();
+                    let remainder = block.len() % L;
+
+                    if remainder != 0 {
+                        block.extend(vec![Fp::ZERO; L - remainder].iter());
+                    }
+
+                    let block_len = block.len();
+
+                    let message = block
+                        .try_into()
+                        .map_err(|_| ModuleError::InputWrongLength(block_len))?;
+
+                    Ok(halo2_gadgets::poseidon::primitives::Hash::<
+                        _,
+                        S,
+                        ConstantLength<L>,
+                        { WIDTH },
+                        { RATE },
+                    >::init()
+                    .hash(message))
+                })
+                .collect::<Result<Vec<_>, ModuleError>>()?;
+            one_iter = true;
+            hash_inputs = hashes;
+        }
 
         let duration = start_time.elapsed();
         log::trace!("run (N={:?}) took: {:?}", len, duration);
 
-        Ok(vec![vec![hash]])
+        Ok(vec![hash_inputs])
     }
 
-    fn num_rows(input_len: usize) -> usize {
+    fn num_rows(mut input_len: usize) -> usize {
         // this was determined by running the circuit and looking at the number of constraints
         // in the test called hash_for_a_range_of_input_sizes, then regressing in python to find the slope
-        // import numpy as np
-        // from scipy import stats
+        let fixed_cost: usize = 41 * L;
 
-        // x = np.array([32, 64, 96, 128, 160, 192])
-        // y = np.array([1298, 2594, 3890, 5186, 6482, 7778])
+        let mut num_rows = 0;
 
-        // slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)
+        loop {
+            // the number of times the input_len is divisible by L
+            let num_chunks = input_len / L + 1;
+            num_rows += num_chunks * fixed_cost;
+            if num_chunks == 1 {
+                break;
+            }
+            input_len = num_chunks;
+        }
 
-        // print(f"slope: {slope}")
-        // print(f"intercept: {intercept}")
-        // print(f"R^2: {r_value**2}")
-
-        // # Predict for any x
-        // def predict(x):
-        // return slope * x + intercept
-
-        // # Test prediction
-        // test_x = 256
-        // print(f"Predicted value for x={test_x}: {predict(test_x)}")
-        // our output:
-        // slope: 40.5
-        // intercept: 2.0
-        // R^2: 1.0
-        // Predicted value for x=256: 10370.0
-        let fixed_cost: usize = 41 * input_len;
-
-        // the cost of the hash function is linear with the number of inputs
-        fixed_cost + 2
+        num_rows
     }
 }
 
@@ -421,12 +479,12 @@ mod tests {
     const RATE: usize = POSEIDON_RATE;
     const R: usize = 240;
 
-    struct HashCircuit<S: Spec<Fp, WIDTH, RATE>> {
+    struct HashCircuit<S: Spec<Fp, WIDTH, RATE>, const L: usize> {
         message: ValTensor<Fp>,
         _spec: PhantomData<S>,
     }
 
-    impl<S: Spec<Fp, WIDTH, RATE>> Circuit<Fp> for HashCircuit<S> {
+    impl<S: Spec<Fp, WIDTH, RATE>, const L: usize> Circuit<Fp> for HashCircuit<S, L> {
         type Config = PoseidonConfig<WIDTH, RATE>;
         type FloorPlanner = ModulePlanner;
         type Params = ();
@@ -442,7 +500,7 @@ mod tests {
         }
 
         fn configure(meta: &mut ConstraintSystem<Fp>) -> PoseidonConfig<WIDTH, RATE> {
-            PoseidonChip::<PoseidonSpec, WIDTH, RATE>::configure(meta, ())
+            PoseidonChip::<PoseidonSpec, WIDTH, RATE, L>::configure(meta, ())
         }
 
         fn synthesize(
@@ -450,7 +508,7 @@ mod tests {
             config: PoseidonConfig<WIDTH, RATE>,
             mut layouter: impl Layouter<Fp>,
         ) -> Result<(), Error> {
-            let chip: PoseidonChip<PoseidonSpec, WIDTH, RATE> = PoseidonChip::new(config);
+            let chip: PoseidonChip<PoseidonSpec, WIDTH, RATE, L> = PoseidonChip::new(config);
             chip.layout(
                 &mut layouter,
                 &[self.message.clone()],
@@ -465,15 +523,15 @@ mod tests {
     #[test]
     fn poseidon_hash_empty() {
         let message = [];
-        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(message.to_vec()).unwrap();
+        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE, 2>::run(message.to_vec()).unwrap();
         let mut message: Tensor<ValType<Fp>> =
             message.into_iter().map(|m| Value::known(m).into()).into();
         let k = 9;
-        let circuit = HashCircuit::<PoseidonSpec> {
+        let circuit = HashCircuit::<PoseidonSpec, 2> {
             message: message.into(),
             _spec: PhantomData,
         };
-        let prover = halo2_proofs::dev::MockProver::run(k, &circuit, vec![vec![]]).unwrap();
+        let prover = halo2_proofs::dev::MockProver::run(k, &circuit, output).unwrap();
         assert_eq!(prover.verify(), Ok(()))
     }
 
@@ -482,13 +540,13 @@ mod tests {
         let rng = rand::rngs::OsRng;
 
         let message = [Fp::random(rng), Fp::random(rng)];
-        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(message.to_vec()).unwrap();
+        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE, 2>::run(message.to_vec()).unwrap();
 
         let mut message: Tensor<ValType<Fp>> =
             message.into_iter().map(|m| Value::known(m).into()).into();
 
         let k = 9;
-        let circuit = HashCircuit::<PoseidonSpec> {
+        let circuit = HashCircuit::<PoseidonSpec, 2> {
             message: message.into(),
             _spec: PhantomData,
         };
@@ -501,13 +559,13 @@ mod tests {
         let rng = rand::rngs::OsRng;
 
         let message = [Fp::random(rng), Fp::random(rng), Fp::random(rng)];
-        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(message.to_vec()).unwrap();
+        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE, 3>::run(message.to_vec()).unwrap();
 
         let mut message: Tensor<ValType<Fp>> =
             message.into_iter().map(|m| Value::known(m).into()).into();
 
         let k = 9;
-        let circuit = HashCircuit::<PoseidonSpec> {
+        let circuit = HashCircuit::<PoseidonSpec, 3> {
             message: message.into(),
             _spec: PhantomData,
         };
@@ -523,21 +581,23 @@ mod tests {
         #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
         env_logger::init();
 
-        for i in (32..128).step_by(32) {
+        {
+            let i = 32;
             // print a bunch of new lines
-            log::info!(
+            println!(
                 "i is {} -------------------------------------------------",
                 i
             );
 
             let message: Vec<Fp> = (0..i).map(|_| Fp::random(rng)).collect::<Vec<_>>();
-            let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(message.clone()).unwrap();
+            let output =
+                PoseidonChip::<PoseidonSpec, WIDTH, RATE, 32>::run(message.clone()).unwrap();
 
             let mut message: Tensor<ValType<Fp>> =
                 message.into_iter().map(|m| Value::known(m).into()).into();
 
             let k = 17;
-            let circuit = HashCircuit::<PoseidonSpec> {
+            let circuit = HashCircuit::<PoseidonSpec, 32> {
                 message: message.into(),
                 _spec: PhantomData,
             };
@@ -554,13 +614,13 @@ mod tests {
 
         let mut message: Vec<Fp> = (0..2048).map(|_| Fp::random(rng)).collect::<Vec<_>>();
 
-        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(message.clone()).unwrap();
+        let output = PoseidonChip::<PoseidonSpec, WIDTH, RATE, 25>::run(message.clone()).unwrap();
 
         let mut message: Tensor<ValType<Fp>> =
             message.into_iter().map(|m| Value::known(m).into()).into();
 
         let k = 17;
-        let circuit = HashCircuit::<PoseidonSpec> {
+        let circuit = HashCircuit::<PoseidonSpec, 25> {
             message: message.into(),
             _spec: PhantomData,
         };

src/circuit/ops/base.rs

@@ -17,6 +17,7 @@ pub enum BaseOp {
     Sub,
     SumInit,
     Sum,
+    IsBoolean,
 }
 
 /// Matches a [BaseOp] to an operation over inputs
@@ -33,6 +34,7 @@ impl BaseOp {
             BaseOp::Add => a + b,
             BaseOp::Sub => a - b,
             BaseOp::Mult => a * b,
+            BaseOp::IsBoolean => b,
             _ => panic!("nonaccum_f called on accumulating operation"),
         }
     }
@@ -72,6 +74,7 @@ impl BaseOp {
             BaseOp::Mult => "MULT",
             BaseOp::Sum => "SUM",
             BaseOp::SumInit => "SUMINIT",
+            BaseOp::IsBoolean => "ISBOOLEAN",
         }
     }
 
@@ -87,6 +90,7 @@ impl BaseOp {
             BaseOp::Mult => (0, 1),
             BaseOp::Sum => (-1, 2),
             BaseOp::SumInit => (0, 1),
+            BaseOp::IsBoolean => (0, 1),
         }
     }
 
@@ -102,6 +106,7 @@ impl BaseOp {
             BaseOp::Mult => 2,
             BaseOp::Sum => 1,
             BaseOp::SumInit => 1,
+            BaseOp::IsBoolean => 0,
         }
     }
 
@@ -117,6 +122,7 @@ impl BaseOp {
             BaseOp::SumInit => 0,
             BaseOp::CumProd => 1,
             BaseOp::CumProdInit => 0,
+            BaseOp::IsBoolean => 0,
         }
     }
 }

src/circuit/ops/chip.rs

@@ -20,6 +20,7 @@ use crate::{
     circuit::{
         ops::base::BaseOp,
         table::{Range, RangeCheck, Table},
+        utils,
     },
     tensor::{Tensor, TensorType, ValTensor, VarTensor},
 };
@@ -84,6 +85,55 @@ impl CheckMode {
     }
 }
 
+#[allow(missing_docs)]
+/// An enum representing the tolerance we can accept for the accumulated arguments, either absolute or percentage
+#[derive(Clone, Default, Debug, PartialEq, PartialOrd, Serialize, Deserialize, Copy)]
+pub struct Tolerance {
+    pub val: f32,
+    pub scale: utils::F32,
+}
+
+impl std::fmt::Display for Tolerance {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:.2}", self.val)
+    }
+}
+
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
+impl ToFlags for Tolerance {
+    /// Convert the struct to a subcommand string
+    fn to_flags(&self) -> Vec<String> {
+        vec![format!("{}", self)]
+    }
+}
+
+impl FromStr for Tolerance {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Ok(val) = s.parse::<f32>() {
+            Ok(Tolerance {
+                val,
+                scale: utils::F32(1.0),
+            })
+        } else {
+            Err(
+                "Invalid tolerance value provided. It should expressed as a percentage (f32)."
+                    .to_string(),
+            )
+        }
+    }
+}
+
+impl From<f32> for Tolerance {
+    fn from(value: f32) -> Self {
+        Tolerance {
+            val: value,
+            scale: utils::F32(1.0),
+        }
+    }
+}
+
 #[cfg(feature = "python-bindings")]
 /// Converts CheckMode into a PyObject (Required for CheckMode to be compatible with Python)
 impl IntoPy<PyObject> for CheckMode {
@@ -108,6 +158,29 @@ impl<'source> FromPyObject<'source> for CheckMode {
     }
 }
 
+#[cfg(feature = "python-bindings")]
+/// Converts Tolerance into a PyObject (Required for Tolerance to be compatible with Python)
+impl IntoPy<PyObject> for Tolerance {
+    fn into_py(self, py: Python) -> PyObject {
+        (self.val, self.scale.0).to_object(py)
+    }
+}
+
+#[cfg(feature = "python-bindings")]
+/// Obtains Tolerance from PyObject (Required for Tolerance to be compatible with Python)
+impl<'source> FromPyObject<'source> for Tolerance {
+    fn extract_bound(ob: &pyo3::Bound<'source, pyo3::PyAny>) -> PyResult<Self> {
+        if let Ok((val, scale)) = <(f32, f32)>::extract_bound(ob) {
+            Ok(Tolerance {
+                val,
+                scale: utils::F32(scale),
+            })
+        } else {
+            Err(PyValueError::new_err("Invalid tolerance value provided. "))
+        }
+    }
+}
+
 /// A struct representing the selectors for the dynamic lookup tables
 #[derive(Clone, Debug, Default)]
 pub struct DynamicLookups {
@@ -321,6 +394,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
                 nonaccum_selectors.insert((BaseOp::Add, i, j), meta.selector());
                 nonaccum_selectors.insert((BaseOp::Sub, i, j), meta.selector());
                 nonaccum_selectors.insert((BaseOp::Mult, i, j), meta.selector());
+                nonaccum_selectors.insert((BaseOp::IsBoolean, i, j), meta.selector());
             }
         }
 
@@ -354,13 +428,24 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
                 // Get output expressions for each input channel
                 let (rotation_offset, rng) = base_op.query_offset_rng();
 
-                let constraints = {
-                    let expected_output: Tensor<Expression<F>> = output
-                        .query_rng(meta, *block_idx, *inner_col_idx, rotation_offset, rng)
-                        .expect("non accum: output query failed");
+                let constraints = match base_op {
+                    BaseOp::IsBoolean => {
+                        let expected_output: Tensor<Expression<F>> = output
+                            .query_rng(meta, *block_idx, *inner_col_idx, 0, 1)
+                            .expect("non accum: output query failed");
 
-                    let res = base_op.nonaccum_f((qis[0].clone(), qis[1].clone()));
-                    vec![expected_output[base_op.constraint_idx()].clone() - res]
+                        let output = expected_output[base_op.constraint_idx()].clone();
+
+                        vec![(output.clone()) * (output.clone() - Expression::Constant(F::from(1)))]
+                    }
+                    _ => {
+                        let expected_output: Tensor<Expression<F>> = output
+                            .query_rng(meta, *block_idx, *inner_col_idx, rotation_offset, rng)
+                            .expect("non accum: output query failed");
+
+                        let res = base_op.nonaccum_f((qis[0].clone(), qis[1].clone()));
+                        vec![expected_output[base_op.constraint_idx()].clone() - res]
+                    }
                 };
 
                 Constraints::with_selector(selector, constraints)

src/circuit/ops/errors.rs

@@ -106,7 +106,4 @@ pub enum CircuitError {
     /// Visibility has not been set
     #[error("visibility has not been set")]
     UnsetVisibility,
-    /// A decomposition base overflowed
-    #[error("decomposition base overflowed")]
-    DecompositionBaseOverflow,
 }

src/circuit/ops/hybrid.rs

@@ -1,9 +1,9 @@
 use super::*;
 use crate::{
-    circuit::{layouts, utils},
+    circuit::{layouts, utils, Tolerance},
     fieldutils::{integer_rep_to_felt, IntegerRep},
     graph::multiplier_to_scale,
-    tensor::{self, DataFormat, Tensor, TensorType, ValTensor},
+    tensor::{self, Tensor, TensorType, ValTensor},
 };
 use halo2curves::ff::PrimeField;
 use serde::{Deserialize, Serialize};
@@ -57,13 +57,11 @@ pub enum HybridOp {
         stride: Vec<usize>,
         kernel_shape: Vec<usize>,
         normalized: bool,
-        data_format: DataFormat,
     },
     MaxPool {
         padding: Vec<(usize, usize)>,
         stride: Vec<usize>,
         pool_dims: Vec<usize>,
-        data_format: DataFormat,
     },
     ReduceMin {
         axes: Vec<usize>,
@@ -78,9 +76,7 @@ pub enum HybridOp {
         output_scale: utils::F32,
         axes: Vec<usize>,
     },
-    Output {
-        decomp: bool,
-    },
+    RangeCheck(Tolerance),
     Greater,
     GreaterEqual,
     Less,
@@ -155,10 +151,10 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                 padding,
                 stride,
                 kernel_shape,
-                normalized, data_format
+                normalized,
             } => format!(
-                "SUMPOOL (padding={:?}, stride={:?}, kernel_shape={:?}, normalized={}, data_format={:?})",
-                padding, stride, kernel_shape, normalized, data_format
+                "SUMPOOL (padding={:?}, stride={:?}, kernel_shape={:?}, normalized={})",
+                padding, stride, kernel_shape, normalized
             ),
             HybridOp::ReduceMax { axes } => format!("REDUCEMAX (axes={:?})", axes),
             HybridOp::ReduceArgMax { dim } => format!("REDUCEARGMAX (dim={})", dim),
@@ -166,10 +162,9 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                 padding,
                 stride,
                 pool_dims,
-                data_format,
             } => format!(
-                "MaxPool (padding={:?}, stride={:?}, pool_dims={:?}, data_format={:?})",
-                padding, stride, pool_dims, data_format
+                "MaxPool (padding={:?}, stride={:?}, pool_dims={:?})",
+                padding, stride, pool_dims
             ),
             HybridOp::ReduceMin { axes } => format!("REDUCEMIN (axes={:?})", axes),
             HybridOp::ReduceArgMin { dim } => format!("REDUCEARGMIN (dim={})", dim),
@@ -183,9 +178,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                     input_scale, output_scale, axes
                 )
             }
-            HybridOp::Output { decomp } => {
-                format!("OUTPUT (decomp={})", decomp)
-            }
+            HybridOp::RangeCheck(p) => format!("RANGECHECK (tol={:?})", p),
             HybridOp::Greater => "GREATER".to_string(),
             HybridOp::GreaterEqual => "GREATEREQUAL".to_string(),
             HybridOp::Less => "LESS".to_string(),
@@ -241,7 +234,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                 stride,
                 kernel_shape,
                 normalized,
-                data_format,
             } => layouts::sumpool(
                 config,
                 region,
@@ -250,7 +242,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                 stride,
                 kernel_shape,
                 *normalized,
-                *data_format,
             )?,
             HybridOp::Recip {
                 input_scale,
@@ -291,7 +282,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                 padding,
                 stride,
                 pool_dims,
-                data_format,
             } => layouts::max_pool(
                 config,
                 region,
@@ -299,7 +289,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                 padding,
                 stride,
                 pool_dims,
-                *data_format,
             )?,
             HybridOp::ReduceMax { axes } => {
                 layouts::max_axes(config, region, values[..].try_into()?, axes)?
@@ -325,9 +314,13 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                 *output_scale,
                 axes,
             )?,
-            HybridOp::Output { decomp } => {
-                layouts::output(config, region, values[..].try_into()?, *decomp)?
-            }
+            HybridOp::RangeCheck(tol) => layouts::range_check_percent(
+                config,
+                region,
+                values[..].try_into()?,
+                tol.scale,
+                tol.val,
+            )?,
             HybridOp::Greater => layouts::greater(config, region, values[..].try_into()?)?,
             HybridOp::GreaterEqual => {
                 layouts::greater_equal(config, region, values[..].try_into()?)?

src/circuit/ops/mod.rs

@@ -1,8 +1,6 @@
 use std::any::Any;
 
 use serde::{Deserialize, Serialize};
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-use tract_onnx::prelude::DatumType;
 
 use crate::{
     graph::quantize_tensor,
@@ -98,8 +96,6 @@ pub enum InputType {
     Int,
     ///
     TDim,
-    ///
-    Unknown,
 }
 
 impl InputType {
@@ -136,7 +132,6 @@ impl InputType {
                 let int_input = input.clone().to_i64().unwrap();
                 *input = T::from_i64(int_input).unwrap();
             }
-            InputType::Unknown => {}
         }
     }
 }
@@ -157,28 +152,6 @@ impl std::str::FromStr for InputType {
     }
 }
 
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-impl From<DatumType> for InputType {
-    fn from(datum_type: DatumType) -> Self {
-        match datum_type {
-            DatumType::Bool => InputType::Bool,
-            DatumType::F16 => InputType::F16,
-            DatumType::F32 => InputType::F32,
-            DatumType::F64 => InputType::F64,
-            DatumType::I8 => InputType::Int,
-            DatumType::I16 => InputType::Int,
-            DatumType::I32 => InputType::Int,
-            DatumType::I64 => InputType::Int,
-            DatumType::U8 => InputType::Int,
-            DatumType::U16 => InputType::Int,
-            DatumType::U32 => InputType::Int,
-            DatumType::U64 => InputType::Int,
-            DatumType::TDim => InputType::TDim,
-            _ => unimplemented!(),
-        }
-    }
-}
-
 ///
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct Input {
@@ -186,8 +159,6 @@ pub struct Input {
     pub scale: crate::Scale,
     ///
     pub datum_type: InputType,
-    /// decomp check
-    pub decomp: bool,
 }
 
 impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input {
@@ -225,7 +196,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input
                     config,
                     region,
                     values[..].try_into()?,
-                    self.decomp,
                 )?)),
             }
         } else {
@@ -281,18 +251,15 @@ pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
     ///
     #[serde(skip)]
     pub pre_assigned_val: Option<ValTensor<F>>,
-    ///
-    pub decomp: bool,
 }
 
 impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Constant<F> {
     ///
-    pub fn new(quantized_values: Tensor<F>, raw_values: Tensor<f32>, decomp: bool) -> Self {
+    pub fn new(quantized_values: Tensor<F>, raw_values: Tensor<f32>) -> Self {
         Self {
             quantized_values,
             raw_values,
             pre_assigned_val: None,
-            decomp,
         }
     }
     /// Rebase the scale of the constant
@@ -301,8 +268,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Constant<F> {
             Some(v) => v,
             None => return Err(CircuitError::UnsetVisibility),
         };
-        self.quantized_values =
-            quantize_tensor(self.raw_values.clone(), new_scale, &visibility, true)?;
+        self.quantized_values = quantize_tensor(self.raw_values.clone(), new_scale, &visibility)?;
         Ok(())
     }
 
@@ -318,8 +284,13 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Constant<F> {
 }
 
 impl<
-    F: PrimeField + TensorType + PartialOrd + std::hash::Hash + Serialize + for<'de> Deserialize<'de>,
-> Op<F> for Constant<F>
+        F: PrimeField
+            + TensorType
+            + PartialOrd
+            + std::hash::Hash
+            + Serialize
+            + for<'de> Deserialize<'de>,
+    > Op<F> for Constant<F>
 {
     fn as_any(&self) -> &dyn Any {
         self
@@ -340,12 +311,7 @@ impl<
             self.quantized_values.clone().try_into()?
         };
         // we gotta constrain it once if its used multiple times
-        Ok(Some(layouts::identity(
-            config,
-            region,
-            &[value],
-            self.decomp,
-        )?))
+        Ok(Some(layouts::identity(config, region, &[value])?))
     }
 
     fn clone_dyn(&self) -> Box<dyn Op<F>> {

src/circuit/ops/poly.rs

@@ -4,7 +4,6 @@ use crate::{
         utils::{self, F32},
     },
     tensor::{self, Tensor, TensorError},
-    tensor::{DataFormat, KernelFormat},
 };
 
 use super::{base::BaseOp, *};
@@ -44,8 +43,6 @@ pub enum PolyOp {
         padding: Vec<(usize, usize)>,
         stride: Vec<usize>,
         group: usize,
-        data_format: DataFormat,
-        kernel_format: KernelFormat,
     },
     Downsample {
         axis: usize,
@@ -57,8 +54,6 @@ pub enum PolyOp {
         output_padding: Vec<usize>,
         stride: Vec<usize>,
         group: usize,
-        data_format: DataFormat,
-        kernel_format: KernelFormat,
     },
     Add,
     Sub,
@@ -170,12 +165,10 @@ impl<
                 stride,
                 padding,
                 group,
-                data_format,
-                kernel_format,
             } => {
                 format!(
-                    "CONV (stride={:?}, padding={:?}, group={}, data_format={:?}, kernel_format={:?})",
-                    stride, padding, group, data_format, kernel_format
+                    "CONV (stride={:?}, padding={:?}, group={})",
+                    stride, padding, group
                 )
             }
             PolyOp::DeConv {
@@ -183,12 +176,11 @@ impl<
                 padding,
                 output_padding,
                 group,
-                data_format,
-                kernel_format,
             } => {
                 format!(
-                    "DECONV (stride={:?}, padding={:?}, output_padding={:?}, group={}, data_format={:?}, kernel_format={:?})",
-                    stride, padding, output_padding, group, data_format, kernel_format)
+                    "DECONV (stride={:?}, padding={:?}, output_padding={:?}, group={})",
+                    stride, padding, output_padding, group
+                )
             }
             PolyOp::Concat { axis } => format!("CONCAT (axis={})", axis),
             PolyOp::Slice { axis, start, end } => {
@@ -250,8 +242,6 @@ impl<
                 padding,
                 stride,
                 group,
-                data_format,
-                kernel_format,
             } => layouts::conv(
                 config,
                 region,
@@ -259,8 +249,6 @@ impl<
                 padding,
                 stride,
                 *group,
-                *data_format,
-                *kernel_format,
             )?,
             PolyOp::GatherElements { dim, constant_idx } => {
                 if let Some(idx) = constant_idx {
@@ -321,8 +309,6 @@ impl<
                 output_padding,
                 stride,
                 group,
-                data_format,
-                kernel_format,
             } => layouts::deconv(
                 config,
                 region,
@@ -331,17 +317,13 @@ impl<
                 output_padding,
                 stride,
                 *group,
-                *data_format,
-                *kernel_format,
             )?,
             PolyOp::Add => layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Add)?,
             PolyOp::Sub => layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Sub)?,
             PolyOp::Mult => {
                 layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Mult)?
             }
-            PolyOp::Identity { .. } => {
-                layouts::identity(config, region, values[..].try_into()?, false)?
-            }
+            PolyOp::Identity { .. } => layouts::identity(config, region, values[..].try_into()?)?,
             PolyOp::Reshape(d) | PolyOp::Flatten(d) => layouts::reshape(values[..].try_into()?, d)?,
             PolyOp::Pad(p) => {
                 if values.len() != 1 {

src/circuit/tests.rs

@@ -1,6 +1,5 @@
 use crate::circuit::ops::poly::PolyOp;
 use crate::circuit::*;
-use crate::tensor::{DataFormat, KernelFormat};
 use crate::tensor::{Tensor, TensorType, ValTensor, VarTensor};
 use halo2_proofs::{
     circuit::{Layouter, SimpleFloorPlanner, Value},
@@ -1066,8 +1065,6 @@ mod conv {
                                     padding: vec![(1, 1); 2],
                                     stride: vec![2; 2],
                                     group: 1,
-                                    data_format: DataFormat::default(),
-                                    kernel_format: KernelFormat::default(),
                                 }),
                             )
                             .map_err(|_| Error::Synthesis)
@@ -1223,8 +1220,6 @@ mod conv_col_ultra_overflow {
                                     padding: vec![(1, 1); 2],
                                     stride: vec![2; 2],
                                     group: 1,
-                                    data_format: DataFormat::default(),
-                                    kernel_format: KernelFormat::default(),
                                 }),
                             )
                             .map_err(|_| Error::Synthesis)
@@ -1382,8 +1377,6 @@ mod conv_relu_col_ultra_overflow {
                                     padding: vec![(1, 1); 2],
                                     stride: vec![2; 2],
                                     group: 1,
-                                    data_format: DataFormat::default(),
-                                    kernel_format: KernelFormat::default(),
                                 }),
                             )
                             .map_err(|_| Error::Synthesis);
@@ -1820,7 +1813,6 @@ mod shuffle {
                                 &mut region,
                                 &self.inputs[i],
                                 &self.references[i],
-                                layouts::SortCollisionMode::Unsorted,
                             )
                             .map_err(|_| Error::Synthesis)?;
                         }
@@ -2006,7 +1998,7 @@ mod add_with_overflow_and_poseidon {
             let base = BaseConfig::configure(cs, &[a, b], &output, CheckMode::SAFE);
             VarTensor::constant_cols(cs, K, 2, false);
 
-            let poseidon = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::configure(cs, ());
+            let poseidon = PoseidonChip::<PoseidonSpec, WIDTH, RATE, WIDTH>::configure(cs, ());
 
             MyCircuitConfig { base, poseidon }
         }
@@ -2016,7 +2008,7 @@ mod add_with_overflow_and_poseidon {
             mut config: Self::Config,
             mut layouter: impl Layouter<Fr>,
         ) -> Result<(), Error> {
-            let poseidon_chip: PoseidonChip<PoseidonSpec, WIDTH, RATE> =
+            let poseidon_chip: PoseidonChip<PoseidonSpec, WIDTH, RATE, WIDTH> =
                 PoseidonChip::new(config.poseidon.clone());
 
             let assigned_inputs_a =
@@ -2051,9 +2043,11 @@ mod add_with_overflow_and_poseidon {
         let b = (0..LEN)
             .map(|i| halo2curves::bn256::Fr::from(i as u64 + 1))
             .collect::<Vec<_>>();
-        let commitment_a = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(a.clone()).unwrap()[0][0];
+        let commitment_a =
+            PoseidonChip::<PoseidonSpec, WIDTH, RATE, WIDTH>::run(a.clone()).unwrap()[0][0];
 
-        let commitment_b = PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(b.clone()).unwrap()[0][0];
+        let commitment_b =
+            PoseidonChip::<PoseidonSpec, WIDTH, RATE, WIDTH>::run(b.clone()).unwrap()[0][0];
 
         // parameters
         let a = Tensor::from(a.into_iter().map(Value::known));
@@ -2075,11 +2069,13 @@ mod add_with_overflow_and_poseidon {
         let b = (0..LEN)
             .map(|i| halo2curves::bn256::Fr::from(i as u64 + 1))
             .collect::<Vec<_>>();
-        let commitment_a =
-            PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(a.clone()).unwrap()[0][0] + Fr::one();
+        let commitment_a = PoseidonChip::<PoseidonSpec, WIDTH, RATE, WIDTH>::run(a.clone())
+            .unwrap()[0][0]
+            + Fr::one();
 
-        let commitment_b =
-            PoseidonChip::<PoseidonSpec, WIDTH, RATE>::run(b.clone()).unwrap()[0][0] + Fr::one();
+        let commitment_b = PoseidonChip::<PoseidonSpec, WIDTH, RATE, WIDTH>::run(b.clone())
+            .unwrap()[0][0]
+            + Fr::one();
 
         // parameters
         let a = Tensor::from(a.into_iter().map(Value::known));

src/commands.rs

@@ -1,6 +1,6 @@
 use alloy::primitives::Address as H160;
 use clap::{Command, Parser, Subcommand};
-use clap_complete::{Generator, Shell, generate};
+use clap_complete::{generate, Generator, Shell};
 #[cfg(feature = "python-bindings")]
 use pyo3::{conversion::FromPyObject, exceptions::PyValueError, prelude::*};
 use serde::{Deserialize, Serialize};
@@ -8,7 +8,7 @@ use std::path::PathBuf;
 use std::str::FromStr;
 use tosubcommand::{ToFlags, ToSubcommand};
 
-use crate::{Commitments, RunArgs, pfsys::ProofType};
+use crate::{pfsys::ProofType, Commitments, RunArgs};
 
 use crate::circuit::CheckMode;
 use crate::graph::TestDataSource;
@@ -360,13 +360,8 @@ pub fn get_styles() -> clap::builder::Styles {
 }
 
 /// Print completions for the given generator
-pub fn print_completions<G: Generator>(r#gen: G, cmd: &mut Command) {
-    generate(
-        r#gen,
-        cmd,
-        cmd.get_name().to_string(),
-        &mut std::io::stdout(),
-    );
+pub fn print_completions<G: Generator>(gen: G, cmd: &mut Command) {
+    generate(gen, cmd, cmd.get_name().to_string(), &mut std::io::stdout());
 }
 
 #[allow(missing_docs)]
@@ -401,9 +396,8 @@ pub enum Commands {
     /// Generates the witness from an input file.
     GenWitness {
         /// The path to the .json data file
-        /// You can also pass the input data as a string, eg. --data '{"input_data": [1.0,2.0,3.0]}' directly and skip the file
         #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
+        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, value_hint = clap::ValueHint::FilePath)]
         compiled_circuit: Option<PathBuf>,
@@ -435,7 +429,7 @@ pub enum Commands {
         /// The path to the .onnx model file
         #[arg(short = 'M', long, default_value = DEFAULT_MODEL, value_hint = clap::ValueHint::FilePath)]
         model: Option<PathBuf>,
-        /// The path to the .json data file to output
+        /// The path to the .json data file
         #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
         data: Option<PathBuf>,
         /// Hand-written parser for graph variables, eg. batch_size=1
@@ -448,9 +442,8 @@ pub enum Commands {
     /// Calibrates the proving scale, lookup bits and logrows from a circuit settings file.
     CalibrateSettings {
         /// The path to the .json calibration data file.
-        /// You can also pass the input data as a string, eg. --data '{"input_data": [1.0,2.0,3.0]}' directly and skip the file
         #[arg(short = 'D', long, default_value = DEFAULT_CALIBRATION_FILE, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
+        data: Option<PathBuf>,
         /// The path to the .onnx model file
         #[arg(short = 'M', long, default_value = DEFAULT_MODEL, value_hint = clap::ValueHint::FilePath)]
         model: Option<PathBuf>,
@@ -633,9 +626,8 @@ pub enum Commands {
     #[command(arg_required_else_help = true)]
     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)
-        /// You can also pass the input data as a string, eg. --data '{"input_data": [1.0,2.0,3.0]}' directly and skip the file
         #[arg(short = 'D', long, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
+        data: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long, value_hint = clap::ValueHint::FilePath)]
         compiled_circuit: Option<PathBuf>,
@@ -661,9 +653,8 @@ pub enum Commands {
         #[arg(long, value_hint = clap::ValueHint::Other)]
         addr: H160Flag,
         /// The path to the .json data file.
-        /// You can also pass the input data as a string, eg. --data '{"input_data": [1.0,2.0,3.0]}' directly and skip the file
         #[arg(short = 'D', long, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
+        data: Option<PathBuf>,
         /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
         #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
         rpc_url: Option<String>,
@@ -780,7 +771,7 @@ pub enum Commands {
         /// view functions that return the data that the network
         /// ingests as inputs.
         #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
+        data: Option<PathBuf>,
         /// The path to the witness file. This is needed for proof swapping for kzg commitments.
         #[arg(short = 'W', long, default_value = DEFAULT_WITNESS, value_hint = clap::ValueHint::FilePath)]
         witness: Option<PathBuf>,
@@ -875,9 +866,8 @@ pub enum Commands {
     #[command(name = "deploy-evm-da")]
     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)
-        /// You can also pass the input data as a string, eg. --data '{"input_data": [1.0,2.0,3.0]}' directly and skip the file
         #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
+        data: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
         settings_path: Option<PathBuf>,

src/eth.rs

@@ -383,7 +383,7 @@ pub async fn deploy_contract_via_solidity(
 ///
 pub async fn deploy_da_verifier_via_solidity(
     settings_path: PathBuf,
-    input: String,
+    input: PathBuf,
     sol_code_path: PathBuf,
     rpc_url: Option<&str>,
     runs: usize,
@@ -391,7 +391,7 @@ pub async fn deploy_da_verifier_via_solidity(
 ) -> Result<H160, EthError> {
     let (client, client_address) = setup_eth_backend(rpc_url, private_key).await?;
 
-    let input = GraphData::from_str(&input).map_err(|_| EthError::GraphData)?;
+    let input = GraphData::from_path(input).map_err(|_| EthError::GraphData)?;
 
     let settings = GraphSettings::load(&settings_path).map_err(|_| EthError::GraphSettings)?;
 
@@ -688,10 +688,10 @@ fn parse_call_to_account(call_to_account: CallToAccount) -> Result<ParsedCallToA
 
 pub async fn update_account_calls(
     addr: H160,
-    input: String,
+    input: PathBuf,
     rpc_url: Option<&str>,
 ) -> Result<(), EthError> {
-    let input = GraphData::from_str(&input).map_err(|_| EthError::GraphData)?;
+    let input = GraphData::from_path(input).map_err(|_| EthError::GraphData)?;
 
     // The data that will be stored in the test contracts that will eventually be read from.
     let mut calls_to_accounts = vec![];

src/execute.rs

@@ -1,6 +1,5 @@
-use crate::EZKL_BUF_CAPACITY;
-use crate::circuit::CheckMode;
 use crate::circuit::region::RegionSettings;
+use crate::circuit::CheckMode;
 use crate::commands::CalibrationTarget;
 use crate::eth::{
     deploy_contract_via_solidity, deploy_da_verifier_via_solidity, fix_da_multi_sol,
@@ -13,21 +12,21 @@ use crate::graph::{GraphCircuit, GraphSettings, GraphWitness, Model};
 use crate::graph::{TestDataSource, TestSources};
 use crate::pfsys::evm::aggregation_kzg::{AggregationCircuit, PoseidonTranscript};
 use crate::pfsys::{
-    ProofSplitCommit, create_proof_circuit, swap_proof_commitments_polycommit, verify_proof_circuit,
+    create_keys, load_pk, load_vk, save_params, save_pk, Snark, StrategyType, TranscriptType,
 };
 use crate::pfsys::{
-    Snark, StrategyType, TranscriptType, create_keys, load_pk, load_vk, save_params, save_pk,
+    create_proof_circuit, swap_proof_commitments_polycommit, verify_proof_circuit, ProofSplitCommit,
 };
 use crate::pfsys::{save_vk, srs::*};
 use crate::tensor::TensorError;
+use crate::EZKL_BUF_CAPACITY;
+use crate::{commands::*, EZKLError};
 use crate::{Commitments, RunArgs};
-use crate::{EZKLError, commands::*};
 use colored::Colorize;
 #[cfg(unix)]
 use gag::Gag;
 use halo2_proofs::dev::VerifyFailure;
 use halo2_proofs::plonk::{self, Circuit};
-use halo2_proofs::poly::VerificationStrategy;
 use halo2_proofs::poly::commitment::{CommitmentScheme, Params};
 use halo2_proofs::poly::commitment::{ParamsProver, Verifier};
 use halo2_proofs::poly::ipa::commitment::{IPACommitmentScheme, ParamsIPA};
@@ -40,6 +39,7 @@ use halo2_proofs::poly::kzg::strategy::AccumulatorStrategy as KZGAccumulatorStra
 use halo2_proofs::poly::kzg::{
     commitment::ParamsKZG, strategy::SingleStrategy as KZGSingleStrategy,
 };
+use halo2_proofs::poly::VerificationStrategy;
 use halo2_proofs::transcript::{EncodedChallenge, TranscriptReadBuffer};
 use halo2_solidity_verifier;
 use halo2curves::bn256::{Bn256, Fr, G1Affine};
@@ -50,12 +50,12 @@ use instant::Instant;
 use itertools::Itertools;
 use log::debug;
 use log::{info, trace, warn};
-use serde::Serialize;
 use serde::de::DeserializeOwned;
+use serde::Serialize;
 use snark_verifier::loader::native::NativeLoader;
-use snark_verifier::system::halo2::Config;
 use snark_verifier::system::halo2::compile;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
+use snark_verifier::system::halo2::Config;
 use std::fs::File;
 use std::io::BufWriter;
 use std::io::{Cursor, Write};
@@ -516,9 +516,7 @@ fn update_ezkl_binary(version: &Option<String>) -> Result<String, EZKLError> {
         .status()
         .is_err()
     {
-        log::warn!(
-            "bash is not installed on this system, trying to run the install script with sh (may fail)"
-        );
+        log::warn!("bash is not installed on this system, trying to run the install script with sh (may fail)");
         "sh"
     } else {
         "bash"
@@ -727,7 +725,7 @@ pub(crate) fn table(model: PathBuf, run_args: RunArgs) -> Result<String, EZKLErr
 
 pub(crate) async fn gen_witness(
     compiled_circuit_path: PathBuf,
-    data: String,
+    data: PathBuf,
     output: Option<PathBuf>,
     vk_path: Option<PathBuf>,
     srs_path: Option<PathBuf>,
@@ -735,7 +733,7 @@ pub(crate) async fn gen_witness(
     // these aren't real values so the sanity checks are mostly meaningless
 
     let mut circuit = GraphCircuit::load(compiled_circuit_path)?;
-    let data = GraphData::from_str(&data)?;
+    let data: GraphData = GraphData::from_path(data)?;
     let settings = circuit.settings().clone();
 
     let vk = if let Some(vk) = vk_path {
@@ -878,7 +876,7 @@ pub(crate) fn gen_random_data(
 
         let mut tensor = TractTensor::zero::<f32>(sizes).unwrap();
         let slice = tensor.as_slice_mut::<f32>().unwrap();
-        slice.iter_mut().for_each(|x| *x = rng.r#gen());
+        slice.iter_mut().for_each(|x| *x = rng.gen());
         tensor.cast_to_dt(datum_type).unwrap().into_owned()
     }
 
@@ -1046,7 +1044,7 @@ impl AccuracyResults {
 #[allow(clippy::too_many_arguments)]
 pub(crate) async fn calibrate(
     model_path: PathBuf,
-    data: String,
+    data: PathBuf,
     settings_path: PathBuf,
     target: CalibrationTarget,
     lookup_safety_margin: f64,
@@ -1060,7 +1058,7 @@ pub(crate) async fn calibrate(
 
     use crate::fieldutils::IntegerRep;
 
-    let data = GraphData::from_str(&data)?;
+    let data = GraphData::from_path(data)?;
     // load the pre-generated settings
     let settings = GraphSettings::load(&settings_path)?;
     // now retrieve the run args
@@ -1524,7 +1522,7 @@ pub(crate) async fn create_evm_data_attestation(
     settings_path: PathBuf,
     sol_code_path: PathBuf,
     abi_path: PathBuf,
-    input: String,
+    input: PathBuf,
     witness: Option<PathBuf>,
 ) -> Result<String, EZKLError> {
     #[allow(unused_imports)]
@@ -1538,7 +1536,7 @@ pub(crate) async fn create_evm_data_attestation(
 
     // if input is not provided, we just instantiate dummy input data
     let data =
-        GraphData::from_str(&input).unwrap_or_else(|_| GraphData::new(DataSource::File(vec![])));
+        GraphData::from_path(input).unwrap_or_else(|_| GraphData::new(DataSource::File(vec![])));
 
     // The number of input and output instances we attest to for the single call data attestation
     let mut input_len = None;
@@ -1627,7 +1625,7 @@ pub(crate) async fn create_evm_data_attestation(
 }
 
 pub(crate) async fn deploy_da_evm(
-    data: String,
+    data: PathBuf,
     settings_path: PathBuf,
     sol_code_path: PathBuf,
     rpc_url: Option<String>,
@@ -1870,7 +1868,7 @@ pub(crate) fn setup(
 }
 
 pub(crate) async fn setup_test_evm_witness(
-    data_path: String,
+    data_path: PathBuf,
     compiled_circuit_path: PathBuf,
     test_data: PathBuf,
     rpc_url: Option<String>,
@@ -1879,7 +1877,7 @@ pub(crate) async fn setup_test_evm_witness(
 ) -> Result<String, EZKLError> {
     use crate::graph::TestOnChainData;
 
-    let mut data = GraphData::from_str(&data_path)?;
+    let mut data = GraphData::from_path(data_path)?;
     let mut circuit = GraphCircuit::load(compiled_circuit_path)?;
 
     // if both input and output are from files fail
@@ -1907,7 +1905,7 @@ pub(crate) async fn setup_test_evm_witness(
 use crate::pfsys::ProofType;
 pub(crate) async fn test_update_account_calls(
     addr: H160Flag,
-    data: String,
+    data: PathBuf,
     rpc_url: Option<String>,
 ) -> Result<String, EZKLError> {
     use crate::eth::update_account_calls;

src/graph/errors.rs

@@ -33,7 +33,7 @@ pub enum GraphError {
     #[error("a node is missing required params: {0}")]
     MissingParams(String),
     /// A node has missing parameters
-    #[error("a node has misformed params: {0}")]
+    #[error("a node is has misformed params: {0}")]
     MisformedParams(String),
     /// Error in the configuration of the visibility of variables
     #[error("there should be at least one set of public variables")]

src/graph/input.rs

@@ -528,27 +528,6 @@ impl GraphData {
         }
     }
 
-    /// Loads graph input data from a string, first seeing if it is a file path or JSON data
-    /// If it is a file path, it will load the data from the file
-    /// Otherwise, it will attempt to parse the string as JSON data
-    /// 
-    /// # Arguments
-    /// * `data` - String containing the input data
-    /// # Returns
-    /// A new GraphData instance containing the loaded data
-    pub fn from_str(data: &str) -> Result<Self, GraphError> {
-        let graph_input = serde_json::from_str(data); 
-        match graph_input {
-            Ok(graph_input) => {
-                return Ok(graph_input);
-            }
-            Err(_) => {
-                let path = std::path::PathBuf::from(data);
-                GraphData::from_path(path)
-            }
-        }
-    }
-
     /// Loads graph input data from a file
     ///
     /// # Arguments
@@ -630,12 +609,8 @@ impl GraphData {
             if input.len() % input_size != 0 {
                 return Err(GraphError::InvalidDims(
                     0,
-                    format!(
-                        "calibration data length (={}) must be evenly divisible by the original input_size(={})",
-                        input.len(),
-                        input_size
-                    ),
-                    
+                    "calibration data length must be evenly divisible by the original input_size"
+                        .to_string(),
                 ));
             }
 

src/graph/mod.rs

@@ -455,10 +455,6 @@ pub struct GraphSettings {
     pub num_blinding_factors: Option<usize>,
     /// unix time timestamp
     pub timestamp: Option<u128>,
-    /// Model inputs types (if any)
-    pub input_types: Option<Vec<InputType>>,
-    /// Model outputs types (if any)
-    pub output_types: Option<Vec<InputType>>,
 }
 
 impl GraphSettings {

src/graph/model.rs

@@ -1,6 +1,7 @@
 use super::errors::GraphError;
 use super::extract_const_quantized_values;
 use super::node::*;
+use super::scale_to_multiplier;
 use super::vars::*;
 use super::GraphSettings;
 use crate::circuit::hybrid::HybridOp;
@@ -378,15 +379,9 @@ pub struct ParsedNodes {
     pub nodes: BTreeMap<usize, NodeType>,
     inputs: Vec<usize>,
     outputs: Vec<Outlet>,
-    output_types: Vec<InputType>,
 }
 
 impl ParsedNodes {
-    /// Returns the output types of the computational graph.
-    pub fn get_output_types(&self) -> Vec<InputType> {
-        self.output_types.clone()
-    }
-
     /// Returns the number of the computational graph's inputs
     pub fn num_inputs(&self) -> usize {
         self.inputs.len()
@@ -496,16 +491,6 @@ impl Model {
         Ok(om)
     }
 
-    /// Gets the input types from the parsed nodes
-    pub fn get_input_types(&self) -> Result<Vec<InputType>, GraphError> {
-        self.graph.get_input_types()
-    }
-
-    /// Gets the output types from the parsed nodes
-    pub fn get_output_types(&self) -> Vec<InputType> {
-        self.graph.get_output_types()
-    }
-
     ///
     pub fn save(&self, path: PathBuf) -> Result<(), GraphError> {
         let f = std::fs::File::create(&path).map_err(|e| {
@@ -589,11 +574,6 @@ impl Model {
             required_range_checks: res.range_checks.into_iter().collect(),
             model_output_scales: self.graph.get_output_scales()?,
             model_input_scales: self.graph.get_input_scales(),
-            input_types: match self.get_input_types() {
-                Ok(x) => Some(x),
-                Err(_) => None,
-            },
-            output_types: Some(self.get_output_types()),
             num_dynamic_lookups: res.num_dynamic_lookups,
             total_dynamic_col_size: res.dynamic_lookup_col_coord,
             num_shuffles: res.num_shuffles,
@@ -724,11 +704,6 @@ impl Model {
             nodes,
             inputs: model.inputs.iter().map(|o| o.node).collect(),
             outputs: model.outputs.iter().map(|o| (o.node, o.slot)).collect(),
-            output_types: model
-                .outputs
-                .iter()
-                .map(|o| Ok::<InputType, GraphError>(model.outlet_fact(*o)?.datum_type.into()))
-                .collect::<Result<Vec<_>, GraphError>>()?,
         };
 
         let duration = start_time.elapsed();
@@ -887,15 +862,6 @@ impl Model {
                         nodes: subgraph_nodes,
                         inputs: model.inputs.iter().map(|o| o.node).collect(),
                         outputs: model.outputs.iter().map(|o| (o.node, o.slot)).collect(),
-                        output_types: model
-                            .outputs
-                            .iter()
-                            .map(|o| {
-                                Ok::<InputType, GraphError>(
-                                    model.outlet_fact(*o)?.datum_type.into(),
-                                )
-                            })
-                            .collect::<Result<Vec<_>, GraphError>>()?,
                     };
 
                     let om = Model {
@@ -942,7 +908,6 @@ impl Model {
                             n.opkind = SupportedOp::Input(Input {
                                 scale,
                                 datum_type: inp.datum_type,
-                                decomp: !run_args.ignore_range_check_inputs_outputs,
                             });
                             input_idx += 1;
                             n.out_scale = scale;
@@ -1172,10 +1137,17 @@ impl Model {
                     })?;
 
                 if run_args.output_visibility.is_public() || run_args.output_visibility.is_fixed() {
+                    let output_scales = self.graph.get_output_scales().map_err(|e| {
+                        error!("{}", e);
+                        halo2_proofs::plonk::Error::Synthesis
+                    })?;
                     let res = outputs
                         .iter()
                         .enumerate()
                         .map(|(i, output)| {
+                            let mut tolerance = run_args.tolerance;
+                            tolerance.scale = scale_to_multiplier(output_scales[i]).into();
+
                             let comparators = if run_args.output_visibility == Visibility::Public {
                                 let res = vars
                                     .instance
@@ -1197,9 +1169,7 @@ impl Model {
                                 .layout(
                                     &mut thread_safe_region,
                                     &[output.clone(), comparators],
-                                    Box::new(HybridOp::Output {
-                                        decomp: !run_args.ignore_range_check_inputs_outputs,
-                                    }),
+                                    Box::new(HybridOp::RangeCheck(tolerance)),
                                 )
                                 .map_err(|e| e.into())
                         })
@@ -1459,9 +1429,11 @@ impl Model {
         let outputs = self.layout_nodes(&mut model_config, &mut region, &mut results)?;
 
         if self.visibility.output.is_public() || self.visibility.output.is_fixed() {
+            let output_scales = self.graph.get_output_scales()?;
             let res = outputs
                 .iter()
-                .map(|output| {
+                .enumerate()
+                .map(|(i, output)| {
                     let mut comparator: ValTensor<Fp> = (0..output.len())
                         .map(|_| {
                             if !self.visibility.output.is_fixed() {
@@ -1474,12 +1446,13 @@ impl Model {
                         .into();
                     comparator.reshape(output.dims())?;
 
+                    let mut tolerance = run_args.tolerance;
+                    tolerance.scale = scale_to_multiplier(output_scales[i]).into();
+
                     dummy_config.layout(
                         &mut region,
                         &[output.clone(), comparator],
-                        Box::new(HybridOp::Output {
-                            decomp: !run_args.ignore_range_check_inputs_outputs,
-                        }),
+                        Box::new(HybridOp::RangeCheck(tolerance)),
                     )
                 })
                 .collect::<Result<Vec<_>, _>>();
@@ -1571,7 +1544,6 @@ impl Model {
                         let mut op = crate::circuit::Constant::new(
                             c.quantized_values.clone(),
                             c.raw_values.clone(),
-                            c.decomp,
                         );
                         op.pre_assign(consts[const_idx].clone());
                         n.opkind = SupportedOp::Constant(op);
@@ -1599,16 +1571,4 @@ impl Model {
         }
         Ok(instance_shapes)
     }
-
-    /// Input types of the computational graph's public inputs (if any)
-    pub fn instance_types(&self) -> Result<Vec<InputType>, GraphError> {
-        let mut instance_types = vec![];
-        if self.visibility.input.is_public() {
-            instance_types.extend(self.graph.get_input_types()?);
-        }
-        if self.visibility.output.is_public() {
-            instance_types.extend(self.graph.get_output_types());
-        }
-        Ok(instance_types)
-    }
 }

src/graph/modules.rs

@@ -14,11 +14,14 @@ use serde::{Deserialize, Serialize};
 use super::errors::GraphError;
 use super::{VarVisibility, Visibility};
 
+/// poseidon len to hash in tree
+pub const POSEIDON_LEN_GRAPH: usize = 32;
 /// Poseidon number of instances
 pub const POSEIDON_INSTANCES: usize = 1;
 
 /// Poseidon module type
-pub type ModulePoseidon = PoseidonChip<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>;
+pub type ModulePoseidon =
+    PoseidonChip<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, POSEIDON_LEN_GRAPH>;
 /// Poseidon module config
 pub type ModulePoseidonConfig = PoseidonConfig<POSEIDON_WIDTH, POSEIDON_RATE>;
 

src/graph/node.rs

@@ -14,14 +14,14 @@ use super::VarScales;
 use super::Visibility;
 
 // Import operation types for different circuit components
+use crate::circuit::hybrid::HybridOp;
+use crate::circuit::lookup::LookupOp;
+use crate::circuit::poly::PolyOp;
 use crate::circuit::CircuitError;
 use crate::circuit::Constant;
 use crate::circuit::Input;
 use crate::circuit::Op;
 use crate::circuit::Unknown;
-use crate::circuit::hybrid::HybridOp;
-use crate::circuit::lookup::LookupOp;
-use crate::circuit::poly::PolyOp;
 
 // Import graph error types for EZKL
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
@@ -740,7 +740,7 @@ fn rescale_const_with_single_use(
         if scale_max > &current_scale {
             let raw_values = constant.raw_values.clone();
             constant.quantized_values =
-                super::quantize_tensor(raw_values, *scale_max, param_visibility, true)?;
+                super::quantize_tensor(raw_values, *scale_max, param_visibility)?;
         }
     }
 

src/graph/utilities.rs

@@ -1,14 +1,14 @@
+use super::errors::GraphError;
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use super::VarScales;
-use super::errors::GraphError;
 use super::{Rescaled, SupportedOp, Visibility};
-use crate::circuit::Op;
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::circuit::hybrid::HybridOp;
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::circuit::lookup::LookupOp;
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::circuit::poly::PolyOp;
+use crate::circuit::Op;
 use crate::fieldutils::IntegerRep;
 use crate::tensor::{Tensor, TensorError, TensorType};
 use halo2curves::bn256::Fr as Fp;
@@ -22,7 +22,6 @@ use std::sync::Arc;
 use tract_onnx::prelude::{DatumType, Node as OnnxNode, TypedFact, TypedOp};
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::tract_core::ops::{
-    Downsample,
     array::{
         Gather, GatherElements, GatherNd, MultiBroadcastTo, OneHot, ScatterElements, ScatterNd,
         Slice, Topk,
@@ -32,6 +31,7 @@ use tract_onnx::tract_core::ops::{
     einsum::EinSum,
     element_wise::ElementWiseOp,
     nn::{LeakyRelu, Reduce, Softmax},
+    Downsample,
 };
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::tract_hir::{
@@ -39,8 +39,9 @@ use tract_onnx::tract_hir::{
     ops::array::{Pad, PadMode, TypedConcat},
     ops::cnn::PoolSpec,
     ops::konst::Const,
+    ops::nn::DataFormat,
     tract_core::ops::cast::Cast,
-    tract_core::ops::cnn::{MaxPool, SumPool},
+    tract_core::ops::cnn::{conv::KernelFormat, MaxPool, SumPool},
 };
 
 /// Quantizes an iterable of f64 to a [Tensor] of IntegerRep using a fixed point representation.
@@ -68,33 +69,6 @@ pub fn quantize_float(
     Ok(scaled)
 }
 
-/// Quantizes an iterable of f64 to a [Tensor] of IntegerRep using a fixed point representation.
-/// NAN gets mapped to 0. And values that exceed the max are capped.
-/// Arguments
-///
-/// * `elem` - the element to quantize.
-/// * `shift` - offset used in the fixed point representation.
-/// * `scale` - `2^scale` used in the fixed point representation.
-pub fn quantize_float_and_cap(
-    elem: &f64,
-    shift: f64,
-    scale: crate::Scale,
-) -> Result<IntegerRep, TensorError> {
-    let mult = scale_to_multiplier(scale);
-    let max_value = ((IntegerRep::MAX as f64 - shift) / mult).round(); // the maximum value that can be represented w/o sig bit truncation
-
-    if *elem > max_value {
-        return Ok(IntegerRep::MAX);
-    } else if *elem < -max_value {
-        return Ok(IntegerRep::MIN);
-    }
-
-    // we parallelize the quantization process as it seems to be quite slow at times
-    let scaled = (mult * *elem + shift).round() as IntegerRep;
-
-    Ok(scaled)
-}
-
 /// Dequantizes a field element to a f64 using a fixed point representation.
 /// Arguments
 /// * `felt` - the field element to dequantize.
@@ -300,10 +274,12 @@ pub fn new_op_from_onnx(
     symbol_values: &SymbolValues,
     run_args: &crate::RunArgs,
 ) -> Result<(SupportedOp, Vec<usize>), GraphError> {
-    use crate::circuit::InputType;
     use std::f64::consts::E;
+
     use tract_onnx::tract_core::ops::array::Trilu;
 
+    use crate::circuit::InputType;
+
     let input_scales = inputs
         .iter()
         .flat_map(|x| x.out_scales())
@@ -406,13 +382,9 @@ pub fn new_op_from_onnx(
             let range = (start..end).step_by(delta).collect::<Vec<_>>();
             let raw_value = range.iter().map(|x| *x as f32).collect::<Tensor<_>>();
             // Quantize the raw value (integers)
-            let quantized_value = quantize_tensor(raw_value.clone(), 0, &Visibility::Fixed, false)?;
+            let quantized_value = quantize_tensor(raw_value.clone(), 0, &Visibility::Fixed)?;
 
-            let c = crate::circuit::ops::Constant::new(
-                quantized_value,
-                raw_value,
-                !run_args.ignore_range_check_inputs_outputs,
-            );
+            let c = crate::circuit::ops::Constant::new(quantized_value, raw_value);
             // Create a constant op
             SupportedOp::Constant(c)
         }
@@ -474,7 +446,6 @@ pub fn new_op_from_onnx(
                 inputs[1].replace_opkind(SupportedOp::Input(crate::circuit::ops::Input {
                     scale: 0,
                     datum_type: InputType::TDim,
-                    decomp: false,
                 }));
                 inputs[1].bump_scale(0);
             }
@@ -551,7 +522,6 @@ pub fn new_op_from_onnx(
                 inputs[1].replace_opkind(SupportedOp::Input(crate::circuit::ops::Input {
                     scale: 0,
                     datum_type: InputType::TDim,
-                    decomp: !run_args.ignore_range_check_inputs_outputs,
                 }));
                 inputs[1].bump_scale(0);
             }
@@ -588,7 +558,6 @@ pub fn new_op_from_onnx(
                 inputs[1].replace_opkind(SupportedOp::Input(crate::circuit::ops::Input {
                     scale: 0,
                     datum_type: InputType::TDim,
-                    decomp: !run_args.ignore_range_check_inputs_outputs,
                 }));
                 inputs[1].bump_scale(0);
             }
@@ -626,7 +595,6 @@ pub fn new_op_from_onnx(
                 inputs[1].replace_opkind(SupportedOp::Input(crate::circuit::ops::Input {
                     scale: 0,
                     datum_type: InputType::TDim,
-                    decomp: !run_args.ignore_range_check_inputs_outputs,
                 }));
                 inputs[1].bump_scale(0);
             }
@@ -664,7 +632,6 @@ pub fn new_op_from_onnx(
                 inputs[1].replace_opkind(SupportedOp::Input(crate::circuit::ops::Input {
                     scale: 0,
                     datum_type: InputType::TDim,
-                    decomp: !run_args.ignore_range_check_inputs_outputs,
                 }));
                 inputs[1].bump_scale(0);
             }
@@ -738,13 +705,8 @@ pub fn new_op_from_onnx(
                 raw_value.clone(),
                 constant_scale,
                 &run_args.param_visibility,
-                true,
             )?;
-            let c = crate::circuit::ops::Constant::new(
-                quantized_value,
-                raw_value,
-                run_args.ignore_range_check_inputs_outputs,
-            );
+            let c = crate::circuit::ops::Constant::new(quantized_value, raw_value);
             // Create a constant op
             SupportedOp::Constant(c)
         }
@@ -1007,11 +969,7 @@ pub fn new_op_from_onnx(
                 DatumType::F64 => (scales.input, InputType::F64),
                 _ => return Err(GraphError::UnsupportedDataType(idx, format!("{:?}", dt))),
             };
-            SupportedOp::Input(crate::circuit::ops::Input {
-                scale,
-                datum_type,
-                decomp: !run_args.ignore_range_check_inputs_outputs,
-            })
+            SupportedOp::Input(crate::circuit::ops::Input { scale, datum_type })
         }
         "Cast" => {
             let op = load_op::<Cast>(node.op(), idx, node.op().name().to_string())?;
@@ -1173,6 +1131,13 @@ pub fn new_op_from_onnx(
 
             let pool_spec: &PoolSpec = &sumpool_node.pool_spec;
 
+            // only support pytorch type formatting for now
+            if pool_spec.data_format != DataFormat::NCHW {
+                return Err(GraphError::MissingParams(
+                    "data in wrong format".to_string(),
+                ));
+            }
+
             let stride = extract_strides(pool_spec)?;
             let padding = extract_padding(pool_spec, &input_dims[0])?;
             let kernel_shape = &pool_spec.kernel_shape;
@@ -1181,7 +1146,6 @@ pub fn new_op_from_onnx(
                 padding,
                 stride: stride.to_vec(),
                 pool_dims: kernel_shape.to_vec(),
-                data_format: pool_spec.data_format.into(),
             })
         }
         "Ceil" => {
@@ -1293,19 +1257,9 @@ pub fn new_op_from_onnx(
                     // get the non constant index
                     let denom = c.raw_values[0];
 
-                    let op = SupportedOp::Hybrid(HybridOp::Div {
+                    SupportedOp::Hybrid(HybridOp::Div {
                         denom: denom.into(),
-                    });
-
-                    // if the input is scale 0 we re up to the max scale
-                    if input_scales[0] == 0 {
-                        SupportedOp::Rescaled(Rescaled {
-                            inner: Box::new(op),
-                            scale: vec![(0, scale_to_multiplier(scales.get_max()) as u128)],
-                        })
-                    } else {
-                        op
-                    }
+                    })
                 } else {
                     return Err(GraphError::MisformedParams(
                         "only support non zero divisors of size 1".to_string(),
@@ -1335,6 +1289,15 @@ pub fn new_op_from_onnx(
                 }
             }
 
+            if ((conv_node.pool_spec.data_format != DataFormat::NCHW)
+                && (conv_node.pool_spec.data_format != DataFormat::CHW))
+                || (conv_node.kernel_fmt != KernelFormat::OIHW)
+            {
+                return Err(GraphError::MisformedParams(
+                    "data or kernel in wrong format".to_string(),
+                ));
+            }
+
             let pool_spec = &conv_node.pool_spec;
 
             let stride = extract_strides(pool_spec)?;
@@ -1362,8 +1325,6 @@ pub fn new_op_from_onnx(
                 padding,
                 stride,
                 group,
-                data_format: conv_node.pool_spec.data_format.into(),
-                kernel_format: conv_node.kernel_fmt.into(),
             })
         }
         "Not" => SupportedOp::Linear(PolyOp::Not),
@@ -1387,6 +1348,14 @@ pub fn new_op_from_onnx(
                 }
             }
 
+            if (deconv_node.pool_spec.data_format != DataFormat::NCHW)
+                || (deconv_node.kernel_format != KernelFormat::OIHW)
+            {
+                return Err(GraphError::MisformedParams(
+                    "data or kernel in wrong format".to_string(),
+                ));
+            }
+
             let pool_spec = &deconv_node.pool_spec;
 
             let stride = extract_strides(pool_spec)?;
@@ -1412,8 +1381,6 @@ pub fn new_op_from_onnx(
                 output_padding: deconv_node.adjustments.to_vec(),
                 stride,
                 group: deconv_node.group,
-                data_format: deconv_node.pool_spec.data_format.into(),
-                kernel_format: deconv_node.kernel_format.into(),
             })
         }
         "Downsample" => {
@@ -1497,6 +1464,13 @@ pub fn new_op_from_onnx(
 
             let pool_spec: &PoolSpec = &sumpool_node.pool_spec;
 
+            // only support pytorch type formatting for now
+            if pool_spec.data_format != DataFormat::NCHW {
+                return Err(GraphError::MissingParams(
+                    "data in wrong format".to_string(),
+                ));
+            }
+
             let stride = extract_strides(pool_spec)?;
             let padding = extract_padding(pool_spec, &input_dims[0])?;
 
@@ -1505,7 +1479,6 @@ pub fn new_op_from_onnx(
                 stride: stride.to_vec(),
                 kernel_shape: pool_spec.kernel_shape.to_vec(),
                 normalized: sumpool_node.normalize,
-                data_format: pool_spec.data_format.into(),
             })
         }
         "Pad" => {
@@ -1578,20 +1551,13 @@ pub fn quantize_tensor<F: PrimeField + TensorType + PartialOrd>(
     const_value: Tensor<f32>,
     scale: crate::Scale,
     visibility: &Visibility,
-    cap: bool,
 ) -> Result<Tensor<F>, TensorError> {
     let mut value: Tensor<F> = const_value.par_enum_map(|_, x| {
-        if cap {
-            Ok::<F, TensorError>(crate::fieldutils::integer_rep_to_felt::<F>(
-                quantize_float_and_cap(&(x).into(), 0.0, scale)?,
-            ))
-        } else {
-            Ok(crate::fieldutils::integer_rep_to_felt::<F>(quantize_float(
-                &(x).into(),
-                0.0,
-                scale,
-            )?))
-        }
+        Ok::<_, TensorError>(crate::fieldutils::integer_rep_to_felt::<F>(quantize_float(
+            &(x).into(),
+            0.0,
+            scale,
+        )?))
     })?;
 
     value.set_scale(scale);
@@ -1679,7 +1645,7 @@ pub mod tests {
         let reference: Tensor<Fp> = (0..10).map(|x| x.into()).into();
         let scale = 0;
         let visibility = &Visibility::Public;
-        let quantized: Tensor<Fp> = quantize_tensor(tensor, scale, visibility, false).unwrap();
+        let quantized: Tensor<Fp> = quantize_tensor(tensor, scale, visibility).unwrap();
         assert_eq!(quantized.len(), 10);
         assert_eq!(quantized, reference);
     }

src/lib.rs

@@ -97,9 +97,10 @@ impl From<String> for EZKLError {
 
 use std::str::FromStr;
 
-use circuit::{table::Range, CheckMode};
+use circuit::{table::Range, CheckMode, Tolerance};
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use clap::Args;
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use fieldutils::IntegerRep;
 use graph::{Visibility, MAX_PUBLIC_SRS};
 use halo2_proofs::poly::{
@@ -274,6 +275,10 @@ impl From<String> for Commitments {
     derive(Args, ToFlags)
 )]
 pub struct RunArgs {
+    /// Error tolerance for model outputs
+    /// Only applicable when outputs are public
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(short = 'T', long, default_value = "0", value_hint = clap::ValueHint::Other))]
+    pub tolerance: Tolerance,
     /// Fixed point scaling factor for quantizing inputs
     /// Higher values provide more precision but increase circuit complexity
     #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(short = 'S', long, default_value = "7", value_hint = clap::ValueHint::Other))]
@@ -344,12 +349,6 @@ pub struct RunArgs {
         arg(long, default_value = "false")
     )]
     pub bounded_log_lookup: bool,
-    /// Range check inputs and outputs (turn off if the inputs are felts)
-    #[cfg_attr(
-        all(feature = "ezkl", not(target_arch = "wasm32")),
-        arg(long, default_value = "false")
-    )]
-    pub ignore_range_check_inputs_outputs: bool,
 }
 
 impl Default for RunArgs {
@@ -360,6 +359,7 @@ impl Default for RunArgs {
     fn default() -> Self {
         Self {
             bounded_log_lookup: false,
+            tolerance: Tolerance::default(),
             input_scale: 7,
             param_scale: 7,
             scale_rebase_multiplier: 1,
@@ -375,7 +375,6 @@ impl Default for RunArgs {
             commitment: None,
             decomp_base: 16384,
             decomp_legs: 2,
-            ignore_range_check_inputs_outputs: false,
         }
     }
 }
@@ -393,16 +392,6 @@ impl RunArgs {
     pub fn validate(&self) -> Result<(), String> {
         let mut errors = Vec::new();
 
-        // check if the largest represented integer in the decomposed form overflows IntegerRep
-        //  try it with the largest possible value
-        let max_decomp = (self.decomp_base as IntegerRep).checked_pow(self.decomp_legs as u32);
-        if max_decomp.is_none() {
-            errors.push(format!(
-                "decomp_base^decomp_legs overflows IntegerRep: {}^{}",
-                self.decomp_base, self.decomp_legs
-            ));
-        }
-
         // Visibility validations
         if self.param_visibility == Visibility::Public {
             errors.push(
@@ -411,6 +400,10 @@ impl RunArgs {
             );
         }
 
+        if self.tolerance.val > 0.0 && self.output_visibility != Visibility::Public {
+            errors.push("Non-zero tolerance requires output_visibility to be public".to_string());
+        }
+
         // Scale validations
         if self.scale_rebase_multiplier < 1 {
             errors.push("scale_rebase_multiplier must be >= 1".to_string());
@@ -459,6 +452,11 @@ impl RunArgs {
             warn!("logrows exceeds maximum public SRS size");
         }
 
+        // Validate tolerance is non-negative
+        if self.tolerance.val < 0.0 {
+            errors.push("tolerance cannot be negative".to_string());
+        }
+
         // Performance warnings
         if self.input_scale > 20 || self.param_scale > 20 {
             warn!("High scale values (>20) may impact performance");
@@ -605,6 +603,23 @@ mod tests {
         assert!(err.contains("num_inner_cols must be >= 1"));
     }
 
+    #[test]
+    fn test_invalid_tolerance() {
+        let mut args = RunArgs::default();
+        args.tolerance.val = 1.0;
+        args.output_visibility = Visibility::Private;
+        let err = args.validate().unwrap_err();
+        assert!(err.contains("Non-zero tolerance requires output_visibility to be public"));
+    }
+
+    #[test]
+    fn test_negative_tolerance() {
+        let mut args = RunArgs::default();
+        args.tolerance.val = -1.0;
+        let err = args.validate().unwrap_err();
+        assert!(err.contains("tolerance cannot be negative"));
+    }
+
     #[test]
     fn test_zero_batch_size() {
         let mut args = RunArgs::default();

src/tensor/errors.rs

@@ -1,6 +1,6 @@
 use thiserror::Error;
 
-use super::{ops::DecompositionError, DataFormat};
+use super::ops::DecompositionError;
 
 /// A wrapper for tensor related errors.
 #[derive(Debug, Error)]
@@ -44,7 +44,4 @@ pub enum TensorError {
     /// Index out of bounds
     #[error("index {0} out of bounds for dimension {1}")]
     IndexOutOfBounds(usize, usize),
-    /// Invalid data conversion
-    #[error("invalid data conversion from format {0} to {1}")]
-    InvalidDataConversion(DataFormat, DataFormat),
 }

src/tensor/mod.rs

@@ -9,7 +9,6 @@ pub mod var;
 
 pub use errors::TensorError;
 
-use core::hash::Hash;
 use halo2curves::ff::PrimeField;
 use maybe_rayon::{
     prelude::{
@@ -27,7 +26,7 @@ pub use var::*;
 
 use crate::{
     circuit::utils,
-    fieldutils::{IntegerRep, integer_rep_to_felt},
+    fieldutils::{integer_rep_to_felt, IntegerRep},
     graph::Visibility,
 };
 
@@ -62,7 +61,7 @@ pub trait TensorType: Clone + Debug + 'static {
 }
 
 macro_rules! tensor_type {
-    ($rust_type:ty, $tensor_type:ident, $zero:expr_2021, $one:expr_2021) => {
+    ($rust_type:ty, $tensor_type:ident, $zero:expr, $one:expr) => {
         impl TensorType for $rust_type {
             fn zero() -> Option<Self> {
                 Some($zero)
@@ -415,7 +414,7 @@ impl<T: Clone + TensorType + PrimeField> Tensor<T> {
                 Err(_) => {
                     return Err(TensorError::FileLoadError(
                         "Failed to read tensor".to_string(),
-                    ));
+                    ))
                 }
             }
         }
@@ -1254,7 +1253,7 @@ impl<T: Clone + TensorType> Tensor<T> {
             None => {
                 return Err(TensorError::DimError(
                     "Cannot get last element of empty tensor".to_string(),
-                ));
+                ))
             }
         };
 
@@ -1279,7 +1278,7 @@ impl<T: Clone + TensorType> Tensor<T> {
             None => {
                 return Err(TensorError::DimError(
                     "Cannot get first element of empty tensor".to_string(),
-                ));
+                ))
             }
         };
 
@@ -1692,8 +1691,8 @@ impl<T: TensorType + Rem<Output = T> + std::marker::Send + std::marker::Sync + P
 
         lhs.par_iter_mut()
             .zip(rhs)
-            .map(|(o, r)| match T::zero() {
-                Some(zero) => {
+            .map(|(o, r)| {
+                if let Some(zero) = T::zero() {
                     if r != zero {
                         *o = o.clone() % r;
                         Ok(())
@@ -1702,10 +1701,11 @@ impl<T: TensorType + Rem<Output = T> + std::marker::Send + std::marker::Sync + P
                             "Cannot divide by zero in remainder".to_string(),
                         ))
                     }
+                } else {
+                    Err(TensorError::InvalidArgument(
+                        "Undefined zero value".to_string(),
+                    ))
                 }
-                _ => Err(TensorError::InvalidArgument(
-                    "Undefined zero value".to_string(),
-                )),
             })
             .collect::<Result<Vec<_>, _>>()?;
 
@@ -1768,228 +1768,6 @@ pub fn get_broadcasted_shape(
 }
 ////////////////////////
 
-/// The shape of data for some operations
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Default, Copy)]
-pub enum DataFormat {
-    /// NCHW
-    #[default]
-    NCHW,
-    /// NHWC
-    NHWC,
-    /// CHW
-    CHW,
-    /// HWC
-    HWC,
-}
-
-// as str
-impl core::fmt::Display for DataFormat {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            DataFormat::NCHW => write!(f, "NCHW"),
-            DataFormat::NHWC => write!(f, "NHWC"),
-            DataFormat::CHW => write!(f, "CHW"),
-            DataFormat::HWC => write!(f, "HWC"),
-        }
-    }
-}
-
-impl DataFormat {
-    /// Get the format's canonical form
-    pub fn canonical(&self) -> DataFormat {
-        match self {
-            DataFormat::NHWC => DataFormat::NCHW,
-            DataFormat::HWC => DataFormat::CHW,
-            _ => self.clone(),
-        }
-    }
-
-    /// no batch dim
-    pub fn has_no_batch(&self) -> bool {
-        match self {
-            DataFormat::CHW | DataFormat::HWC => true,
-            _ => false,
-        }
-    }
-
-    /// Convert tensor to canonical format (NCHW or CHW)
-    pub fn to_canonical<F: PrimeField + TensorType + PartialOrd + Hash>(
-        &self,
-        tensor: &mut ValTensor<F>,
-    ) -> Result<(), TensorError> {
-        match self {
-            DataFormat::NHWC => {
-                // For ND: Move channels from last axis to position after batch
-                let ndims = tensor.dims().len();
-                if ndims > 2 {
-                    tensor.move_axis(ndims - 1, 1)?;
-                }
-            }
-            DataFormat::HWC => {
-                // For ND: Move channels from last axis to first position
-                let ndims = tensor.dims().len();
-                if ndims > 1 {
-                    tensor.move_axis(ndims - 1, 0)?;
-                }
-            }
-            _ => {} // NCHW/CHW are already in canonical format
-        }
-        Ok(())
-    }
-
-    /// Convert tensor from canonical format to target format
-    pub fn from_canonical<F: PrimeField + TensorType + PartialOrd + Hash>(
-        &self,
-        tensor: &mut ValTensor<F>,
-    ) -> Result<(), TensorError> {
-        match self {
-            DataFormat::NHWC => {
-                // Move channels from position 1 to end
-                let ndims = tensor.dims().len();
-                if ndims > 2 {
-                    tensor.move_axis(1, ndims - 1)?;
-                }
-            }
-            DataFormat::HWC => {
-                // Move channels from position 0 to end
-                let ndims = tensor.dims().len();
-                if ndims > 1 {
-                    tensor.move_axis(0, ndims - 1)?;
-                }
-            }
-            _ => {} // NCHW/CHW don't need conversion
-        }
-        Ok(())
-    }
-
-    /// Get the position of the channel dimension
-    pub fn get_channel_dim(&self, ndims: usize) -> usize {
-        match self {
-            DataFormat::NCHW => 1,
-            DataFormat::NHWC => ndims - 1,
-            DataFormat::CHW => 0,
-            DataFormat::HWC => ndims - 1,
-        }
-    }
-}
-/// The shape of the kernel for some operations
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Default, Copy)]
-pub enum KernelFormat {
-    /// HWIO
-    HWIO,
-    /// OIHW
-    #[default]
-    OIHW,
-    /// OHWI
-    OHWI,
-}
-
-impl core::fmt::Display for KernelFormat {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            KernelFormat::HWIO => write!(f, "HWIO"),
-            KernelFormat::OIHW => write!(f, "OIHW"),
-            KernelFormat::OHWI => write!(f, "OHWI"),
-        }
-    }
-}
-
-impl KernelFormat {
-    /// Get the format's canonical form
-    pub fn canonical(&self) -> KernelFormat {
-        match self {
-            KernelFormat::HWIO => KernelFormat::OIHW,
-            KernelFormat::OHWI => KernelFormat::OIHW,
-            _ => self.clone(),
-        }
-    }
-
-    /// Convert kernel to canonical format (OIHW)
-    pub fn to_canonical<F: PrimeField + TensorType + PartialOrd + Hash>(
-        &self,
-        kernel: &mut ValTensor<F>,
-    ) -> Result<(), TensorError> {
-        match self {
-            KernelFormat::HWIO => {
-                let kdims = kernel.dims().len();
-                // Move output channels from last to first
-                kernel.move_axis(kdims - 1, 0)?;
-                // Move input channels from new last to second position
-                kernel.move_axis(kdims - 1, 1)?;
-            }
-            KernelFormat::OHWI => {
-                let kdims = kernel.dims().len();
-                // Move input channels from last to second position
-                kernel.move_axis(kdims - 1, 1)?;
-            }
-            _ => {} // OIHW is already canonical
-        }
-        Ok(())
-    }
-
-    /// Convert kernel from canonical format to target format
-    pub fn from_canonical<F: PrimeField + TensorType + PartialOrd + Hash>(
-        &self,
-        kernel: &mut ValTensor<F>,
-    ) -> Result<(), TensorError> {
-        match self {
-            KernelFormat::HWIO => {
-                let kdims = kernel.dims().len();
-                // Move input channels from second position to last
-                kernel.move_axis(1, kdims - 1)?;
-                // Move output channels from first to last
-                kernel.move_axis(0, kdims - 1)?;
-            }
-            KernelFormat::OHWI => {
-                let kdims = kernel.dims().len();
-                // Move input channels from second position to last
-                kernel.move_axis(1, kdims - 1)?;
-            }
-            _ => {} // OIHW doesn't need conversion
-        }
-        Ok(())
-    }
-
-    /// Get the position of input and output channel dimensions
-    pub fn get_channel_dims(&self, ndims: usize) -> (usize, usize) {
-        // (input_ch, output_ch)
-        match self {
-            KernelFormat::OIHW => (1, 0),
-            KernelFormat::HWIO => (ndims - 2, ndims - 1),
-            KernelFormat::OHWI => (ndims - 1, 0),
-        }
-    }
-}
-
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-impl From<tract_onnx::tract_hir::ops::nn::DataFormat> for DataFormat {
-    fn from(fmt: tract_onnx::tract_hir::ops::nn::DataFormat) -> Self {
-        match fmt {
-            tract_onnx::tract_hir::ops::nn::DataFormat::NCHW => DataFormat::NCHW,
-            tract_onnx::tract_hir::ops::nn::DataFormat::NHWC => DataFormat::NHWC,
-            tract_onnx::tract_hir::ops::nn::DataFormat::CHW => DataFormat::CHW,
-            tract_onnx::tract_hir::ops::nn::DataFormat::HWC => DataFormat::HWC,
-        }
-    }
-}
-
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-impl From<tract_onnx::tract_hir::tract_core::ops::cnn::conv::KernelFormat> for KernelFormat {
-    fn from(fmt: tract_onnx::tract_hir::tract_core::ops::cnn::conv::KernelFormat) -> Self {
-        match fmt {
-            tract_onnx::tract_hir::tract_core::ops::cnn::conv::KernelFormat::HWIO => {
-                KernelFormat::HWIO
-            }
-            tract_onnx::tract_hir::tract_core::ops::cnn::conv::KernelFormat::OIHW => {
-                KernelFormat::OIHW
-            }
-            tract_onnx::tract_hir::tract_core::ops::cnn::conv::KernelFormat::OHWI => {
-                KernelFormat::OHWI
-            }
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/tensor/ops.rs

@@ -387,7 +387,7 @@ pub fn add<T: TensorType + Add<Output = T> + std::marker::Send + std::marker::Sy
 ) -> Result<Tensor<T>, TensorError> {
     if t.len() == 1 {
         return Ok(t[0].clone());
-    } else if t.is_empty() {
+    } else if t.len() == 0 {
         return Err(TensorError::DimMismatch("add".to_string()));
     }
 
@@ -441,7 +441,7 @@ pub fn sub<T: TensorType + Sub<Output = T> + std::marker::Send + std::marker::Sy
 ) -> Result<Tensor<T>, TensorError> {
     if t.len() == 1 {
         return Ok(t[0].clone());
-    } else if t.is_empty() {
+    } else if t.len() == 0 {
         return Err(TensorError::DimMismatch("sub".to_string()));
     }
     // calculate value of output
@@ -492,7 +492,7 @@ pub fn mult<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::S
 ) -> Result<Tensor<T>, TensorError> {
     if t.len() == 1 {
         return Ok(t[0].clone());
-    } else if t.is_empty() {
+    } else if t.len() == 0 {
         return Err(TensorError::DimMismatch("mult".to_string()));
     }
     // calculate value of output
@@ -1326,6 +1326,7 @@ pub fn pad<T: TensorType>(
 ///
 /// # Errors
 /// Returns a TensorError if the tensors in `inputs` have incompatible dimensions for concatenation along the specified `axis`.
+
 pub fn concat<T: TensorType + Send + Sync>(
     inputs: &[&Tensor<T>],
     axis: usize,
@@ -2101,6 +2102,7 @@ pub mod nonlinearities {
     /// let expected = Tensor::<IntegerRep>::new(Some(&[4, 25, 8, 1, 1, 0]), &[2, 3]).unwrap();
     /// assert_eq!(result, expected);
     /// ```
+
     pub fn tanh(a: &Tensor<IntegerRep>, scale_input: f64) -> Tensor<IntegerRep> {
         a.par_enum_map(|_, a_i| {
             let kix = (a_i as f64) / scale_input;

tests/assets/settings.json

@@ -28,12 +28,11 @@
         "commitment": "KZG",
         "decomp_base": 128,
         "decomp_legs": 2,
-        "bounded_log_lookup": false,
-        "ignore_range_check_inputs_outputs": false
+        "bounded_log_lookup": false
     },
-    "num_rows": 236,
-    "total_assignments": 472,
-    "total_const_size": 4,
+    "num_rows": 46,
+    "total_assignments": 92,
+    "total_const_size": 3,
     "total_dynamic_col_size": 0,
     "max_dynamic_input_len": 0,
     "num_dynamic_lookups": 0,

tests/integration_tests.rs

@@ -1,7 +1,9 @@
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 #[cfg(test)]
 mod native_tests {
-    
+
+    use ezkl::circuit::Tolerance;
+    use ezkl::fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep};
     // use ezkl::circuit::table::RESERVED_BLINDING_ROWS_PAD;
     use ezkl::graph::input::{FileSource, FileSourceInner, GraphData};
     use ezkl::graph::{DataSource, GraphSettings, GraphWitness};
@@ -21,8 +23,6 @@ mod native_tests {
     static COMPILE_WASM: Once = Once::new();
     static ENV_SETUP: Once = Once::new();
 
-    const TEST_BINARY: &str = "test-runs/ezkl";
-
     //Sure to run this once
     #[derive(Debug)]
     #[allow(dead_code)]
@@ -103,7 +103,7 @@ mod native_tests {
 
     fn download_srs(logrows: u32, commitment: Commitments) {
         // if does not exist, download it
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "get-srs",
                 "--logrows",
@@ -186,7 +186,7 @@ mod native_tests {
 
     const PF_FAILURE_AGGR: &str = "examples/test_failure_aggr_proof.json";
 
-    const LARGE_TESTS: [&str; 8] = [
+    const LARGE_TESTS: [&str; 7] = [
         "self_attention",
         "nanoGPT",
         "multihead_attention",
@@ -194,7 +194,6 @@ mod native_tests {
         "mnist_gan",
         "smallworm",
         "fr_age",
-        "1d_conv",
     ];
 
     const ACCURACY_CAL_TESTS: [&str; 6] = [
@@ -206,62 +205,62 @@ mod native_tests {
         "1l_tiny_div",
     ];
 
-    const TESTS: [&str; 99] = [
-        "1l_mlp",     //0
-        "1l_slice",   //1
-        "1l_concat",  //2
-        "1l_flatten", //3
+    const TESTS: [&str; 98] = [
+        "1l_mlp", //0
+        "1l_slice",
+        "1l_concat",
+        "1l_flatten",
         // "1l_average",
-        "1l_div",         //4
-        "1l_pad",         // 5
-        "1l_reshape",     //6
-        "1l_eltwise_div", //7
-        "1l_sigmoid",     //8
-        "1l_sqrt",        //9
-        "1l_softmax",     //10
+        "1l_div",
+        "1l_pad", // 5
+        "1l_reshape",
+        "1l_eltwise_div",
+        "1l_sigmoid",
+        "1l_sqrt",
+        "1l_softmax", //10
         // "1l_instance_norm",
-        "1l_batch_norm",  //11
-        "1l_prelu",       //12
-        "1l_leakyrelu",   //13
-        "1l_gelu_noappx", //14
+        "1l_batch_norm",
+        "1l_prelu",
+        "1l_leakyrelu",
+        "1l_gelu_noappx",
         // "1l_gelu_tanh_appx",
-        "1l_relu",                   //15
-        "1l_downsample",             //16
-        "1l_tanh",                   //17
-        "2l_relu_sigmoid_small",     //18
-        "2l_relu_fc",                //19
-        "2l_relu_small",             //20
-        "2l_relu_sigmoid",           //21
-        "1l_conv",                   //22
-        "2l_sigmoid_small",          //23
-        "2l_relu_sigmoid_conv",      //24
-        "3l_relu_conv_fc",           //25
-        "4l_relu_conv_fc",           //26
-        "1l_erf",                    //27
-        "1l_var",                    //28
-        "1l_elu",                    //29
-        "min",                       //30
-        "max",                       //31
-        "1l_max_pool",               //32
-        "1l_conv_transpose",         //33
-        "1l_upsample",               //34
-        "1l_identity",               //35
-        "idolmodel",                 // too big evm
-        "trig",                      // too big evm
-        "prelu_gmm",                 //38
-        "lstm",                      //39
-        "rnn",                       //40
-        "quantize_dequantize",       //41
-        "1l_where",                  //42
-        "boolean",                   //43
-        "boolean_identity",          //44
-        "decision_tree",             // 45
-        "random_forest",             //46
-        "gradient_boosted_trees",    //47
-        "1l_topk",                   //48
-        "xgboost",                   //49
-        "lightgbm",                  //50
-        "hummingbird_decision_tree", //51
+        "1l_relu", //15
+        "1l_downsample",
+        "1l_tanh",
+        "2l_relu_sigmoid_small",
+        "2l_relu_fc",
+        "2l_relu_small", //20
+        "2l_relu_sigmoid",
+        "1l_conv",
+        "2l_sigmoid_small",
+        "2l_relu_sigmoid_conv",
+        "3l_relu_conv_fc", //25
+        "4l_relu_conv_fc",
+        "1l_erf",
+        "1l_var",
+        "1l_elu",
+        "min", //30
+        "max",
+        "1l_max_pool",
+        "1l_conv_transpose",
+        "1l_upsample",
+        "1l_identity", //35
+        "idolmodel",   // too big evm
+        "trig",        // too big evm
+        "prelu_gmm",
+        "lstm",
+        "rnn", //40
+        "quantize_dequantize",
+        "1l_where",
+        "boolean",
+        "boolean_identity",
+        "decision_tree", // 45
+        "random_forest",
+        "gradient_boosted_trees",
+        "1l_topk",
+        "xgboost",
+        "lightgbm", //50
+        "hummingbird_decision_tree",
         "oh_decision_tree",
         "linear_svc",
         "gather_elements",
@@ -309,7 +308,6 @@ mod native_tests {
         "log",         // 95
         "exp",         // 96
         "general_exp", // 97
-        "integer_div", // 98
     ];
 
     const WASM_TESTS: [&str; 46] = [
@@ -522,7 +520,7 @@ mod native_tests {
             use crate::native_tests::run_js_tests;
             use crate::native_tests::render_circuit;
             use crate::native_tests::model_serialization_different_binaries;
-            
+            use rand::Rng;
             use tempdir::TempDir;
             use ezkl::Commitments;
 
@@ -543,12 +541,12 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "fixed", "public", 1, "accuracy", None, false, None, None);
+                mock(path, test.to_string(), "public", "fixed", "public", 1, "accuracy", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
         });
 
-            seq!(N in 0..=98 {
+            seq!(N in 0..=97 {
 
             #(#[test_case(TESTS[N])])*
             #[ignore]
@@ -608,7 +606,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -618,10 +616,22 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None, true, Some(8194), Some(4));
+                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None, 0.0, true, Some(8194), Some(4));
                 test_dir.close().unwrap();
             }
 
+            #(#[test_case(TESTS[N])])*
+            fn mock_tolerance_public_outputs_(test: &str) {
+                crate::native_tests::init_binary();
+                let test_dir = TempDir::new(test).unwrap();
+                let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
+                // gen random number between 0.0 and 1.0
+                let tolerance = rand::thread_rng().gen_range(0.0..1.0) * 100.0;
+                mock(path, test.to_string(), "private", "private", "public", 1, "resources", None, tolerance, false, Some(8194), Some(5));
+                test_dir.close().unwrap();
+            }
+
+
 
             #(#[test_case(TESTS[N])])*
             fn mock_large_batch_public_outputs_(test: &str) {
@@ -632,7 +642,7 @@ mod native_tests {
                     let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                     let large_batch_dir = &format!("large_batches_{}", test);
                     crate::native_tests::mk_data_batches_(path, test, &large_batch_dir, 10);
-                    mock(path, large_batch_dir.to_string(), "private", "private", "public", 10, "resources", None, false, None, None);
+                    mock(path, large_batch_dir.to_string(), "private", "private", "public", 10, "resources", None, 0.0, false, None, None);
                     test_dir.close().unwrap();
                 }
             }
@@ -642,7 +652,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "private", "private", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "public", "private", "private", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -651,7 +661,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "hashed", "private", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "public", "hashed", "private", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -660,7 +670,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "fixed", "private", "private", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "fixed", "private", "private", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -669,7 +679,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "private", "fixed", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "private", "private", "fixed", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -678,7 +688,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "fixed", "private", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "private", "fixed", "private", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -687,7 +697,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "hashed", "private", "public", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "hashed", "private", "public", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -696,7 +706,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "polycommit", "private", "public", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "polycommit", "private", "public", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -706,7 +716,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "hashed", "public", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "private", "hashed", "public", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -716,7 +726,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "polycommit", "public", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "private", "polycommit", "public", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -725,7 +735,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "private", "hashed", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "public", "private", "hashed", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -735,7 +745,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "private", "polycommit", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "public", "private", "polycommit", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -744,7 +754,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "fixed", "hashed", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "public", "fixed", "hashed", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -754,7 +764,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "public", "polycommit", "hashed", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "public", "polycommit", "hashed", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -764,7 +774,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "polycommit", "polycommit", "polycommit", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "polycommit", "polycommit", "polycommit", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -774,7 +784,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "hashed", "private", "hashed", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(), "hashed", "private", "hashed", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -784,7 +794,7 @@ mod native_tests {
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                 // needs an extra row for the large model
-                mock(path, test.to_string(),"hashed", "hashed", "public", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(),"hashed", "hashed", "public", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -794,7 +804,7 @@ mod native_tests {
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
                 // needs an extra row for the large model
-                mock(path, test.to_string(),"hashed", "hashed", "hashed", 1, "resources", None, false, None, None);
+                mock(path, test.to_string(),"hashed", "hashed", "hashed", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
 
@@ -953,7 +963,7 @@ mod native_tests {
 
             });
 
-            seq!(N in 0..=7 {
+            seq!(N in 0..=6 {
 
             #(#[test_case(LARGE_TESTS[N])])*
             #[ignore]
@@ -971,7 +981,7 @@ mod native_tests {
                 crate::native_tests::init_binary();
                 let test_dir = TempDir::new(test).unwrap();
                 let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                mock(path, test.to_string(), "private", "fixed", "public", 1, "resources", None, false, None, Some(5));
+                mock(path, test.to_string(), "private", "fixed", "public", 1, "resources", None, 0.0, false, None, None);
                 test_dir.close().unwrap();
             }
         });
@@ -1447,10 +1457,12 @@ mod native_tests {
         batch_size: usize,
         cal_target: &str,
         scales_to_use: Option<Vec<u32>>,
+        tolerance: f32,
         bounded_lookup_log: bool,
         decomp_base: Option<usize>,
         decomp_legs: Option<usize>,
     ) {
+        let mut tolerance = tolerance;
         gen_circuit_settings_and_witness(
             test_dir,
             example_name.clone(),
@@ -1461,6 +1473,7 @@ mod native_tests {
             cal_target,
             scales_to_use,
             2,
+            &mut tolerance,
             Commitments::KZG,
             2,
             bounded_lookup_log,
@@ -1468,17 +1481,128 @@ mod native_tests {
             decomp_legs,
         );
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-            .args([
-                "mock",
-                "-W",
-                format!("{}/{}/witness.json", test_dir, example_name).as_str(),
-                "-M",
-                format!("{}/{}/network.compiled", test_dir, example_name).as_str(),
-            ])
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
+        if tolerance > 0.0 {
+            // load witness and shift the output by a small amount that is less than tolerance percent
+            let witness = GraphWitness::from_path(
+                format!("{}/{}/witness.json", test_dir, example_name).into(),
+            )
+            .unwrap();
+            let witness = witness.clone();
+            let outputs = witness.outputs.clone();
+
+            // get values as i64
+            let output_perturbed_safe: Vec<Vec<halo2curves::bn256::Fr>> = outputs
+                .iter()
+                .map(|sv| {
+                    sv.iter()
+                        .map(|v| {
+                            // randomly perturb by a small amount less than tolerance
+                            let perturbation = if v == &halo2curves::bn256::Fr::zero() {
+                                halo2curves::bn256::Fr::zero()
+                            } else {
+                                integer_rep_to_felt(
+                                    (felt_to_integer_rep(*v) as f32
+                                        * (rand::thread_rng().gen_range(-0.01..0.01) * tolerance))
+                                        as IntegerRep,
+                                )
+                            };
+
+                            *v + perturbation
+                        })
+                        .collect::<Vec<_>>()
+                })
+                .collect::<Vec<_>>();
+
+            // get values as i64
+            let output_perturbed_bad: Vec<Vec<halo2curves::bn256::Fr>> = outputs
+                .iter()
+                .map(|sv| {
+                    sv.iter()
+                        .map(|v| {
+                            // randomly perturb by a small amount less than tolerance
+                            let perturbation = if v == &halo2curves::bn256::Fr::zero() {
+                                halo2curves::bn256::Fr::from(2)
+                            } else {
+                                integer_rep_to_felt(
+                                    (felt_to_integer_rep(*v) as f32
+                                        * (rand::thread_rng().gen_range(0.02..0.1) * tolerance))
+                                        as IntegerRep,
+                                )
+                            };
+                            *v + perturbation
+                        })
+                        .collect::<Vec<_>>()
+                })
+                .collect::<Vec<_>>();
+
+            let good_witness = GraphWitness {
+                outputs: output_perturbed_safe,
+                ..witness.clone()
+            };
+
+            // save
+            good_witness
+                .save(format!("{}/{}/witness_ok.json", test_dir, example_name).into())
+                .unwrap();
+
+            let bad_witness = GraphWitness {
+                outputs: output_perturbed_bad,
+                ..witness.clone()
+            };
+
+            // save
+            bad_witness
+                .save(format!("{}/{}/witness_bad.json", test_dir, example_name).into())
+                .unwrap();
+
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                .args([
+                    "mock",
+                    "-W",
+                    format!("{}/{}/witness.json", test_dir, example_name).as_str(),
+                    "-M",
+                    format!("{}/{}/network.compiled", test_dir, example_name).as_str(),
+                ])
+                .status()
+                .expect("failed to execute process");
+            assert!(status.success());
+
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                .args([
+                    "mock",
+                    "-W",
+                    format!("{}/{}/witness_ok.json", test_dir, example_name).as_str(),
+                    "-M",
+                    format!("{}/{}/network.compiled", test_dir, example_name).as_str(),
+                ])
+                .status()
+                .expect("failed to execute process");
+            assert!(status.success());
+
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                .args([
+                    "mock",
+                    "-W",
+                    format!("{}/{}/witness_bad.json", test_dir, example_name).as_str(),
+                    "-M",
+                    format!("{}/{}/network.compiled", test_dir, example_name).as_str(),
+                ])
+                .status()
+                .expect("failed to execute process");
+            assert!(!status.success());
+        } else {
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+                .args([
+                    "mock",
+                    "-W",
+                    format!("{}/{}/witness.json", test_dir, example_name).as_str(),
+                    "-M",
+                    format!("{}/{}/network.compiled", test_dir, example_name).as_str(),
+                ])
+                .status()
+                .expect("failed to execute process");
+            assert!(status.success());
+        }
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -1492,6 +1616,7 @@ mod native_tests {
         cal_target: &str,
         scales_to_use: Option<Vec<u32>>,
         num_inner_columns: usize,
+        tolerance: &mut f32,
         commitment: Commitments,
         lookup_safety_margin: usize,
         bounded_lookup_log: bool,
@@ -1506,23 +1631,15 @@ mod native_tests {
                 "--settings-path={}/{}/settings.json",
                 test_dir, example_name
             ),
-            format!(
-                "--variables=batch_size->{},sequence_length->100,<Sym1>->1",
-                batch_size
-            ),
+            format!("--variables=batch_size->{}", batch_size),
             format!("--input-visibility={}", input_visibility),
             format!("--param-visibility={}", param_visibility),
             format!("--output-visibility={}", output_visibility),
             format!("--num-inner-cols={}", num_inner_columns),
+            format!("--tolerance={}", tolerance),
             format!("--commitment={}", commitment),
-            format!("--logrows={}", 22),
         ];
 
-        // if output-visibility is fixed set --range-check-inputs-outputs to False
-        if output_visibility == "fixed" {
-            args.push("--ignore-range-check-inputs-outputs".to_string());
-        }
-
         if let Some(decomp_base) = decomp_base {
             args.push(format!("--decomp-base={}", decomp_base));
         }
@@ -1535,7 +1652,7 @@ mod native_tests {
             args.push("--bounded-log-lookup".to_string());
         }
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(args)
             .status()
             .expect("failed to execute process");
@@ -1565,13 +1682,31 @@ mod native_tests {
             calibrate_args.push(scales);
         }
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(calibrate_args)
             .status()
             .expect("failed to execute process");
         assert!(status.success());
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let mut settings =
+            GraphSettings::load(&format!("{}/{}/settings.json", test_dir, example_name).into())
+                .unwrap();
+
+        let any_output_scales_smol = settings.model_output_scales.iter().any(|s| *s <= 0);
+
+        if any_output_scales_smol {
+            // set the tolerance to 0.0
+            settings.run_args.tolerance = Tolerance {
+                val: 0.0,
+                scale: 0.0.into(),
+            };
+            settings
+                .save(&format!("{}/{}/settings.json", test_dir, example_name).into())
+                .unwrap();
+            *tolerance = 0.0;
+        }
+
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "compile-circuit",
                 "-M",
@@ -1583,11 +1718,12 @@ mod native_tests {
                     test_dir, example_name
                 ),
             ])
+            .stdout(std::process::Stdio::null())
             .status()
             .expect("failed to execute process");
         assert!(status.success());
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "gen-witness",
                 "-D",
@@ -1625,6 +1761,7 @@ mod native_tests {
             cal_target,
             None,
             2,
+            &mut 0.0,
             Commitments::KZG,
             2,
             false,
@@ -1654,7 +1791,7 @@ mod native_tests {
 
     // Mock prove (fast, but does not cover some potential issues)
     fn render_circuit(test_dir: &str, example_name: String) {
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "render-circuit",
                 "-M",
@@ -1685,7 +1822,7 @@ mod native_tests {
             Commitments::KZG,
             2,
         );
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "mock-aggregate",
                 "--logrows=23",
@@ -1723,7 +1860,7 @@ mod native_tests {
 
         download_srs(23, commitment);
         // now setup-aggregate
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "setup-aggregate",
                 "--sample-snarks",
@@ -1739,7 +1876,7 @@ mod native_tests {
             .expect("failed to execute process");
         assert!(status.success());
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "aggregate",
                 "--logrows=23",
@@ -1754,7 +1891,7 @@ mod native_tests {
             .status()
             .expect("failed to execute process");
         assert!(status.success());
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "verify-aggr",
                 "--logrows=23",
@@ -1804,7 +1941,7 @@ mod native_tests {
         let private_key = format!("--private-key={}", *ANVIL_DEFAULT_PRIVATE_KEY);
 
         // create encoded calldata
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "encode-evm-calldata",
                 "--proof-path",
@@ -1826,7 +1963,7 @@ mod native_tests {
 
         let args = build_args(base_args, &sol_arg);
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(args)
             .status()
             .expect("failed to execute process");
@@ -1842,7 +1979,7 @@ mod native_tests {
             private_key.as_str(),
         ];
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(&args)
             .status()
             .expect("failed to execute process");
@@ -1864,14 +2001,14 @@ mod native_tests {
             rpc_arg.as_str(),
         ];
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(&base_args)
             .status()
             .expect("failed to execute process");
         assert!(status.success());
         // As sanity check, add example that should fail.
         base_args[2] = PF_FAILURE_AGGR;
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(base_args)
             .status()
             .expect("failed to execute process");
@@ -1910,6 +2047,7 @@ mod native_tests {
             target_str,
             scales_to_use,
             num_inner_columns,
+            &mut 0.0,
             commitment,
             lookup_safety_margin,
             false,
@@ -1921,7 +2059,7 @@ mod native_tests {
 
         init_params(settings_path.clone().into());
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "setup",
                 "-M",
@@ -1936,7 +2074,7 @@ mod native_tests {
             .expect("failed to execute process");
         assert!(status.success());
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "prove",
                 "-W",
@@ -1954,7 +2092,7 @@ mod native_tests {
             .expect("failed to execute process");
         assert!(status.success());
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "swap-proof-commitments",
                 "--proof-path",
@@ -1966,7 +2104,7 @@ mod native_tests {
             .expect("failed to execute process");
         assert!(status.success());
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "verify",
                 format!("--settings-path={}", settings_path).as_str(),
@@ -1989,7 +2127,7 @@ mod native_tests {
         // get_srs for the graph_settings_num_instances
         download_srs(1, graph_settings.run_args.commitment.into());
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "verify",
                 format!("--settings-path={}", settings_path).as_str(),
@@ -2039,7 +2177,7 @@ mod native_tests {
         let settings_arg = format!("--settings-path={}", settings_path);
 
         // create encoded calldata
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "encode-evm-calldata",
                 "--proof-path",
@@ -2059,7 +2197,7 @@ mod native_tests {
         args.push("--sol-code-path");
         args.push(sol_arg.as_str());
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(&args)
             .status()
             .expect("failed to execute process");
@@ -2071,7 +2209,7 @@ mod native_tests {
         args.push("--sol-code-path");
         args.push(sol_arg.as_str());
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(&args)
             .status()
             .expect("failed to execute process");
@@ -2093,14 +2231,14 @@ mod native_tests {
             deployed_addr_arg.as_str(),
         ];
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(&args)
             .status()
             .expect("failed to execute process");
         assert!(status.success());
         // As sanity check, add example that should fail.
         args[2] = PF_FAILURE;
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(args)
             .status()
             .expect("failed to execute process");
@@ -2159,7 +2297,7 @@ mod native_tests {
                     "--reusable",
                 ];
 
-                let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+                let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
                     .args(&args)
                     .status()
                     .expect("failed to execute process");
@@ -2174,7 +2312,7 @@ mod native_tests {
                     "-C=verifier/reusable",
                 ];
 
-                let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+                let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
                     .args(&args)
                     .status()
                     .expect("failed to execute process");
@@ -2203,7 +2341,7 @@ mod native_tests {
             &sol_arg_vk,
         ];
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(&args)
             .status()
             .expect("failed to execute process");
@@ -2218,7 +2356,7 @@ mod native_tests {
             "-C=vka",
         ];
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(&args)
             .status()
             .expect("failed to execute process");
@@ -2231,7 +2369,7 @@ mod native_tests {
         let deployed_addr_arg_vk = format!("--addr-vk={}", addr_vk);
 
         // create encoded calldata
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "encode-evm-calldata",
                 "--proof-path",
@@ -2254,7 +2392,7 @@ mod native_tests {
             deployed_addr_arg_vk.as_str(),
         ];
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(&args)
             .status()
             .expect("failed to execute process");
@@ -2287,7 +2425,7 @@ mod native_tests {
             // Verify the modified proof (should fail)
             let mut args_mod = args.clone();
             args_mod[2] = &modified_pf_arg;
-            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
                 .args(&args_mod)
                 .status()
                 .expect("failed to execute process");
@@ -2344,6 +2482,7 @@ mod native_tests {
             // we need the accuracy
             Some(vec![4]),
             1,
+            &mut 0.0,
             Commitments::KZG,
             2,
             false,
@@ -2364,7 +2503,7 @@ mod native_tests {
         let test_input_source = format!("--input-source={}", input_source);
         let test_output_source = format!("--output-source={}", output_source);
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "setup",
                 "-M",
@@ -2379,7 +2518,7 @@ mod native_tests {
         assert!(status.success());
 
         // generate the witness, passing the vk path to generate the necessary kzg commits
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "gen-witness",
                 "-D",
@@ -2436,7 +2575,7 @@ mod native_tests {
             }
             input.save(data_path.clone().into()).unwrap();
 
-            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
                 .args([
                     "setup-test-evm-data",
                     "-D",
@@ -2454,7 +2593,7 @@ mod native_tests {
             assert!(status.success());
         }
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "prove",
                 "-W",
@@ -2475,7 +2614,7 @@ mod native_tests {
         let settings_arg = format!("--settings-path={}", settings_path);
 
         // create encoded calldata
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "encode-evm-calldata",
                 "--proof-path",
@@ -2494,7 +2633,7 @@ mod native_tests {
         args.push("--sol-code-path");
         args.push(sol_arg.as_str());
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(&args)
             .status()
             .expect("failed to execute process");
@@ -2515,7 +2654,7 @@ mod native_tests {
         args.push("--sol-code-path");
         args.push(sol_arg.as_str());
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(&args)
             .status()
             .expect("failed to execute process");
@@ -2538,7 +2677,7 @@ mod native_tests {
             create_da_args.push(test_on_chain_data_path.as_str());
         }
 
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(&create_da_args)
             .status()
             .expect("failed to execute process");
@@ -2551,7 +2690,7 @@ mod native_tests {
         };
 
         let addr_path_da_arg = format!("--addr-path={}/{}/addr_da.txt", test_dir, example_name);
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args([
                 "deploy-evm-da",
                 format!("--settings-path={}", settings_path).as_str(),
@@ -2589,14 +2728,14 @@ mod native_tests {
             deployed_addr_da_arg.as_str(),
             rpc_arg.as_str(),
         ];
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(&args)
             .status()
             .expect("failed to execute process");
         assert!(status.success());
         // Create a new set of test on chain data only for the on-chain input source
         if input_source != "file" || output_source != "file" {
-            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
                 .args([
                     "setup-test-evm-data",
                     "-D",
@@ -2623,7 +2762,7 @@ mod native_tests {
                 test_on_chain_data_path.as_str(),
                 rpc_arg.as_str(),
             ];
-            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+            let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
                 .args(&args)
                 .status()
                 .expect("failed to execute process");
@@ -2639,7 +2778,7 @@ mod native_tests {
             deployed_addr_da_arg.as_str(),
             rpc_arg.as_str(),
         ];
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
             .args(args)
             .status()
             .expect("failed to execute process");
@@ -2650,7 +2789,7 @@ mod native_tests {
         #[cfg(feature = "icicle")]
         let args = [
             "build",
-            "--profile=test-runs",
+            "--release",
             "--bin",
             "ezkl",
             "--features",
@@ -2659,7 +2798,7 @@ mod native_tests {
         #[cfg(feature = "macos-metal")]
         let args = [
             "build",
-            "--profile=test-runs",
+            "--release",
             "--bin",
             "ezkl",
             "--features",
@@ -2667,11 +2806,11 @@ mod native_tests {
         ];
         // not macos-metal and not icicle
         #[cfg(all(not(feature = "icicle"), not(feature = "macos-metal")))]
-        let args = ["build", "--profile=test-runs", "--bin", "ezkl"];
+        let args = ["build", "--release", "--bin", "ezkl"];
         #[cfg(not(feature = "mv-lookup"))]
         let args = [
             "build",
-            "--profile=test-runs",
+            "--release",
             "--bin",
             "ezkl",
             "--no-default-features",
@@ -2692,7 +2831,7 @@ mod native_tests {
         let status = Command::new("wasm-pack")
             .args([
                 "build",
-                "--profile=test-runs",
+                "--release",
                 "--target",
                 "nodejs",
                 "--out-dir",

tests/py_integration_tests.rs

@@ -46,28 +46,7 @@ mod py_tests {
             assert!(status.success());
         });
         // set VOICE_DATA_DIR environment variable
-        unsafe {
-            std::env::set_var("VOICE_DATA_DIR", format!("{}", voice_data_dir));
-        }
-    }
-
-    fn download_catdog_data() {
-        let cat_and_dog_data_dir = shellexpand::tilde("~/data/catdog_data");
-
-        DOWNLOAD_VOICE_DATA.call_once(|| {
-            let status = Command::new("bash")
-                .args([
-                    "examples/notebooks/cat_and_dog_data.sh",
-                    &cat_and_dog_data_dir,
-                ])
-                .status()
-                .expect("failed to execute process");
-            assert!(status.success());
-        });
-        // set VOICE_DATA_DIR environment variable
-        unsafe {
-            std::env::set_var("CATDOG_DATA_DIR", format!("{}", cat_and_dog_data_dir));
-        }
+        std::env::set_var("VOICE_DATA_DIR", format!("{}", voice_data_dir));
     }
 
     fn setup_py_env() {
@@ -147,10 +126,10 @@ mod py_tests {
     }
 
     const TESTS: [&str; 35] = [
-        "mnist_gan.ipynb",                         // 0
-        "ezkl_demo_batch.ipynb",                   // 1
-        "proof_splitting.ipynb",                   // 2
-        "variance.ipynb",                          // 3
+        "ezkl_demo_batch.ipynb",                   // 0
+        "proof_splitting.ipynb",                   // 1
+        "variance.ipynb",                          // 2
+        "mnist_gan.ipynb",                         // 3
         "keras_simple_demo.ipynb",                 // 4
         "mnist_gan_proof_splitting.ipynb",         // 5
         "hashed_vis.ipynb",                        // 6
@@ -246,20 +225,6 @@ mod py_tests {
                 anvil_child.kill().unwrap();
             }
 
-
-            #[test]
-            fn cat_and_dog_notebook_() {
-                crate::py_tests::init_binary();
-                let mut anvil_child = crate::py_tests::start_anvil(false);
-                crate::py_tests::download_catdog_data();
-                let test_dir: TempDir = TempDir::new("cat_and_dog").unwrap();
-                let path = test_dir.path().to_str().unwrap();
-                crate::py_tests::mv_test_(path, "cat_and_dog.ipynb");
-                run_notebook(path, "cat_and_dog.ipynb");
-                test_dir.close().unwrap();
-                anvil_child.kill().unwrap();
-            }
-
             #[test]
             fn reusable_verifier_notebook_() {
                 crate::py_tests::init_binary();

tests/python/binding_tests.py

@@ -48,6 +48,7 @@ def test_py_run_args():
     run_args = ezkl.PyRunArgs()
     run_args.input_visibility = "hashed"
     run_args.output_visibility = "hashed"
+    run_args.tolerance = 1.5
 
 
 def test_poseidon_hash():
@@ -58,7 +59,7 @@ def test_poseidon_hash():
     message = [ezkl.float_to_felt(x, 7) for x in message]
     res = ezkl.poseidon_hash(message)
     assert ezkl.felt_to_big_endian(
-        res[0]) == "0x2369898875588bf49b6539376b09705ea69aee318a58e6fcc1e68fc3e7ad81ab"
+        res[0]) == "0x0da7e5e5c8877242fa699f586baf770d731defd54f952d4adeb85047a0e32f45"
 
 
 
@@ -872,8 +873,7 @@ def get_examples():
         'linear_regression',
         "mnist_gan",
         "smallworm",
-        "fr_age",
-        "1d_conv",
+        "fr_age"
     ]
     examples = []
     for subdir, _, _ in os.walk(os.path.join(examples_path, "onnx")):
@@ -900,12 +900,7 @@ async def test_all_examples(model_file, input_file):
     proof_path = os.path.join(folder_path, 'proof.json')
 
     print("Testing example: ", model_file)
-
-    run_args = ezkl.PyRunArgs()
-    run_args.variables = [("batch_size", 1), ("sequence_length", 100), ("<Sym1>", 1)]
-    run_args.logrows = 22
-
-    res = ezkl.gen_settings(model_file, settings_path, py_run_args=run_args)
+    res = ezkl.gen_settings(model_file, settings_path)
     assert res
 
     res = await ezkl.calibrate_settings(

tests/wasm.rs

@@ -11,6 +11,7 @@ mod wasm32 {
     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::GraphCircuit;
     use ezkl::graph::{GraphSettings, GraphWitness};
     use ezkl::pfsys;
@@ -226,9 +227,11 @@ mod wasm32 {
         let hash: Vec<Vec<Fr>> = serde_json::from_slice(&hash[..]).unwrap();
 
         let reference_hash =
-            PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>::run(message.clone())
-                .map_err(|_| "failed")
-                .unwrap();
+            PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, POSEIDON_LEN_GRAPH>::run(
+                message.clone(),
+            )
+            .map_err(|_| "failed")
+            .unwrap();
 
         assert_eq!(hash, reference_hash)
     }
@@ -337,7 +340,7 @@ mod wasm32 {
         // Run compiled circuit validation on onnx network (should fail)
         let circuit = compiledCircuitValidation(wasm_bindgen::Clamped(NETWORK.to_vec()));
         assert!(circuit.is_err());
-        // Run compiled circuit validation on compiled network (should pass)
+        // Run compiled circuit validation on comiled network (should pass)
         let circuit = compiledCircuitValidation(wasm_bindgen::Clamped(NETWORK_COMPILED.to_vec()));
         assert!(circuit.is_ok());
         // Run input validation on witness (should fail)