fix: bump python version (#761 )

chore: verify aggr wasm unit test (#760 )
chore: verify aggr in wasm (#758 )
2026-01-13 16:27:59 -05:00 · 2024-04-02 17:08:26 +01:00 · 2024-04-01 20:54:20 +01:00 · 2024-03-29 23:28:20 +00:00 · 2024-03-27 01:14:29 +00:00 · 2024-03-26 13:12:09 +00:00
165 changed files with 22455 additions and 18116 deletions
--- a/.github/workflows/large-tests.yml
+++ b/.github/workflows/large-tests.yml
@@ -6,12 +6,12 @@ on:
        description: "Test scenario tags"
 jobs:
  large-tests:
-    runs-on: self-hosted
+    runs-on: kaiju
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - name: nanoGPT Mock
@@ -23,6 +23,6 @@ jobs:
      - name: Self Attention KZG prove and verify large tests
        run: cargo test --release --verbose tests::large_kzg_prove_and_verify_::large_tests_0_expects -- --include-ignored
      - name: mobilenet Mock
-        run: cargo test --release --verbose tests::large_mock_::large_tests_2_expects -- --include-ignored
+        run: cargo test --release --verbose tests::large_mock_::large_tests_3_expects -- --include-ignored
      - name: mobilenet KZG prove and verify large tests
-        run: cargo test --release --verbose tests::large_kzg_prove_and_verify_::large_tests_2_expects -- --include-ignored
+        run: cargo test --release --verbose tests::large_kzg_prove_and_verify_::large_tests_3_expects -- --include-ignored
--- a/.github/workflows/wasm.yml
+++ b/.github/workflows/wasm.yml
@@ -1,4 +1,4 @@
-name: Build and Publish WASM<>JS Bindings
+name: Build and Publish EZKL npm packages (wasm bindings and in-browser evm verifier)

 on:
  workflow_dispatch:
@@ -14,7 +14,7 @@ defaults:
  run:
    working-directory: .
 jobs:
-  wasm-publish:
+  publish-wasm-bindings:
    name: publish-wasm-bindings
    runs-on: ubuntu-latest
    if: startsWith(github.ref, 'refs/tags/')
@@ -22,24 +22,21 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: jetli/wasm-pack-action@v0.4.0
      - name: Add wasm32-unknown-unknown target
        run: rustup target add wasm32-unknown-unknown

-      - name: Install wasm-server-runner
-        run: cargo install wasm-server-runner
-
      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
      - name: Install binaryen
        run: |
-            set -e
-            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
+          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"
@@ -95,7 +92,7 @@ jobs:
            const jsonObject = JSONBig.parse(string);
            return jsonObject;
          }
-          
+
          function serialize(data) { // data is an object // return a Uint8ClampedArray
            // Step 1: Stringify the Object with BigInt support
            if (typeof data === "object") {
@@ -103,11 +100,11 @@ jobs:
            }
            // Step 2: Encode the JSON String
            const uint8Array = new TextEncoder().encode(data);
-          
+
            // Step 3: Convert to Uint8ClampedArray
            return new Uint8ClampedArray(uint8Array.buffer);
          }
-          
+
          module.exports = {
            deserialize,
            serialize
@@ -126,7 +123,7 @@ jobs:
            const jsonObject = parse(string);
            return jsonObject;
          }
-          
+
          export function serialize(data) { // data is an object // return a Uint8ClampedArray
            // Step 1: Stringify the Object with BigInt support
            if (typeof data === "object") {
@@ -134,7 +131,7 @@ jobs:
            }
            // Step 2: Encode the JSON String
            const uint8Array = new TextEncoder().encode(data);
-          
+
            // Step 3: Convert to Uint8ClampedArray
            return new Uint8ClampedArray(uint8Array.buffer);
          }
@@ -177,3 +174,40 @@ jobs:
          npm publish
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+  in-browser-evm-ver-publish:
+    name: publish-in-browser-evm-verifier-package
+    needs: ["publish-wasm-bindings"]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - uses: actions/checkout@v4
+      - name: Update version in package.json
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          sed -i "s|\"version\": \".*\"|\"version\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
+      - name: Update @ezkljs/engine version in package.json
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          sed -i "s|\"@ezkljs/engine\": \".*\"|\"@ezkljs/engine\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
+      - name: Update the engine import in in-browser-evm-verifier to use @ezkljs/engine package instead of the local one;
+        run: |
+          sed -i "s|import { encodeVerifierCalldata } from '../nodejs/ezkl';|import { encodeVerifierCalldata } from '@ezkljs/engine';|" in-browser-evm-verifier/src/index.ts
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "18.12.1"
+          registry-url: "https://registry.npmjs.org"
+      - name: Publish to npm
+        run: |
+          cd in-browser-evm-verifier
+          npm install
+          npm run build
+          npm ci
+          npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
--- a/.github/workflows/pypi-gpu.yml
+++ b/.github/workflows/pypi-gpu.yml
@@ -26,7 +26,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v4
        with:
-          python-version: 3.7
+          python-version: 3.12
          architecture: x64

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

      - name: Set Cargo.toml version to match github tag
@@ -70,7 +70,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v4
        with:
-          python-version: 3.7
+          python-version: 3.12
          architecture: ${{ matrix.target }}

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

      - name: Set Cargo.toml version to match github tag
@@ -139,6 +139,20 @@ jobs:
          target: ${{ matrix.target }}
          manylinux: auto
          args: --release --out dist --features python-bindings
+          before-script-linux: |
+            # If we're running on rhel centos, install needed packages.
+            if command -v yum &> /dev/null; then
+                yum update -y && yum install -y perl-core openssl openssl-devel pkgconfig libatomic
+
+                # If we're running on i686 we need to symlink libatomic
+                # in order to build openssl with -latomic flag.
+                if [[ ! -d "/usr/lib64" ]]; then
+                    ln -s /usr/lib/libatomic.so.1 /usr/lib/libatomic.so
+                fi
+            else
+                # If we're running on debian-based system.
+                apt update -y && apt-get install -y libssl-dev openssl pkg-config
+            fi

      - name: Install built wheel
        if: matrix.target == 'x86_64'
@@ -162,7 +176,7 @@ jobs:
  #   - uses: actions/checkout@v4
  #   - uses: actions/setup-python@v4
  #     with:
-  #       python-version: 3.7
+  #       python-version: 3.12

  #   - name: Install cross-compilation tools for aarch64
  #     if: matrix.target == 'aarch64'
@@ -214,7 +228,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v4
        with:
-          python-version: 3.7
+          python-version: 3.12
          architecture: x64

      - name: Set Cargo.toml version to match github tag
@@ -249,7 +263,7 @@ jobs:
            apk add py3-pip
            pip3 install -U pip
            python3 -m venv .venv
-            source .venv/bin/activate            
+            source .venv/bin/activate
            pip3 install ezkl --no-index --find-links /io/dist/ --force-reinstall
            python3 -c "import ezkl"

@@ -273,7 +287,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v4
        with:
-          python-version: 3.7
+          python-version: 3.12

      - name: Set Cargo.toml version to match github tag
        shell: bash
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -32,7 +32,7 @@ jobs:
          token: ${{ secrets.RELEASE_TOKEN }}
          tag_name: ${{ env.EZKL_VERSION }}

-  build-release-gpu: 
+  build-release-gpu:
    name: build-release-gpu
    needs: ["create-release"]
    runs-on: GPU
@@ -45,7 +45,7 @@ jobs:
    steps:
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - name: Checkout repo
@@ -60,16 +60,15 @@ jobs:
      - name: Set Cargo.toml version to match github tag
        shell: bash
        run: |
-            mv Cargo.toml Cargo.toml.orig
-            sed "s/0\\.0\\.0/${EZKL_VERSION//v}/" Cargo.toml.orig >Cargo.toml
-            mv Cargo.lock Cargo.lock.orig
-            sed "s/0\\.0\\.0/${EZKL_VERSION//v}/" Cargo.lock.orig >Cargo.lock
-
+          mv Cargo.toml Cargo.toml.orig
+          sed "s/0\\.0\\.0/${EZKL_VERSION//v}/" Cargo.toml.orig >Cargo.toml
+          mv Cargo.lock Cargo.lock.orig
+          sed "s/0\\.0\\.0/${EZKL_VERSION//v}/" Cargo.lock.orig >Cargo.lock

      - name: Install dependencies
        shell: bash
        run: |
-            sudo apt-get update
+          sudo apt-get update

      - name: Build release binary
        run: cargo build --release -Z sparse-registry --features icicle
@@ -91,7 +90,6 @@ jobs:
          asset_name: ${{ env.ASSET }}
          asset_content_type: application/octet-stream

-
  build-release:
    name: build-release
    needs: ["create-release"]
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -26,7 +26,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - name: Build
@@ -38,7 +38,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - name: Docs
@@ -50,7 +50,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -73,7 +73,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -106,7 +106,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -139,7 +139,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -172,7 +172,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -184,12 +184,12 @@ jobs:

  wasm32-tests:
    runs-on: ubuntu-latest
-    # needs: [build,  library-tests, docs]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: jetli/wasm-pack-action@v0.4.0
@@ -198,10 +198,8 @@ jobs:
        #   chromedriver-version: "115.0.5790.102"
      - name: Install wasm32-unknown-unknown
        run: rustup target add wasm32-unknown-unknown
-      - name: Install wasm runner
-        run: cargo install wasm-server-runner
      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
      - name: Run wasm verifier tests
        # on mac:
        #   AR=/opt/homebrew/opt/llvm/bin/llvm-ar CC=/opt/homebrew/opt/llvm/bin/clang wasm-pack test --firefox --headless -- -Z build-std="panic_abort,std" --features web
@@ -209,12 +207,12 @@ jobs:

  tutorial:
    runs-on: ubuntu-latest
-    needs: [build, library-tests, docs]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -226,18 +224,20 @@ jobs:

  mock-proving-tests:
    runs-on: non-gpu
-    # needs: [build,  library-tests, docs]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
        with:
          crate: cargo-nextest
          locked: true
+      - name: public outputs and tolerance > 0
+        run: cargo nextest run --release --verbose tests::mock_tolerance_public_outputs_ --test-threads 32
      - name: public outputs + batch size == 10
        run: cargo nextest run --release --verbose tests::mock_large_batch_public_outputs_ --test-threads 32
      - name: kzg inputs
@@ -281,12 +281,12 @@ jobs:

  prove-and-verify-evm-tests:
    runs-on: non-gpu
-    needs: [build, library-tests]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -303,16 +303,32 @@ jobs:
        with:
          node-version: "18.12.1"
          cache: "pnpm"
-      - name: Install dependencies
+      - name: "Add rust-src"
+        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
+      - name: Install dependencies for js tests and in-browser-evm-verifier package
        run: |
          pnpm install --no-frozen-lockfile
+          pnpm install --dir ./in-browser-evm-verifier --no-frozen-lockfile
        env:
          CI: false
          NODE_ENV: development
+      - name: Build wasm package for nodejs target.
+        run: |
+          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
+      - name: Build @ezkljs/verify package
+        run: |
+          cd in-browser-evm-verifier
+          pnpm build:commonjs
+          cd ..
      - name: Install solc
        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
+      - name: KZG prove and verify tests (EVM + VK rendered seperately)
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_prove_and_verify_render_seperately_ --test-threads 1
      - name: KZG prove and verify tests (EVM + kzg all)
        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)
@@ -338,23 +354,20 @@ jobs:

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

-      - name: Install wasm-server-runner
-        run: cargo install wasm-server-runner
-
      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
      - uses: actions/checkout@v3
      - name: Use pnpm 8
        uses: pnpm/action-setup@v2
@@ -365,7 +378,7 @@ jobs:
        with:
          node-version: "18.12.1"
          cache: "pnpm"
-      - name: Install dependencies
+      - name: Install dependencies for js tests
        run: |
          pnpm install --no-frozen-lockfile
        env:
@@ -381,6 +394,12 @@ jobs:
      - name: Replace memory definition in nodejs
        run: |
          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" tests/wasm/nodejs/ezkl.js
+      - name: KZG prove and verify tests (public outputs)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_tight_lookup_::t
+      - name: IPA prove and verify tests
+        run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_::t --test-threads 1
+      - name: IPA prove and verify tests (ipa outputs)
+        run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_ipa_output
      - name: KZG prove and verify tests (public outputs + column overflow)
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w
      - name: KZG prove and verify tests single inner col
@@ -397,8 +416,6 @@ jobs:
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_
      - name: KZG prove and verify tests (public outputs)
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t
-      - name: KZG prove and verify tests (public outputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t
      - name: KZG prove and verify tests (public inputs)
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input
      - name: KZG prove and verify tests (fixed params)
@@ -414,71 +431,48 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
      - uses: actions/checkout@v3
      - uses: baptiste0928/cargo-install@v1
        with:
          crate: cargo-nextest
          locked: true
      - name: KZG prove and verify tests (kzg outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output --features icicle --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output --features icicle --test-threads 1
      - name: KZG prove and verify tests (public outputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w --features icicle  --test-threads 1
      - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_ --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_ --features icicle  --test-threads 1
      - name: KZG prove and verify tests (public outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
      - name: KZG prove and verify tests (public outputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
      - name: KZG prove and verify tests (public inputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input --features icicle  --test-threads 1
      - name: KZG prove and verify tests (fixed params)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params --features icicle  --test-threads 2
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params --features icicle  --test-threads 1
      - name: KZG prove and verify tests (hashed outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 2
-
-  fuzz-tests:
-    runs-on: ubuntu-latest-32-cores
-    needs: [build, library-tests, python-tests]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly-2023-08-24
-          override: true
-          components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@v1
-        with:
-          crate: cargo-nextest
-          locked: true
-      - name: Install solc
-        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
-      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
-      - name: fuzz tests (EVM)
-        run: cargo nextest run --release --verbose tests_evm::kzg_evm_fuzz_ --test-threads 2
-      # - name: fuzz tests
-      #   run: cargo nextest run --release --verbose tests::kzg_fuzz_ --test-threads 6
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1

  prove-and-verify-mock-aggr-tests:
    runs-on: self-hosted
-    needs: [build, library-tests]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
        with:
          crate: cargo-nextest
          locked: true
-      - name: Mock aggr tests
+      - name: Mock aggr tests (KZG)
        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_mock_prove_and_verify_  --test-threads 8

  prove-and-verify-aggr-tests-gpu:
@@ -489,7 +483,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -501,29 +495,29 @@ jobs:

  prove-and-verify-aggr-tests:
    runs-on: large-self-hosted
-    needs: [build, library-tests, python-tests]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
        with:
          crate: cargo-nextest
          locked: true
-      - name: KZG )tests
-        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 8 -- --include-ignored
+      - name: KZG tests
+        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 4 -- --include-ignored

  prove-and-verify-aggr-evm-tests:
    runs-on: large-self-hosted
-    needs: [build, library-tests, python-tests]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -533,7 +527,7 @@ jobs:
      - name: Install solc
        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
      - name: KZG prove and verify aggr tests
        run: cargo nextest run  --release --verbose tests_evm::kzg_evm_aggr_prove_and_verify_::t --test-threads 4 -- --include-ignored

@@ -544,7 +538,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -563,34 +557,36 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v4
        with:
-          python-version: "3.7"
+          python-version: "3.12"
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
+      - name: Install cmake
+        run: sudo apt-get install -y cmake
      - name: Install solc
        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
      - name: Setup Virtual Env and Install python dependencies
-        run: python -m venv .env; source .env/bin/activate; pip install -r requirements.txt;
+        run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt;
      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
      - name: Build python ezkl
-        run: source .env/bin/activate; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
      - name: Run pytest
        run: source .env/bin/activate; pytest -vv

  accuracy-measurement-tests:
    runs-on: ubuntu-latest-32-cores
-    # needs: [build, library-tests, docs]
+    needs: [build, library-tests, docs, python-tests, python-integration-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v4
        with:
-          python-version: "3.7"
+          python-version: "3.12"
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -598,9 +594,11 @@ jobs:
          crate: cargo-nextest
          locked: true
      - name: Setup Virtual Env and Install python dependencies
-        run: python -m venv .env; source .env/bin/activate; pip install -r requirements.txt;
+        run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt;
      - name: Build python ezkl
-        run: source .env/bin/activate; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
+      - name: Div rebase
+        run: source .env/bin/activate; cargo nextest run --release --verbose tests::accuracy_measurement_div_rebase_
      - name: Public inputs
        run: source .env/bin/activate; cargo nextest run --release --verbose tests::accuracy_measurement_public_inputs_
      - name: fixed params
@@ -616,10 +614,10 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v4
        with:
-          python-version: "3.9"
+          python-version: "3.11"
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -629,11 +627,15 @@ jobs:
      - name: Install solc
        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
+      - name: Install pip
+        run: python -m ensurepip --upgrade
      - name: Setup Virtual Env and Install python dependencies
-        run: python -m venv .env; source .env/bin/activate; pip install -r requirements.txt;
+        run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt; python -m ensurepip --upgrade
      - name: Build python ezkl
-        run: source .env/bin/activate; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
+      - name: Tictactoe tutorials
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_ --test-threads 1
      # - name: authenticate-kaggle-cli
      #   shell: bash
      #   env:
@@ -643,14 +645,11 @@ 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: Voice tutorial
        run: source .env/bin/activate; cargo nextest run py_tests::tests::voice_
      - name: NBEATS tutorial
        run: source .env/bin/activate; cargo nextest run py_tests::tests::nbeats_
-      - name: All notebooks
-        run: source .env/bin/activate; cargo nextest run py_tests::tests::run_notebook_ --test-threads 1
-      - name: Tictactoe tutorials
-        run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_ --test-threads 1
      # - name: Postgres tutorials
      #   run: source .env/bin/activate; cargo nextest run py_tests::tests::postgres_ --test-threads 1
-     
--- a/.gitignore
+++ b/.gitignore
@@ -45,6 +45,8 @@ var/
 *.whl
 *.bak
 node_modules
+/dist
 timingData.json
 !tests/wasm/pk.key
-!tests/wasm/vk.key
+!tests/wasm/vk.key
+!tests/wasm/vk_aggr.key
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,70 +15,96 @@ crate-type = ["cdylib", "rlib"]


 [dependencies]
-halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch= "ac/lookup-modularity" }
-halo2_proofs = { git = "https://github.com/zkonduit/halo2", branch= "ac/lookup-modularity"  }
-halo2curves = { version = "0.1.0" }
+halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch = "ac/optional-selector-poly" }
+halo2_proofs = { git = "https://github.com/zkonduit/halo2", branch = "ac/optional-selector-poly" }
+halo2curves = { git = "https://github.com/privacy-scaling-explorations/halo2curves", rev = "9fff22c", features = [
+    "derive_serde",
+] }
 rand = { version = "0.8", default_features = false }
 itertools = { version = "0.10.3", default_features = false }
-clap = { version = "4.3.3", features = ["derive"]}
+clap = { version = "4.5.3", features = ["derive"] }
 serde = { version = "1.0.126", features = ["derive"], optional = true }
-serde_json = { version = "1.0.97", default_features = false, features = ["float_roundtrip", "raw_value"], optional = true }
+serde_json = { version = "1.0.97", default_features = false, features = [
+    "float_roundtrip",
+    "raw_value",
+], optional = true }
 log = { version = "0.4.17", default_features = false, optional = true }
 thiserror = { version = "1.0.38", default_features = false }
 hex = { version = "0.4.3", default_features = false }
 halo2_wrong_ecc = { git = "https://github.com/zkonduit/halo2wrong", branch = "ac/chunked-mv-lookup", package = "ecc" }
-snark-verifier = { git = "https://github.com/zkonduit/snark-verifier", branch = "ac/chunked-mv-lookup", features=["derive_serde"]}
-halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier",  branch= "ac/lookup-modularity" }
-maybe-rayon = { version = "0.1.1",  default_features = false }
+snark-verifier = { git = "https://github.com/zkonduit/snark-verifier", branch = "ac/chunked-mv-lookup", features = [
+    "derive_serde",
+] }
+halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier", branch = "main" }
+maybe-rayon = { version = "0.1.1", default_features = false }
 bincode = { version = "1.3.3", default_features = false }
 ark-std = { version = "^0.3.0", default-features = false }
 unzip-n = "0.1.2"
 num = "0.4.1"
+portable-atomic = "1.6.0"
+tosubcommand = { git = "https://github.com/zkonduit/enum_to_subcommand", package = "tosubcommand" }
+

 # evm related deps
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-ethers = { version = "2.0.7", default_features = false, features = ["ethers-solc"] }
-indicatif = {version = "0.17.5", features = ["rayon"]}
-gag =  { version = "1.0.0", default_features = false}
+ethers = { version = "2.0.11", default_features = false, features = [
+    "ethers-solc",
+] }
+indicatif = { version = "0.17.5", features = ["rayon"] }
+gag = { version = "1.0.0", default_features = false }
 instant = { version = "0.1" }
-reqwest = { version = "0.11.14", default-features = false, features = ["default-tls", "multipart", "stream"] }
+reqwest = { version = "0.11.14", default-features = false, features = [
+    "default-tls",
+    "multipart",
+    "stream",
+] }
 openssl = { version = "0.10.55", features = ["vendored"] }
 postgres = "0.19.5"
 pg_bigdecimal = "0.1.5"
 lazy_static = "1.4.0"
-colored_json =  { version = "3.0.1",  default_features = false, optional = true}
+colored_json = { version = "3.0.1", default_features = false, optional = true }
 plotters = { version = "0.3.0", default_features = false, optional = true }
 regex = { version = "1", default_features = false }
-tokio = { version = "1.26.0",  default_features = false, features = ["macros", "rt"] }
+tokio = { version = "1.26.0", default_features = false, features = [
+    "macros",
+    "rt",
+] }
 tokio-util = { version = "0.7.9", features = ["codec"] }
-pyo3 = { version = "0.20.2", features = ["extension-module", "abi3-py37", "macros"],  default_features = false, optional = true }
-pyo3-asyncio = { version = "0.20.0",  features = ["attributes", "tokio-runtime"],  default_features = false, optional = true }
+pyo3 = { version = "0.20.2", features = [
+    "extension-module",
+    "abi3-py37",
+    "macros",
+], default_features = false, optional = true }
+pyo3-asyncio = { version = "0.20.0", features = [
+    "attributes",
+    "tokio-runtime",
+], default_features = false, optional = true }
 pyo3-log = { version = "0.9.0", default_features = false, optional = true }
-tract-onnx = { git = "https://github.com/sonos/tract/", rev= "7b1aa33b2f7d1f19b80e270c83320f0f94daff69", default_features = false, optional = true }
+tract-onnx = { git = "https://github.com/sonos/tract/", rev = "7b1aa33b2f7d1f19b80e270c83320f0f94daff69", default_features = false, optional = true }
 tabled = { version = "0.12.0", optional = true }


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

 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.2.8", features = ["js"] }
-instant = { version = "0.1", features = [ "wasm-bindgen", "inaccurate" ] }
+instant = { version = "0.1", features = ["wasm-bindgen", "inaccurate"] }

 [target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
-wasm-bindgen-rayon = { version = "1.0", optional=true }
-wasm-bindgen-test = "0.3.34"
-serde-wasm-bindgen = "0.4"
-wasm-bindgen = { version = "0.2.81", features = ["serde-serialize"]}
+wasm-bindgen-rayon = { version = "1.2.1", optional = true }
+wasm-bindgen-test = "0.3.42"
+serde-wasm-bindgen = "0.6.5"
+wasm-bindgen = { version = "0.2.92", features = ["serde-serialize"] }
 console_error_panic_hook = "0.1.7"
 wasm-bindgen-console-logger = "0.1.1"


 [dev-dependencies]
-criterion = {version = "0.3",  features = ["html_reports"]}
+criterion = { version = "0.3", features = ["html_reports"] }
 tempfile = "3.3.0"
 lazy_static = "1.4.0"
 mnist = "0.5"
@@ -150,18 +176,36 @@ required-features = ["ezkl"]
 [features]
 web = ["wasm-bindgen-rayon"]
 default = ["ezkl", "mv-lookup"]
-render = ["halo2_proofs/dev-graph", "plotters"]
 onnx = ["dep:tract-onnx"]
 python-bindings = ["pyo3", "pyo3-log", "pyo3-asyncio"]
-ezkl = ["onnx", "serde", "serde_json", "log", "colored", "env_logger", "tabled/color", "colored_json", "halo2_proofs/circuit-params"]
-mv-lookup = ["halo2_proofs/mv-lookup", "snark-verifier/mv-lookup", "halo2_solidity_verifier/mv-lookup"]
+ezkl = [
+    "onnx",
+    "serde",
+    "serde_json",
+    "log",
+    "colored",
+    "env_logger",
+    "tabled/color",
+    "colored_json",
+    "halo2_proofs/circuit-params",
+]
+mv-lookup = [
+    "halo2_proofs/mv-lookup",
+    "snark-verifier/mv-lookup",
+    "halo2_solidity_verifier/mv-lookup",
+]
 det-prove = []
 icicle = ["halo2_proofs/icicle_gpu"]
 empty-cmd = []
+no-banner = []

 # icicle patch to 0.1.0 if feature icicle is enabled
 [patch.'https://github.com/ingonyama-zk/icicle']
-icicle = { git = "https://github.com/ingonyama-zk/icicle?rev=45b00fb", package = "icicle", branch = "fix/vhnat/ezkl-build-fix"}
+icicle = { git = "https://github.com/ingonyama-zk/icicle?rev=45b00fb", package = "icicle", branch = "fix/vhnat/ezkl-build-fix" }
+
+[patch.'https://github.com/zkonduit/halo2']
+halo2_proofs = { git = "https://github.com/zkonduit/halo2?branch=ac/optional-selector-poly#54f54453cf186aa5d89579c4e7663f9a27cfb89a", package = "halo2_proofs", branch = "ac/optional-selector-poly" }
+

 [profile.release]
-rustflags = [ "-C", "relocation-model=pic" ]
+rustflags = ["-C", "relocation-model=pic"]
--- a/README.md
+++ b/README.md
@@ -31,9 +31,9 @@ EZKL

 [![Notebook](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/zkonduit/ezkl/blob/main/examples/notebooks/simple_demo_all_public.ipynb) 

-In the backend we use [Halo2](https://github.com/privacy-scaling-explorations/halo2) as a proof system.
+In the backend we use the collaboratively-developed [Halo2](https://github.com/privacy-scaling-explorations/halo2) as a proof system.

-The generated proofs can then be used on-chain to verify computation, only the Ethereum Virtual Machine (EVM) is supported at the moment.
+The generated proofs can then be verified with much less computational resources, including on-chain (with the Ethereum Virtual Machine), in a browser, or on a device. 

 - If you have any questions, we'd love for you to open up a discussion topic in [Discussions](https://github.com/zkonduit/ezkl/discussions). Alternatively, you can join the ✨[EZKL Community Telegram Group](https://t.me/+QRzaRvTPIthlYWMx)💫.

@@ -45,6 +45,8 @@ The generated proofs can then be used on-chain to verify computation, only the E

 ### getting started ⚙️

+The easiest way to get started is to try out a notebook. 
+
 #### Python
 Install the python bindings by calling.

@@ -65,15 +67,19 @@ More notebook tutorials can be found within `examples/notebooks`.
 #### CLI
 Install the CLI
 ``` shell
-curl https://github.com/JSeam2/ezkl/blob/main/install_ezkl_cli.sh | bash
+curl https://raw.githubusercontent.com/zkonduit/ezkl/main/install_ezkl_cli.sh | bash
 ```

 https://user-images.githubusercontent.com/45801863/236771676-5bbbbfd1-ba6f-418a-902e-20738ce0e9f0.mp4

-For more details visit the [docs](https://docs.ezkl.xyz).
+For more details visit the [docs](https://docs.ezkl.xyz). The CLI is faster than Python, as it has less overhead. For even more speed and convenience, check out the [remote proving service](https://ei40vx5x6j0.typeform.com/to/sFv1oxvb), which feels like the CLI but is backed by a tuned cluster.

 Build the auto-generated rust documentation and open the docs in your browser locally. `cargo doc --open`

+#### In-browser EVM verifier
+
+As an alternative to running the native Halo2 verifier as a WASM binding in the browser, you can use the in-browser EVM verifier. The source code of which you can find in the `in-browser-evm-verifier` directory and a README with instructions on how to use it.
+

 ### building the project 🔨

@@ -120,17 +126,6 @@ unset ENABLE_ICICLE_GPU

 **NOTE:** Even with the above environment variable set, icicle is disabled for circuits where k <= 8. To change the value of `k` where icicle is enabled, you can set the environment variable `ICICLE_SMALL_K`.

-### repos
-
-The EZKL project has several libraries and repos. 
-
-| Repo | Description |
-| --- | --- |
-| [@zkonduit/ezkl](https://github.com/zkonduit/ezkl) | the main ezkl repo in rust with wasm and python bindings |
-| [@zkonduit/ezkljs](https://github.com/zkonduit/ezkljs) | typescript and javascript tooling to help integrate ezkl into web apps |
-
----------------------
-
 ### contributing 🌎

 If you're interested in contributing and are unsure where to start, reach out to one of the maintainers:
@@ -147,7 +142,7 @@ More broadly:
 - To report bugs or request new features [create a new issue within Issues](https://github.com/zkonduit/ezkl/issues) to inform the greater community.


-Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you shall be licensed to Zkonduit Inc. under the terms and conditions specified in the [CLA](https://github.com/zkonduit/ezkl/blob/main/cla.md), which you agree to by intentionally submitting a contribution. In particular, you have the right to submit the contribution and we can distribute it under the Apache 2.0 license, among other terms and conditions. 
+Any contribution intentionally submitted for inclusion in the work by you shall be licensed to Zkonduit Inc. under the terms and conditions specified in the [CLA](https://github.com/zkonduit/ezkl/blob/main/cla.md), which you agree to by intentionally submitting a contribution. In particular, you have the right to submit the contribution and we can distribute it, among other terms and conditions. 

 ### no security guarantees

@@ -155,4 +150,7 @@ 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. 

+### 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,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/benches/accum_conv.rs
+++ b/benches/accum_conv.rs
@@ -2,11 +2,13 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
 use ezkl::pfsys::create_keys;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::srs::gen_srs;
 use ezkl::pfsys::TranscriptType;
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
+use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    arithmetic::Field,
@@ -15,6 +17,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;

 static mut KERNEL_HEIGHT: usize = 2;
 static mut KERNEL_WIDTH: usize = 2;
@@ -121,25 +124,35 @@ fn runcnvrl(c: &mut Criterion) {
            group.throughput(Throughput::Elements(*size as u64));
            group.bench_with_input(BenchmarkId::new("pk", size), &size, |b, &_| {
                b.iter(|| {
-                    create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+                    create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                        .unwrap();
                });
            });

-            let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+            let pk = create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                .unwrap();

            group.throughput(Throughput::Elements(*size as u64));
            group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {
                b.iter(|| {
-                    let prover = create_proof_circuit_kzg(
+                    let prover = create_proof_circuit::<
+                        KZGCommitmentScheme<_>,
+                        MyCircuit,
+                        ProverSHPLONK<_>,
+                        VerifierSHPLONK<_>,
+                        SingleStrategy<_>,
+                        _,
+                        EvmTranscript<_, _, _, _>,
+                        EvmTranscript<_, _, _, _>,
+                    >(
                        circuit.clone(),
+                        vec![],
                        &params,
-                        None,
                        &pk,
-                        TranscriptType::EVM,
-                        SingleStrategy::new(&params),
                        CheckMode::UNSAFE,
+                        ezkl::Commitments::KZG,
+                        TranscriptType::EVM,
+                        None,
                        None,
                    );
                    prover.unwrap();
--- a/benches/accum_dot.rs
+++ b/benches/accum_dot.rs
@@ -1,11 +1,13 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
+use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    arithmetic::Field,
@@ -14,6 +16,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;

 static mut LEN: usize = 4;
@@ -90,25 +93,35 @@ fn rundot(c: &mut Criterion) {
        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
            b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();

        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
            b.iter(|| {
-                let prover = create_proof_circuit_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
-                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
+                    TranscriptType::EVM,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/accum_einsum_matmul.rs
+++ b/benches/accum_einsum_matmul.rs
@@ -1,11 +1,13 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
+use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    arithmetic::Field,
@@ -14,6 +16,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;

 static mut LEN: usize = 4;
@@ -94,25 +97,35 @@ fn runmatmul(c: &mut Criterion) {
        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
            b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();

        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
            b.iter(|| {
-                let prover = create_proof_circuit_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
-                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
+                    TranscriptType::EVM,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/accum_matmul_relu.rs
+++ b/benches/accum_matmul_relu.rs
@@ -1,22 +1,26 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use ezkl::circuit::table::Range;
 use ezkl::circuit::*;

 use ezkl::circuit::lookup::LookupOp;
 use ezkl::circuit::poly::PolyOp;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
+use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    circuit::{Layouter, SimpleFloorPlanner, Value},
    plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;

-const BITS: (i128, i128) = (-32768, 32768);
+const BITS: Range = (-32768, 32768);
 static mut LEN: usize = 4;
 const K: usize = 16;

@@ -111,25 +115,35 @@ fn runmatmul(c: &mut Criterion) {
        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
            b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();

        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
            b.iter(|| {
-                let prover = create_proof_circuit_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
+                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
-                    CheckMode::SAFE,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/accum_matmul_relu_overflow.rs
+++ b/benches/accum_matmul_relu_overflow.rs
@@ -3,20 +3,24 @@ use ezkl::circuit::*;

 use ezkl::circuit::lookup::LookupOp;
 use ezkl::circuit::poly::PolyOp;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::circuit::table::Range;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
+use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    circuit::{Layouter, SimpleFloorPlanner, Value},
    plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;

-const BITS: (i128, i128) = (-8180, 8180);
+const BITS: Range = (-8180, 8180);
 static mut LEN: usize = 4;
 static mut K: usize = 16;

@@ -114,25 +118,35 @@ fn runmatmul(c: &mut Criterion) {
        group.throughput(Throughput::Elements(k as u64));
        group.bench_with_input(BenchmarkId::new("pk", k), &k, |b, &_| {
            b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();

        group.throughput(Throughput::Elements(k as u64));
        group.bench_with_input(BenchmarkId::new("prove", k), &k, |b, &_| {
            b.iter(|| {
-                let prover = create_proof_circuit_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
+                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
-                    CheckMode::SAFE,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/accum_sum.rs
+++ b/benches/accum_sum.rs
@@ -1,11 +1,13 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
+use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    arithmetic::Field,
@@ -14,6 +16,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;

 static mut LEN: usize = 4;
@@ -86,25 +89,35 @@ fn runsum(c: &mut Criterion) {
        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
            b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();

        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
            b.iter(|| {
-                let prover = create_proof_circuit_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
-                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
+                    TranscriptType::EVM,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/accum_sumpool.rs
+++ b/benches/accum_sumpool.rs
@@ -2,11 +2,13 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::hybrid::HybridOp;
 use ezkl::circuit::*;
 use ezkl::pfsys::create_keys;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::srs::gen_srs;
 use ezkl::pfsys::TranscriptType;
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
+use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    arithmetic::Field,
@@ -15,6 +17,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;

 static mut IMAGE_HEIGHT: usize = 2;
 static mut IMAGE_WIDTH: usize = 2;
@@ -101,25 +104,35 @@ fn runsumpool(c: &mut Criterion) {
            group.throughput(Throughput::Elements(*size as u64));
            group.bench_with_input(BenchmarkId::new("pk", size), &size, |b, &_| {
                b.iter(|| {
-                    create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+                    create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                        .unwrap();
                });
            });

-            let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+            let pk = create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                .unwrap();

            group.throughput(Throughput::Elements(*size as u64));
            group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {
                b.iter(|| {
-                    let prover = create_proof_circuit_kzg(
+                    let prover = create_proof_circuit::<
+                        KZGCommitmentScheme<_>,
+                        MyCircuit,
+                        ProverSHPLONK<_>,
+                        VerifierSHPLONK<_>,
+                        SingleStrategy<_>,
+                        _,
+                        EvmTranscript<_, _, _, _>,
+                        EvmTranscript<_, _, _, _>,
+                    >(
                        circuit.clone(),
+                        vec![],
                        &params,
-                        None,
                        &pk,
-                        TranscriptType::EVM,
-                        SingleStrategy::new(&params),
                        CheckMode::UNSAFE,
+                        ezkl::Commitments::KZG,
+                        TranscriptType::EVM,
+                        None,
                        None,
                    );
                    prover.unwrap();
--- a/benches/pairwise_add.rs
+++ b/benches/pairwise_add.rs
@@ -1,11 +1,13 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
+use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    arithmetic::Field,
@@ -14,6 +16,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;

 static mut LEN: usize = 4;
@@ -84,25 +87,35 @@ fn runadd(c: &mut Criterion) {
        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
            b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();

        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
            b.iter(|| {
-                let prover = create_proof_circuit_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
+                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
-                    CheckMode::SAFE,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/pairwise_pow.rs
+++ b/benches/pairwise_pow.rs
@@ -2,11 +2,13 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
+use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    arithmetic::Field,
@@ -15,6 +17,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;

 static mut LEN: usize = 4;
@@ -83,25 +86,35 @@ fn runpow(c: &mut Criterion) {
        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
            b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();

        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
            b.iter(|| {
-                let prover = create_proof_circuit_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
+                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
-                    CheckMode::SAFE,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/poseidon.rs
+++ b/benches/poseidon.rs
@@ -1,15 +1,18 @@
+use std::collections::HashMap;
+
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::modules::poseidon::spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH};
 use ezkl::circuit::modules::poseidon::{PoseidonChip, PoseidonConfig};
 use ezkl::circuit::modules::Module;
 use ezkl::circuit::*;
 use ezkl::pfsys::create_keys;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::srs::gen_srs;
 use ezkl::pfsys::TranscriptType;
 use ezkl::tensor::*;
 use halo2_proofs::circuit::Value;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    arithmetic::Field,
@@ -18,6 +21,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;

 const L: usize = 10;

@@ -46,7 +50,7 @@ impl Circuit<Fr> for MyCircuit {
    ) -> Result<(), Error> {
        let chip: PoseidonChip<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, L> =
            PoseidonChip::new(config);
-        chip.layout(&mut layouter, &[self.image.clone()], 0)?;
+        chip.layout(&mut layouter, &[self.image.clone()], 0, &mut HashMap::new())?;
        Ok(())
    }
 }
@@ -62,7 +66,7 @@ fn runposeidon(c: &mut Criterion) {
        let params = gen_srs::<KZGCommitmentScheme<_>>(k);

        let message = (0..*size).map(|_| Fr::random(OsRng)).collect::<Vec<_>>();
-        let output =
+        let _output =
            PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, L>::run(message.to_vec())
                .unwrap();

@@ -76,25 +80,35 @@ fn runposeidon(c: &mut Criterion) {
        group.throughput(Throughput::Elements(*size as u64));
        group.bench_with_input(BenchmarkId::new("pk", size), &size, |b, &_| {
            b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params).unwrap();
+            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();

        group.throughput(Throughput::Elements(*size as u64));
        group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {
            b.iter(|| {
-                let prover = create_proof_circuit_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    Some(output[0].clone()),
                    &pk,
-                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
+                    TranscriptType::EVM,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/relu.rs
+++ b/benches/relu.rs
@@ -1,11 +1,13 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::region::RegionCtx;
+use ezkl::circuit::table::Range;
 use ezkl::circuit::{ops::lookup::LookupOp, BaseConfig as Config, CheckMode};
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    circuit::{Layouter, SimpleFloorPlanner, Value},
@@ -13,8 +15,9 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::Rng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;

-const BITS: (i128, i128) = (-32768, 32768);
+const BITS: Range = (-32768, 32768);
 static mut LEN: usize = 4;
 const K: usize = 16;

@@ -90,25 +93,35 @@ fn runrelu(c: &mut Criterion) {
        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
            b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, NLCircuit>(&circuit, &params)
+                create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, Fr, NLCircuit>(&circuit, &params).unwrap();
+            create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, &params, true).unwrap();

        group.throughput(Throughput::Elements(len as u64));
        group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
            b.iter(|| {
-                let prover = create_proof_circuit_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    NLCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
+                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
-                    CheckMode::SAFE,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/examples/conv2d_mnist/main.rs
+++ b/examples/conv2d_mnist/main.rs
@@ -6,6 +6,7 @@ use ezkl::fieldutils;
 use ezkl::fieldutils::i32_to_felt;
 use ezkl::tensor::*;
 use halo2_proofs::dev::MockProver;
+use halo2_proofs::poly::commitment::Params;
 use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
 use halo2_proofs::{
    circuit::{Layouter, SimpleFloorPlanner, Value},
@@ -489,6 +490,7 @@ pub fn runconv() {
        strategy,
        pi_for_real_prover,
        &mut transcript,
+        params.n(),
    );
    assert!(verify.is_ok());

--- a/examples/notebooks/data_attest_hashed.ipynb
+++ b/examples/notebooks/data_attest_hashed.ipynb
@@ -309,7 +309,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "print(ezkl.vecu64_to_felt(res['processed_outputs']['poseidon_hash'][0]))"
+                "print(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]))"
            ]
        },
        {
@@ -325,7 +325,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "from web3 import Web3, HTTPProvider, utils\n",
+                "from web3 import Web3, HTTPProvider\n",
                "from solcx import compile_standard\n",
                "from decimal import Decimal\n",
                "import json\n",
@@ -338,7 +338,7 @@
                "\n",
                "def test_on_chain_data(res):\n",
                "    # Step 0: Convert the tensor to a flat list\n",
-                "    data = [int(ezkl.vecu64_to_felt(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
+                "    data = [int(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
                "\n",
                "    # Step 1: Prepare the data\n",
                "    # Step 2: Prepare and compile the contract.\n",
@@ -648,7 +648,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.9.13"
+            "version": "3.9.15"
        },
        "orig_nbformat": 4
    },
--- a/examples/notebooks/ezkl_demo.ipynb
+++ b/examples/notebooks/ezkl_demo.ipynb
@@ -695,17 +695,19 @@
        "formatted_output = \"[\"\n",
        "for i, value in enumerate(proof[\"instances\"]):\n",
        "    for j, field_element in enumerate(value):\n",
-        "        onchain_input_array.append(ezkl.vecu64_to_felt(field_element))\n",
-        "        formatted_output += str(onchain_input_array[-1])\n",
+        "        onchain_input_array.append(ezkl.felt_to_big_endian(field_element))\n",
+        "        formatted_output += '\"' + str(onchain_input_array[-1]) + '\"'\n",
        "        if j != len(value) - 1:\n",
        "            formatted_output += \", \"\n",
-        "    formatted_output += \"]\"\n",
+        "    if i != len(proof[\"instances\"]) - 1:\n",
+        "        formatted_output += \", \"\n",
+        "formatted_output += \"]\"\n",
        "\n",
        "# This will be the values you use onchain\n",
        "# copy them over to remix and see if they verify\n",
        "# What happens when you change a value?\n",
        "print(\"pubInputs: \", formatted_output)\n",
-        "print(\"proof: \", \"0x\" + proof[\"proof\"])"
+        "print(\"proof: \", proof[\"proof\"])"
      ]
    },
    {
--- a/examples/notebooks/generalized_inverse.ipynb
+++ b/examples/notebooks/generalized_inverse.ipynb
@@ -10,7 +10,7 @@
        "\n",
        "## Generalized Inverse\n",
        "\n",
-        "We show how to use EZKL to prove that we know matrices $A$ and its generalized inverse $B$. Since these are large we deal with the KZG commitments, with $a$ the kzgcommit of $A$, $b$ the kzgcommit of $B$, and $ABA = A$.\n"
+        "We show how to use EZKL to prove that we know matrices $A$ and its generalized inverse $B$. Since these are large we deal with the KZG commitments, with $a$ the polycommit of $A$, $b$ the polycommit of $B$, and $ABA = A$.\n"
      ]
    },
    {
@@ -77,7 +77,7 @@
      "outputs": [],
      "source": [
        "gip_run_args = ezkl.PyRunArgs()\n",
-        "gip_run_args.input_visibility = \"kzgcommit\"  # matrix and generalized inverse commitments\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)"
      ]
@@ -340,4 +340,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/hashed_vis.ipynb
+++ b/examples/notebooks/hashed_vis.ipynb
@@ -161,7 +161,7 @@
                "- `fixed`: known to the prover and verifier (as a commit), but not modifiable by the prover.\n",
                "- `hashed`: the hash pre-image is known to the prover, the prover and verifier know the hash. The prover proves that the they know the pre-image to the hash. \n",
                "- `encrypted`: the non-encrypted element and the secret key used for decryption are known to the prover. The prover and the verifier know the encrypted element, the public key used to encrypt, and the hash of the decryption hey. The prover proves that they know the pre-image of the hashed decryption key and that this key can in fact decrypt the encrypted message.\n",
-                "- `kzgcommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be inserted directly within the proof bytes.  \n",
+                "- `polycommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be inserted directly within the proof bytes.  \n",
                "\n",
                "\n",
                "Here we create the following setup:\n",
@@ -510,4 +510,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 2
-}
+}
--- a/examples/notebooks/keras_simple_demo.ipynb
+++ b/examples/notebooks/keras_simple_demo.ipynb
@@ -67,6 +67,7 @@
                "model.add(Dense(128, activation='relu'))\n",
                "model.add(Dropout(0.5))\n",
                "model.add(Dense(10, activation='softmax'))\n",
+                "model.output_names=['output']\n",
                "\n",
                "\n",
                "# Train the model as you like here (skipped for brevity)\n",
--- a/examples/notebooks/kzg_vis.ipynb
+++ b/examples/notebooks/kzg_vis.ipynb
@@ -154,11 +154,11 @@
                "- `fixed`: known to the prover and verifier (as a commit), but not modifiable by the prover.\n",
                "- `hashed`: the hash pre-image is known to the prover, the prover and verifier know the hash. The prover proves that the they know the pre-image to the hash. \n",
                "- `encrypted`: the non-encrypted element and the secret key used for decryption are known to the prover. The prover and the verifier know the encrypted element, the public key used to encrypt, and the hash of the decryption hey. The prover proves that they know the pre-image of the hashed decryption key and that this key can in fact decrypt the encrypted message.\n",
-                "- `kzgcommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes.  \n",
+                "- `polycommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes.  \n",
                "\n",
                "Here we create the following setup:\n",
-                "- `input_visibility`: \"kzgcommit\"\n",
-                "- `param_visibility`: \"kzgcommit\"\n",
+                "- `input_visibility`: \"polycommit\"\n",
+                "- `param_visibility`: \"polycommit\"\n",
                "- `output_visibility`: public\n",
                "\n",
                "We encourage you to play around with other setups :) \n",
@@ -186,8 +186,8 @@
                "data_path = os.path.join('input.json')\n",
                "\n",
                "run_args = ezkl.PyRunArgs()\n",
-                "run_args.input_visibility = \"kzgcommit\"\n",
-                "run_args.param_visibility = \"kzgcommit\"\n",
+                "run_args.input_visibility = \"polycommit\"\n",
+                "run_args.param_visibility = \"polycommit\"\n",
                "run_args.output_visibility = \"public\"\n",
                "run_args.variables = [(\"batch_size\", 1)]\n",
                "\n",
@@ -512,4 +512,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 2
-}
+}
--- a/examples/notebooks/mnist_gan.ipynb
+++ b/examples/notebooks/mnist_gan.ipynb
@@ -38,7 +38,7 @@
                "import logging\n",
                "\n",
                "import tensorflow as tf\n",
-                "from tensorflow.keras.optimizers.legacy import Adam\n",
+                "from tensorflow.keras.optimizers import Adam\n",
                "from tensorflow.keras.layers import *\n",
                "from tensorflow.keras.models import Model\n",
                "from tensorflow.keras.datasets import mnist\n",
@@ -71,9 +71,11 @@
            },
            "outputs": [],
            "source": [
-                "opt = Adam()\n",
                "ZDIM = 100\n",
                "\n",
+                "opt = Adam()\n",
+                "\n",
+                "\n",
                "# discriminator\n",
                "# 0 if it's fake, 1 if it's real\n",
                "x = in1 = Input((28,28))\n",
@@ -114,8 +116,11 @@
                "\n",
                "gm = Model(in1, x)\n",
                "gm.compile('adam', 'mse')\n",
+                "gm.output_names=['output']\n",
                "gm.summary()\n",
                "\n",
+                "opt = Adam()\n",
+                "\n",
                "# GAN\n",
                "dm.trainable = False\n",
                "x = dm(gm.output)\n",
@@ -415,7 +420,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.2"
        }
    },
    "nbformat": 4,
--- a/examples/notebooks/mnist_gan_proof_splitting.ipynb
+++ b/examples/notebooks/mnist_gan_proof_splitting.ipynb
--- a/examples/notebooks/mnist_vae.ipynb
+++ b/examples/notebooks/mnist_vae.ipynb
@@ -349,6 +349,8 @@
                "z_log_var = Dense(ZDIM)(x)\n",
                "z = Lambda(lambda x: x[0] + K.exp(0.5 * x[1]) * K.random_normal(shape=K.shape(x[0])))([z_mu, z_log_var])\n",
                "dec = get_decoder()\n",
+                "dec.output_names=['output']\n",
+                "\n",
                "out = dec(z)\n",
                "\n",
                "mse_loss = mse(Reshape((28*28,))(in1), Reshape((28*28,))(out)) * 28 * 28\n",
--- a/examples/notebooks/proof_aggr.json
+++ b/examples/notebooks/proof_aggr.json
--- a/examples/notebooks/proof_splitting.ipynb
+++ b/examples/notebooks/proof_splitting.ipynb
@@ -208,7 +208,7 @@
                "- `private`: known only to the prover\n",
                "- `hashed`: the hash pre-image is known to the prover, the prover and verifier know the hash. The prover proves that the they know the pre-image to the hash. \n",
                "- `encrypted`: the non-encrypted element and the secret key used for decryption are known to the prover. The prover and the verifier know the encrypted element, the public key used to encrypt, and the hash of the decryption hey. The prover proves that they know the pre-image of the hashed decryption key and that this key can in fact decrypt the encrypted message.\n",
-                "- `kzgcommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes.  \n",
+                "- `polycommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes.  \n",
                "\n",
                "Here we create the following setup:\n",
                "- `input_visibility`: \"public\"\n",
@@ -234,7 +234,7 @@
                "run_args.input_scale = 2\n",
                "run_args.logrows = 8\n",
                "\n",
-                "ezkl.get_srs(logrows=run_args.logrows)"
+                "ezkl.get_srs(logrows=run_args.logrows, commitment=ezkl.PyCommitments.KZG)"
            ]
        },
        {
@@ -302,7 +302,7 @@
                "    assert res == True\n",
                "    assert os.path.isfile(vk_path)\n",
                "    assert os.path.isfile(pk_path)\n",
-                "    \n",
+                "\n",
                "    res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
                "    run_args.input_scale = settings[\"model_output_scales\"][0]\n",
                "\n",
@@ -330,14 +330,14 @@
                "            compiled_model_path,\n",
                "            pk_path,\n",
                "            proof_path,\n",
-                "            \n",
                "            \"for-aggr\",\n",
                "        )\n",
                "\n",
                "    print(res)\n",
+                "    res_1_proof = res[\"proof\"]\n",
                "    assert os.path.isfile(proof_path)\n",
                "\n",
-                "    # Verify the proof\n",
+                "    # # Verify the proof\n",
                "    if i > 0:\n",
                "        print(\"swapping commitments\")\n",
                "        # swap the proof commitments if we are not the first model\n",
@@ -356,12 +356,19 @@
                "\n",
                "        res = ezkl.swap_proof_commitments(proof_path, witness_path)\n",
                "        print(res)\n",
+                "        \n",
+                "        # load proof and then print \n",
+                "        proof = json.load(open(proof_path, 'r'))\n",
+                "        res_2_proof = proof[\"hex_proof\"]\n",
+                "        # show diff in hex strings\n",
+                "        print(res_1_proof)\n",
+                "        print(res_2_proof)\n",
+                "        assert res_1_proof == res_2_proof\n",
                "\n",
                "    res = ezkl.verify(\n",
                "            proof_path,\n",
                "            settings_path,\n",
                "            vk_path,\n",
-                "            \n",
                "        )\n",
                "\n",
                "    assert res == True\n",
@@ -378,9 +385,9 @@
                "###  KZG commitment intermediate calculations\n",
                "\n",
                "This time the visibility parameters are:\n",
-                "- `input_visibility`: \"kzgcommit\"\n",
+                "- `input_visibility`: \"polycommit\"\n",
                "- `param_visibility`: \"public\"\n",
-                "- `output_visibility`: kzgcommit"
+                "- `output_visibility`: polycommit"
            ]
        },
        {
@@ -392,9 +399,9 @@
                "import ezkl\n",
                "\n",
                "run_args = ezkl.PyRunArgs()\n",
-                "run_args.input_visibility = \"kzgcommit\"\n",
+                "run_args.input_visibility = \"polycommit\"\n",
                "run_args.param_visibility = \"fixed\"\n",
-                "run_args.output_visibility = \"kzgcommit\"\n",
+                "run_args.output_visibility = \"polycommit\"\n",
                "run_args.variables = [(\"batch_size\", 1)]\n",
                "run_args.input_scale = 2\n",
                "run_args.logrows = 8\n"
@@ -439,7 +446,7 @@
                "    proof_path = os.path.join('proof_split_'+str(i)+'.json')\n",
                "    proofs.append(proof_path)\n",
                "\n",
-                "ezkl.mock_aggregate(proofs, logrows=23, split_proofs = True)"
+                "ezkl.mock_aggregate(proofs, logrows=22, split_proofs = True)"
            ]
        }
    ],
--- a/examples/notebooks/random_forest.ipynb
+++ b/examples/notebooks/random_forest.ipynb
@@ -61,11 +61,10 @@
                "from sklearn.datasets import load_iris\n",
                "from sklearn.model_selection import train_test_split\n",
                "from sklearn.ensemble import RandomForestClassifier as Rf\n",
-                "import sk2torch\n",
                "import torch\n",
                "import ezkl\n",
                "import os\n",
-                "from torch import nn\n",
+                "from hummingbird.ml import convert\n",
                "\n",
                "\n",
                "\n",
@@ -77,28 +76,12 @@
                "clr.fit(X_train, y_train)\n",
                "\n",
                "\n",
-                "trees = []\n",
-                "for tree in clr.estimators_:\n",
-                "    trees.append(sk2torch.wrap(tree))\n",
                "\n",
-                "\n",
-                "class RandomForest(nn.Module):\n",
-                "    def __init__(self, trees):\n",
-                "        super(RandomForest, self).__init__()\n",
-                "        self.trees = nn.ModuleList(trees)\n",
-                "\n",
-                "    def forward(self, x):\n",
-                "        out = self.trees[0](x)\n",
-                "        for tree in self.trees[1:]:\n",
-                "            out += tree(x)\n",
-                "        return out / len(self.trees)\n",
-                "\n",
-                "\n",
-                "torch_rf = RandomForest(trees)\n",
+                "torch_rf = convert(clr, 'torch')\n",
                "# assert predictions from torch are = to sklearn \n",
                "diffs = []\n",
                "for i in range(len(X_test)):\n",
-                "    torch_pred = torch_rf(torch.tensor(X_test[i].reshape(1, -1)))\n",
+                "    torch_pred = torch_rf.predict(torch.tensor(X_test[i].reshape(1, -1)))\n",
                "    sk_pred = clr.predict(X_test[i].reshape(1, -1))\n",
                "    diffs.append(torch_pred[0].round() - sk_pred[0])\n",
                "\n",
@@ -134,14 +117,12 @@
                "\n",
                "# export to onnx format\n",
                "\n",
-                "torch_rf.eval()\n",
-                "\n",
                "# Input to the model\n",
                "shape = X_train.shape[1:]\n",
                "x = torch.rand(1, *shape, requires_grad=False)\n",
-                "torch_out = torch_rf(x)\n",
+                "torch_out = torch_rf.predict(x)\n",
                "# Export the model\n",
-                "torch.onnx.export(torch_rf,               # model being run\n",
+                "torch.onnx.export(torch_rf.model,               # model being run\n",
                "                  # model input (or a tuple for multiple inputs)\n",
                "                  x,\n",
                "                  # where to save the model (can be a file or file-like object)\n",
@@ -158,7 +139,7 @@
                "\n",
                "data = dict(input_shapes=[shape],\n",
                "            input_data=[d],\n",
-                "            output_data=[((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])\n",
+                "            output_data=[o.reshape([-1]).tolist() for o in torch_out])\n",
                "\n",
                "# Serialize data into file:\n",
                "json.dump(data, open(\"input.json\", 'w'))\n"
@@ -321,7 +302,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.2"
        }
    },
    "nbformat": 4,
--- a/examples/notebooks/set_membership.ipynb
+++ b/examples/notebooks/set_membership.ipynb
@@ -78,7 +78,7 @@
        "pk_path = os.path.join('test.pk')\n",
        "vk_path = os.path.join('test.vk')\n",
        "settings_path = os.path.join('settings.json')\n",
-        "",
+        "\n",
        "witness_path = os.path.join('witness.json')\n",
        "data_path = os.path.join('input.json')"
      ]
@@ -122,8 +122,8 @@
        "# Loop through each element in the y tensor\n",
        "for e in y_input:\n",
        "    # Apply the custom function and append the result to the list\n",
-        "    print(ezkl.float_to_vecu64(e,7))\n",
-        "    result.append(ezkl.poseidon_hash([ezkl.float_to_vecu64(e, 7)])[0])\n",
+        "    print(ezkl.float_to_felt(e,7))\n",
+        "    result.append(ezkl.poseidon_hash([ezkl.float_to_felt(e, 7)])[0])\n",
        "\n",
        "y = y.unsqueeze(0)\n",
        "y = y.reshape(1, 9)\n",
@@ -343,7 +343,7 @@
        "# we force the output to be 0 this corresponds to the set membership test being true -- and we set this to a fixed vis output\n",
        "# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
        "witness = json.load(open(witness_path, \"r\"))\n",
-        "witness[\"outputs\"][0] = [[0, 0, 0, 0]]\n",
+        "witness[\"outputs\"][0] = [\"0000000000000000000000000000000000000000000000000000000000000000\"]\n",
        "json.dump(witness, open(witness_path, \"w\"))\n",
        "\n",
        "witness = json.load(open(witness_path, \"r\"))\n",
@@ -353,7 +353,6 @@
        "        compiled_model_path,\n",
        "        vk_path,\n",
        "        pk_path,\n",
-        "        \n",
        "        witness_path = witness_path,\n",
        "    )\n",
        "\n",
@@ -520,4 +519,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/simple_demo_aggregated_proofs.ipynb
+++ b/examples/notebooks/simple_demo_aggregated_proofs.ipynb
@@ -275,7 +275,6 @@
                "        proof_path,\n",
                "        settings_path,\n",
                "        vk_path,\n",
-                "        \n",
                "    )\n",
                "\n",
                "assert res == True\n",
@@ -291,7 +290,7 @@
            "source": [
                "# Generate a larger SRS. This is needed for the aggregated proof\n",
                "\n",
-                "res = ezkl.get_srs(settings_path=None, logrows=21)"
+                "res = ezkl.get_srs(settings_path=None, logrows=21, commitment=ezkl.PyCommitments.KZG)"
            ]
        },
        {
--- a/examples/notebooks/simple_demo_public_network_output.ipynb
+++ b/examples/notebooks/simple_demo_public_network_output.ipynb
@@ -210,7 +210,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 9,
            "id": "b1c561a8",
            "metadata": {},
            "outputs": [],
--- a/examples/notebooks/solvency.ipynb
+++ b/examples/notebooks/solvency.ipynb
@@ -9,7 +9,7 @@
      "source": [
        "## Solvency demo\n",
        "\n",
-        "Here we create a demo of a solvency calculation in the manner of [summa-solvency](https://github.com/summa-dev/summa-solvency). The aim here is to demonstrate the use of the new kzgcommit method detailed [here](https://blog.ezkl.xyz/post/commits/). \n",
+        "Here we create a demo of a solvency calculation in the manner of [summa-solvency](https://github.com/summa-dev/summa-solvency). The aim here is to demonstrate the use of the new polycommit method detailed [here](https://blog.ezkl.xyz/post/commits/). \n",
        "\n",
        "In this setup:\n",
        "- the commitments to users, respective balances, and total balance are known are publicly known to the prover and verifier. \n",
@@ -126,7 +126,7 @@
        "# Loop through each element in the y tensor\n",
        "for e in user_preimages:\n",
        "    # Apply the custom function and append the result to the list\n",
-        "    users.append(ezkl.poseidon_hash([ezkl.float_to_vecu64(e, 0)])[0])\n",
+        "    users.append(ezkl.poseidon_hash([ezkl.float_to_felt(e, 0)])[0])\n",
        "\n",
        "users_t = torch.tensor(user_preimages)\n",
        "users_t = users_t.reshape(1, 6)\n",
@@ -177,10 +177,10 @@
        "- `private`: known only to the prover\n",
        "- `hashed`: the hash pre-image is known to the prover, the prover and verifier know the hash. The prover proves that the they know the pre-image to the hash. \n",
        "- `encrypted`: the non-encrypted element and the secret key used for decryption are known to the prover. The prover and the verifier know the encrypted element, the public key used to encrypt, and the hash of the decryption hey. The prover proves that they know the pre-image of the hashed decryption key and that this key can in fact decrypt the encrypted message.\n",
-        "- `kzgcommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes.  \n",
+        "- `polycommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes.  \n",
        "\n",
        "Here we create the following setup:\n",
-        "- `input_visibility`: \"kzgcommit\"\n",
+        "- `input_visibility`: \"polycommit\"\n",
        "- `param_visibility`: \"public\"\n",
        "- `output_visibility`: public\n",
        "\n",
@@ -202,8 +202,8 @@
      "outputs": [],
      "source": [
        "run_args = ezkl.PyRunArgs()\n",
-        "# \"kzgcommit\" 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 = \"kzgcommit\"\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",
        "# the parameters are public\n",
        "run_args.param_visibility = \"fixed\"\n",
        "# the output is public (this is the inequality test)\n",
@@ -303,7 +303,7 @@
        "# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
        "# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
        "witness = json.load(open(witness_path, \"r\"))\n",
-        "witness[\"outputs\"][0] = [ezkl.float_to_vecu64(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_felt(1.0, 0)]\n",
        "json.dump(witness, open(witness_path, \"w\"))"
      ]
    },
@@ -417,7 +417,7 @@
        "# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
        "# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
        "witness = json.load(open(witness_path, \"r\"))\n",
-        "witness[\"outputs\"][0] = [ezkl.float_to_vecu64(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_felt(1.0, 0)]\n",
        "json.dump(witness, open(witness_path, \"w\"))\n"
      ]
    },
@@ -510,9 +510,9 @@
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
-      "version": "3.9.13"
+      "version": "3.9.15"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/tictactoe_autoencoder.ipynb
+++ b/examples/notebooks/tictactoe_autoencoder.ipynb
@@ -13,7 +13,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -57,7 +57,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 2,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -119,7 +119,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 3,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -163,7 +163,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 4,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -217,7 +217,7 @@
        },
        {
            "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 6,
            "metadata": {},
            "outputs": [],
            "source": [
@@ -227,6 +227,10 @@
                "        self.length = self.compute_length(self.file_good)\n",
                "        self.data = self.load_data(self.file_good)\n",
                "\n",
+                "    def __iter__(self):\n",
+                "        for i in range(len(self.data)):\n",
+                "            yield self.data[i]\n",
+                "\n",
                "    def parse_json_object(self, line):\n",
                "        try:\n",
                "            return json.loads(line)\n",
@@ -633,7 +637,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [11])"
            ]
        },
        {
@@ -664,7 +668,6 @@
                "    compiled_model_path,\n",
                "    vk_path,\n",
                "    pk_path,\n",
-                "    \n",
                ")"
            ]
        },
@@ -750,7 +753,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.2"
        }
    },
    "nbformat": 4,
--- a/examples/notebooks/tictactoe_binary_classification.ipynb
+++ b/examples/notebooks/tictactoe_binary_classification.ipynb
@@ -209,6 +209,11 @@
                "        self.length = self.compute_length(self.file_good, self.file_bad)\n",
                "        self.data = self.load_data(self.file_good, self.file_bad)\n",
                "\n",
+                "    def __iter__(self):\n",
+                "        for i in range(len(self.data)):\n",
+                "            yield self.data[i]\n",
+                "\n",
+                "\n",
                "    def parse_json_object(self, line):\n",
                "        try:\n",
                "            return json.loads(line)\n",
@@ -520,7 +525,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [4])"
            ]
        },
        {
@@ -636,7 +641,8 @@
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3"
+            "pygments_lexer": "ipython3",
+            "version": "3.12.2"
        }
    },
    "nbformat": 4,
--- a/examples/notebooks/voice_judge.ipynb
+++ b/examples/notebooks/voice_judge.ipynb
@@ -25,17 +25,9 @@
        },
        {
            "cell_type": "code",
-            "execution_count": 1,
+            "execution_count": null,
            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "voice_data_dir:  .\n"
-                    ]
-                }
-            ],
+            "outputs": [],
            "source": [
                "\n",
                "import os\n",
@@ -43,7 +35,7 @@
                "\n",
                "voice_data_dir = os.environ.get('VOICE_DATA_DIR')\n",
                "\n",
-                "#  if is none set to \"\" \n",
+                "#  if is none set to \"\"\n",
                "if voice_data_dir is None:\n",
                "    voice_data_dir = \"\"\n",
                "\n",
@@ -637,7 +629,7 @@
            "source": [
                "\n",
                "\n",
-                "res = ezkl.calibrate_settings(val_data, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(val_data, model_path, settings_path, \"resources\", scales = [4])\n",
                "assert res == True\n",
                "print(\"verified\")\n"
            ]
@@ -908,7 +900,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.9.13"
+            "version": "3.9.15"
        }
    },
    "nbformat": 4,
--- a/examples/notebooks/world_rotation.ipynb
+++ b/examples/notebooks/world_rotation.ipynb
@@ -503,11 +503,11 @@
    "pyplot.arrow(0, 0, 1, 0, width=0.02, alpha=0.5)\n",
    "pyplot.arrow(0, 0, 0, 1, width=0.02, alpha=0.5)\n",
    "\n",
-    "arrow_x = ezkl.vecu64_to_float(witness['outputs'][0][0], out_scale)\n",
-    "arrow_y = ezkl.vecu64_to_float(witness['outputs'][0][1], out_scale)\n",
+    "arrow_x = ezkl.felt_to_float(witness['outputs'][0][0], out_scale)\n",
+    "arrow_y = ezkl.felt_to_float(witness['outputs'][0][1], out_scale)\n",
    "pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)\n",
-    "arrow_x = ezkl.vecu64_to_float(witness['outputs'][0][2], out_scale)\n",
-    "arrow_y = ezkl.vecu64_to_float(witness['outputs'][0][3], out_scale)\n",
+    "arrow_x = ezkl.felt_to_float(witness['outputs'][0][2], out_scale)\n",
+    "arrow_y = ezkl.felt_to_float(witness['outputs'][0][3], out_scale)\n",
    "pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)"
   ]
  }
--- a/examples/onnx/1l_lppool/gen.py
+++ b/examples/onnx/1l_lppool/gen.py
@@ -0,0 +1,40 @@
+from torch import nn
+import torch
+import json
+
+class Model(nn.Module):
+    def __init__(self):
+        super(Model, self).__init__()
+        self.layer = nn.LPPool2d(2, 1, (1, 1))
+
+    def forward(self, x):
+        return self.layer(x)[0]
+
+
+circuit = Model()
+
+x = torch.empty(1, 3, 2, 2).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
+
--- a/examples/onnx/1l_lppool/input.json
+++ b/examples/onnx/1l_lppool/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.7549541592597961, 0.990360677242279, 0.9473411440849304, 0.3951031565666199, 0.8500555753707886, 0.9352139830589294, 0.11867779493331909, 0.9493132829666138, 0.6588345766067505, 0.1933223009109497, 0.12139874696731567, 0.8547163605690002]]}
--- a/examples/onnx/1l_lppool/network.onnx
+++ b/examples/onnx/1l_lppool/network.onnx
--- a/examples/onnx/1l_tiny_div/gen.py
+++ b/examples/onnx/1l_tiny_div/gen.py
@@ -0,0 +1,39 @@
+from torch import nn
+import torch
+import json
+
+class Circuit(nn.Module):
+    def __init__(self, inplace=False):
+        super(Circuit, self).__init__()
+
+    def forward(self, x):
+        return x/ 10000
+
+
+circuit = Circuit()
+
+
+x = torch.empty(1, 8).random_(0, 2)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/1l_tiny_div/input.json
+++ b/examples/onnx/1l_tiny_div/input.json
@@ -0,0 +1 @@
+{"input_data": [[1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0]]}
--- a/examples/onnx/1l_tiny_div/network.onnx
+++ b/examples/onnx/1l_tiny_div/network.onnx
--- a/examples/onnx/celu/gen.py
+++ b/examples/onnx/celu/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = nn.CELU()(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/celu/input.json
+++ b/examples/onnx/celu/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.35387128591537476, 0.030473172664642334, 0.08707714080810547, 0.2429301142692566, 0.45228832960128784, 0.496021032333374, 0.13245105743408203, 0.8497090339660645]]}
--- a/examples/onnx/celu/network.onnx
+++ b/examples/onnx/celu/network.onnx
--- a/examples/onnx/clip/gen.py
+++ b/examples/onnx/clip/gen.py
@@ -0,0 +1,41 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.clamp(x, min=0.4, max=0.8)
+        return m
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 2, 2, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/clip/input.json
+++ b/examples/onnx/clip/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.03297048807144165, 0.46362626552581787, 0.6044231057167053, 0.4949902892112732, 0.48823297023773193, 0.6798646450042725, 0.6824942231178284, 0.03491640090942383, 0.19608813524246216, 0.24129939079284668, 0.9769315123558044, 0.6306831240653992, 0.7690497636795044, 0.252221941947937, 0.9167693853378296, 0.3882681131362915, 0.9307044148445129, 0.33559417724609375, 0.7815426588058472, 0.3435332179069519, 0.7871478796005249, 0.12240773439407349, 0.5295405983924866, 0.4874419569969177, 0.08262640237808228, 0.1124718189239502, 0.5834914445877075, 0.30927878618240356, 0.48899340629577637, 0.9376634955406189, 0.21893149614334106, 0.526070773601532]]}
--- a/examples/onnx/clip/network.onnx
+++ b/examples/onnx/clip/network.onnx
@@ -0,0 +1,24 @@
+pytorch2.2.1:±
+?/Constant_output_0	/Constant"Constant*
+value*JÍÌÌ> 
+C/Constant_1_output_0/Constant_1"Constant*
+value*JÍÌL? 
+F
+input
+/Constant_output_0
+/Constant_1_output_0output/Clip"Clip
+main_graphZ)
+input 
+
+
+batch_size
+
+
+b*
+output 
+
+
+batch_size
+
+
+B
--- a/examples/onnx/gather_nd/gen.py
+++ b/examples/onnx/gather_nd/gen.py
@@ -0,0 +1,48 @@
+from torch import nn
+import json
+import numpy as np
+import tf2onnx
+
+
+import tensorflow as tf
+from tensorflow.keras.layers import *
+from tensorflow.keras.models import Model
+
+
+# gather_nd in tf then export to onnx
+
+
+
+
+x = in1 = Input((15, 18,))
+w = in2 = Input((15, 1), dtype=tf.int32)
+x = tf.gather_nd(x, w, batch_dims=1)
+tm = Model((in1, in2), x )
+tm.summary()
+tm.compile(optimizer='adam', loss='mse')
+
+shape = [1, 15, 18]
+index_shape = [1, 15, 1]
+# After training, export to onnx (network.onnx) and create a data file (input.json)
+x = 0.1*np.random.rand(1,*shape)
+# w = random int tensor
+w = np.random.randint(0, 10, index_shape)
+
+spec = tf.TensorSpec(shape, tf.float32, name='input_0')
+index_spec = tf.TensorSpec(index_shape, tf.int32, name='input_1')
+
+model_path = "network.onnx"
+
+tf2onnx.convert.from_keras(tm, input_signature=[spec, index_spec], inputs_as_nchw=['input_0', 'input_1'], opset=12, output_path=model_path)
+
+
+d = x.reshape([-1]).tolist()
+d1 = w.reshape([-1]).tolist()
+
+
+data = dict(
+    input_data=[d, d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/gather_nd/input.json
+++ b/examples/onnx/gather_nd/input.json
--- a/examples/onnx/gather_nd/network.onnx
+++ b/examples/onnx/gather_nd/network.onnx
--- a/examples/onnx/gru/gen.py
+++ b/examples/onnx/gru/gen.py
@@ -0,0 +1,41 @@
+import random
+import math
+import numpy as np
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+import json
+
+
+model = nn.GRU(3, 3)  # Input dim is 3, output dim is 3
+x = torch.randn(1, 3)  # make a sequence of length 5
+
+print(x)
+
+# Flips the neural net into inference mode
+model.eval()
+model.to('cpu')
+
+# Export the model
+torch.onnx.export(model,               # model being run
+                  # model input (or a tuple for multiple inputs)
+                  x,
+                  # where to save the model (can be a file or file-like object)
+                  "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=10,          # 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'}})
+
+data_array = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data_json = dict(input_data=[data_array])
+
+print(data_json)
+
+# Serialize data into file:
+json.dump(data_json, open("input.json", 'w'))
--- a/examples/onnx/gru/input.json
+++ b/examples/onnx/gru/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.4145222008228302, -0.4043896496295929, 0.7545749545097351]]}
--- a/examples/onnx/gru/network.onnx
+++ b/examples/onnx/gru/network.onnx
--- a/examples/onnx/hard_max/gen.py
+++ b/examples/onnx/hard_max/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.argmax(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/hard_max/input.json
+++ b/examples/onnx/hard_max/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.5505883693695068, 0.0766521692276001, 0.12006187438964844, 0.9497959017753601, 0.9100563526153564, 0.968717098236084, 0.5978299379348755, 0.9419963359832764]]}
--- a/examples/onnx/hard_max/network.onnx
+++ b/examples/onnx/hard_max/network.onnx
--- a/examples/onnx/hard_sigmoid/gen.py
+++ b/examples/onnx/hard_sigmoid/gen.py
@@ -9,7 +9,7 @@ class MyModel(nn.Module):
        super(MyModel, self).__init__()

    def forward(self, x):          
-        m = nn.Logsoftmax()(x)
+        m = nn.Hardsigmoid()(x)
        
        return m 

--- a/examples/onnx/hard_sigmoid/input.json
+++ b/examples/onnx/hard_sigmoid/input.json
@@ -1 +1 @@
-{"input_data": [[0.2971532940864563, 0.3465197682380676, 0.05381882190704346, 0.058654189109802246, 0.014198064804077148, 0.06088751554489136, 0.1723427176475525, 0.5115123987197876]]}
+{"input_data": [[0.8326942324638367, 0.2796096205711365, 0.600328266620636, 0.3701696991920471, 0.17832040786743164, 0.6247223019599915, 0.501872718334198, 0.6961578726768494]]}
--- a/examples/onnx/hard_sigmoid/network.onnx
+++ b/examples/onnx/hard_sigmoid/network.onnx
@@ -1,4 +1,4 @@
-pytorch2.1.0:<3A>
+pytorch2.2.1:<3A>
 ;
 inputoutput/HardSigmoid"HardSigmoid*
 alpha«ª*> 
--- a/examples/onnx/hard_swish/gen.py
+++ b/examples/onnx/hard_swish/gen.py
@@ -0,0 +1,41 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):
+        m = nn.Hardswish()(x)
+        return m
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/hard_swish/input.json
+++ b/examples/onnx/hard_swish/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.6996762752532959, 0.42992985248565674, 0.5102168321609497, 0.5540387630462646, 0.8489438891410828, 0.8533616065979004, 0.36736780405044556, 0.5859147310256958]]}
--- a/examples/onnx/hard_swish/network.onnx
+++ b/examples/onnx/hard_swish/network.onnx
@@ -0,0 +1,15 @@
+pytorch2.2.1:{
+&
+inputoutput
+/HardSwish"	HardSwish
+main_graphZ!
+input
+
+
+batch_size
+b"
+output
+
+
+batch_size
+B
--- a/examples/onnx/log_softmax/gen.py
+++ b/examples/onnx/log_softmax/gen.py
@@ -9,7 +9,7 @@ class MyModel(nn.Module):
        super(MyModel, self).__init__()

    def forward(self, x):          
-        m = nn.Hardsigmoid()(x)
+        m = nn.LogSoftmax()(x)
        
        return m 

--- a/examples/onnx/logsumexp/gen.py
+++ b/examples/onnx/logsumexp/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.logsumexp(x, dim=1)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 2, 2, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/logsumexp/input.json
+++ b/examples/onnx/logsumexp/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.7973018884658813, 0.5245689153671265, 0.34149593114852905, 0.1455438733100891, 0.9482707381248474, 0.4221445322036743, 0.001363217830657959, 0.8736765384674072, 0.42954301834106445, 0.7199509739875793, 0.37641745805740356, 0.5920265316963196, 0.42270803451538086, 0.41761744022369385, 0.603948712348938, 0.7250819802284241, 0.047173500061035156, 0.5115441679954529, 0.3743387460708618, 0.16794061660766602, 0.5352339148521423, 0.037976861000061035, 0.65323406457901, 0.5585184097290039, 0.10559147596359253, 0.07827490568161011, 0.6717077493667603, 0.6480781435966492, 0.9780838489532471, 0.8353415131568909, 0.6491701006889343, 0.6573048233985901]]}
--- a/examples/onnx/logsumexp/network.onnx
+++ b/examples/onnx/logsumexp/network.onnx
--- a/examples/onnx/mish/gen.py
+++ b/examples/onnx/mish/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = nn.Mish()(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/mish/input.json
+++ b/examples/onnx/mish/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.18563222885131836, 0.4843214750289917, 0.9991059899330139, 0.02534431219100952, 0.8105666041374207, 0.9658406376838684, 0.681107759475708, 0.5365872979164124]]}
--- a/examples/onnx/mish/network.onnx
+++ b/examples/onnx/mish/network.onnx
@@ -0,0 +1,19 @@
+pytorch2.2.1:ä
+0
+input/Softplus_output_0	/Softplus"Softplus
+1
+/Softplus_output_0/Tanh_output_0/Tanh"Tanh
+*
+input
+/Tanh_output_0output/Mul"Mul
+main_graphZ!
+input
+
+
+batch_size
+b"
+output
+
+
+batch_size
+B
--- a/examples/onnx/reducel1/gen.py
+++ b/examples/onnx/reducel1/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.norm(x, p=1, dim=1)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 2, 2, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/reducel1/input.json
+++ b/examples/onnx/reducel1/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.02284395694732666, 0.7941043376922607, 0.07971876859664917, 0.8898420929908752, 0.8233054280281067, 0.11066079139709473, 0.4424799084663391, 0.4355071783065796, 0.6723723411560059, 0.6818525195121765, 0.8726171851158142, 0.17742449045181274, 0.054257750511169434, 0.5775953531265259, 0.7758923172950745, 0.8431423306465149, 0.7602444887161255, 0.29686522483825684, 0.22489851713180542, 0.0675363540649414, 0.981339693069458, 0.15771394968032837, 0.5801441669464111, 0.9044001698493958, 0.49266451597213745, 0.42621421813964844, 0.35345613956451416, 0.042848050594329834, 0.6908614039421082, 0.5422852039337158, 0.01975083351135254, 0.5772860050201416]]}
--- a/examples/onnx/reducel1/network.onnx
+++ b/examples/onnx/reducel1/network.onnx
--- a/examples/onnx/reducel2/gen.py
+++ b/examples/onnx/reducel2/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.norm(x, p=2, dim=1)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 2, 2, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/reducel2/input.json
+++ b/examples/onnx/reducel2/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.8709188103675842, 0.11553549766540527, 0.27376580238342285, 0.7518517971038818, 0.7879393100738525, 0.8765475749969482, 0.14315760135650635, 0.8982420563697815, 0.7274006605148315, 0.39007169008255005, 0.729040801525116, 0.11306107044219971, 0.658822774887085, 0.666404664516449, 0.3001367449760437, 0.45343858003616333, 0.7460223436355591, 0.7423691749572754, 0.7544230818748474, 0.5674425959587097, 0.8728761672973633, 0.27062875032424927, 0.1595977544784546, 0.22975260019302368, 0.6711723208427429, 0.8265992403030396, 0.48679041862487793, 0.689740777015686, 0.330846905708313, 0.5630669593811035, 0.8058932423591614, 0.5802426338195801]]}
--- a/examples/onnx/reducel2/network.onnx
+++ b/examples/onnx/reducel2/network.onnx
--- a/examples/onnx/scatter_nd/gen.py
+++ b/examples/onnx/scatter_nd/gen.py
@@ -0,0 +1,76 @@
+import torch
+import torch.nn as nn
+import sys
+import json
+
+sys.path.append("..")
+
+class Model(nn.Module):
+    """
+    Just one Linear layer
+    """
+    def __init__(self, configs):
+        super(Model, self).__init__()
+        self.seq_len = configs.seq_len
+        self.pred_len = configs.pred_len
+
+        # Use this line if you want to visualize the weights
+        # self.Linear.weight = nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len,self.seq_len]))
+        self.channels = configs.enc_in
+        self.individual = configs.individual
+        if self.individual:
+            self.Linear = nn.ModuleList()
+            for i in range(self.channels):
+                self.Linear.append(nn.Linear(self.seq_len,self.pred_len))
+        else:
+            self.Linear = nn.Linear(self.seq_len, self.pred_len)
+
+    def forward(self, x):
+        # x: [Batch, Input length, Channel]
+        if self.individual:
+            output = torch.zeros([x.size(0),self.pred_len,x.size(2)],dtype=x.dtype).to(x.device)
+            for i in range(self.channels):
+                output[:,:,i] = self.Linear[i](x[:,:,i])
+            x = output
+        else:
+            x = self.Linear(x.permute(0,2,1)).permute(0,2,1)
+        return x # [Batch, Output length, Channel]
+
+class Configs:
+    def __init__(self, seq_len, pred_len, enc_in=321, individual=True):
+      self.seq_len = seq_len
+      self.pred_len = pred_len
+      self.enc_in = enc_in
+      self.individual = individual
+
+model = 'Linear'
+seq_len = 10
+pred_len = 4
+enc_in = 3
+
+configs = Configs(seq_len, pred_len, enc_in, True)
+circuit = Model(configs)
+
+x = torch.randn(1, seq_len, pred_len)
+
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=15,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  # the model's input names
+                  input_names=['input'],
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/scatter_nd/input.json
+++ b/examples/onnx/scatter_nd/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.1874287724494934, 1.0498261451721191, 0.22384068369865417, 1.048445224761963, -0.5670360326766968, -0.38653188943862915, 0.12878702580928802, -2.3675858974456787, 0.5800458192825317, -0.43653929233551025, -0.2511898875236511, 0.3324051797389984, 0.27960312366485596, 0.4763695001602173, 0.3796705901622772, 1.1334782838821411, -0.87981778383255, -1.2451434135437012, 0.7672272324562073, -0.24404007196426392, -0.6875824928283691, 0.3619358539581299, -0.10131897777318954, 0.7169521450996399, 1.6585893630981445, -0.5451845526695251, 0.429487019777298, 0.7426952123641968, -0.2543637454509735, 0.06546942889690399, 0.7939824461936951, 0.1579471379518509, -0.043604474514722824, -0.8621711730957031, -0.5344759821891785, -0.05880478024482727, -0.17351101338863373, 0.5095029473304749, -0.7864817976951599, -0.449171245098114]]}
--- a/examples/onnx/scatter_nd/network.onnx
+++ b/examples/onnx/scatter_nd/network.onnx
--- a/examples/onnx/tril/gen.py
+++ b/examples/onnx/tril/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.triu(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 3, 3).uniform_(0, 5)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/tril/input.json
+++ b/examples/onnx/tril/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.4870188236236572, 2.275230646133423, 3.126268148422241, 0.6412187218666077, 0.9967470169067383, 1.9814395904541016, 1.6355383396148682, 0.6397527456283569, 0.7825168967247009]]}
--- a/examples/onnx/tril/network.onnx
+++ b/examples/onnx/tril/network.onnx
--- a/examples/onnx/triu/gen.py
+++ b/examples/onnx/triu/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.tril(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 3, 3).uniform_(0, 5)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/triu/input.json
+++ b/examples/onnx/triu/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.2898547053337097, 1.8070811033248901, 0.30266255140304565, 3.00581955909729, 0.5379888415336609, 1.7057424783706665, 2.415961265563965, 0.589233934879303, 0.03824889659881592]]}
--- a/examples/onnx/triu/network.onnx
+++ b/examples/onnx/triu/network.onnx
--- a/examples/test_failure.proof
+++ b/examples/test_failure.proof
--- a/examples/test_failure_aggr.proof
+++ b/examples/test_failure_aggr.proof
--- a/examples/test_failure_aggr_proof.json
+++ b/examples/test_failure_aggr_proof.json
--- a/examples/test_failure_proof.json
+++ b/examples/test_failure_proof.json
--- a/in-browser-evm-verifier/README.md
+++ b/in-browser-evm-verifier/README.md
@@ -0,0 +1,60 @@
+# inbrowser-evm-verify
+
+We would like the Solidity verifier to be canonical and usually all you ever need. For this, we need to be able to run that verifier in browser.
+
+## How to use (Node js)
+
+```ts 
+import localEVMVerify from '@ezkljs/verify';
+
+// Load in the proof file as a buffer
+const proofFileBuffer = fs.readFileSync(`${path}/${example}/proof.pf`)
+
+// Stringified EZKL evm verifier bytecode (this is just an example don't use in production)
+const bytecode = '0x608060405234801561001057600080fd5b5060d38061001f6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063cfae321714610046575b600080fd5b6100496100f1565b60405161005691906100f1565b60405180910390f35b'
+
+const result = await localEVMVerify(proofFileBuffer, bytecode)
+
+console.log('result', result)
+```
+
+**Note**: Run `ezkl create-evm-verifier` to get the Solidity verifier, with which you can retrieve the bytecode once compiled. We recommend compiling to the Shanghai hardfork target, else you will have to pass an additional parameter specifying the EVM version to the `localEVMVerify` function like so (for Paris hardfork):
+
+```ts
+import localEVMVerify, { hardfork } from '@ezkljs/verify';
+
+const result = await localEVMVerify(proofFileBuffer, bytecode, hardfork['Paris'])
+```
+
+**Note**: You can also verify separated vk verifiers using the `localEVMVerify` function. Just pass the vk verifier bytecode as the third parameter like so:
+```ts
+import localEVMVerify from '@ezkljs/verify';
+
+const result = await localEVMVerify(proofFileBuffer, verifierBytecode, VKBytecode)
+```
+
+
+## How to use (Browser)
+
+```ts
+import localEVMVerify from '@ezkljs/verify';
+
+// Load in the proof file as a buffer using the web apis (fetch, FileReader, etc)
+// We use fetch in this example to load the proof file as a buffer
+const proofFileBuffer = await fetch(`${path}/${example}/proof.pf`).then(res => res.arrayBuffer())
+
+// Stringified EZKL evm verifier bytecode (this is just an example don't use in production)
+const bytecode = '0x608060405234801561001057600080fd5b5060d38061001f6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063cfae321714610046575b600080fd5b6100496100f1565b60405161005691906100f1565b60405180910390f35b'
+
+const result = await browserEVMVerify(proofFileBuffer, bytecode)
+
+console.log('result', result)
+```
+
+Output:
+
+```ts  
+result: true
+```
+
+
--- a/in-browser-evm-verifier/package.json
+++ b/in-browser-evm-verifier/package.json
@@ -0,0 +1,42 @@
+{
+  "name": "@ezkljs/verify",
+  "version": "0.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Evm verify EZKL proofs in the browser.",
+  "main": "dist/commonjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/commonjs/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "clean": "rm -r dist || true",
+    "build:commonjs": "tsc --project tsconfig.commonjs.json && resolve-tspaths -p tsconfig.commonjs.json",
+    "build:esm": "tsc --project tsconfig.esm.json && resolve-tspaths -p tsconfig.esm.json",
+    "build": "npm run clean && npm run build:commonjs && npm run build:esm"
+  },
+  "dependencies": {
+    "@ethereumjs/common": "^4.0.0",
+    "@ethereumjs/evm": "^2.0.0",
+    "@ethereumjs/statemanager": "^2.0.0",
+    "@ethereumjs/tx": "^5.0.0",
+    "@ethereumjs/util": "^9.0.0",
+    "@ethereumjs/vm": "^7.0.0",
+    "@ethersproject/abi": "^5.7.0",
+    "@ezkljs/engine": "^9.4.4",
+    "ethers": "^6.7.1",
+    "json-bigint": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.8.3",
+    "ts-loader": "^9.5.0",
+    "ts-node": "^10.9.1",
+    "resolve-tspaths": "^0.8.16",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.2.2"
+  }
+}
--- a/in-browser-evm-verifier/pnpm-lock.yaml
+++ b/in-browser-evm-verifier/pnpm-lock.yaml
--- a/in-browser-evm-verifier/src/index.ts
+++ b/in-browser-evm-verifier/src/index.ts
@@ -0,0 +1,145 @@
+import { defaultAbiCoder as AbiCoder } from '@ethersproject/abi'
+import { Address, hexToBytes } from '@ethereumjs/util'
+import { Chain, Common, Hardfork } from '@ethereumjs/common'
+import { LegacyTransaction, LegacyTxData } from '@ethereumjs/tx'
+// import { DefaultStateManager } from '@ethereumjs/statemanager'
+// import { Blockchain } from '@ethereumjs/blockchain'
+import { VM } from '@ethereumjs/vm'
+import { EVM } from '@ethereumjs/evm'
+import { buildTransaction, encodeDeployment } from './utils/tx-builder'
+import { getAccountNonce, insertAccount } from './utils/account-utils'
+import { encodeVerifierCalldata } from '../nodejs/ezkl';
+import { error } from 'console'
+
+async function deployContract(
+  vm: VM,
+  common: Common,
+  senderPrivateKey: Uint8Array,
+  deploymentBytecode: string
+): Promise<Address> {
+  // Contracts are deployed by sending their deployment bytecode to the address 0
+  // The contract params should be abi-encoded and appended to the deployment bytecode.
+  // const data =
+  const data = encodeDeployment(deploymentBytecode)
+  const txData = {
+    data,
+    nonce: await getAccountNonce(vm, senderPrivateKey),
+  }
+
+  const tx = LegacyTransaction.fromTxData(
+    buildTransaction(txData) as LegacyTxData,
+    { common, allowUnlimitedInitCodeSize: true },
+  ).sign(senderPrivateKey)
+
+  const deploymentResult = await vm.runTx({
+    tx,
+    skipBlockGasLimitValidation: true,
+    skipNonce: true
+  })
+
+  if (deploymentResult.execResult.exceptionError) {
+    throw deploymentResult.execResult.exceptionError
+  }
+
+  return deploymentResult.createdAddress!
+}
+
+async function verify(
+  vm: VM,
+  contractAddress: Address,
+  caller: Address,
+  proof: Uint8Array | Uint8ClampedArray,
+  vkAddress?: Address | Uint8Array,
+): Promise<boolean> {
+  if (proof instanceof Uint8Array) {
+    proof = new Uint8ClampedArray(proof.buffer)
+  }
+  if (vkAddress) {
+    const vkAddressBytes = hexToBytes(vkAddress.toString())
+    const vkAddressArray = Array.from(vkAddressBytes)
+
+    let string = JSON.stringify(vkAddressArray)
+
+    const uint8Array = new TextEncoder().encode(string);
+
+    // Step 3: Convert to Uint8ClampedArray
+    vkAddress = new Uint8Array(uint8Array.buffer);
+
+    // convert uitn8array of length
+    error('vkAddress', vkAddress)
+  }
+  const data = encodeVerifierCalldata(proof, vkAddress)
+
+  const verifyResult = await vm.evm.runCall({
+    to: contractAddress,
+    caller: caller,
+    origin: caller, // The tx.origin is also the caller here
+    data: data,
+  })
+
+  if (verifyResult.execResult.exceptionError) {
+    throw verifyResult.execResult.exceptionError
+  }
+
+  const results = AbiCoder.decode(['bool'], verifyResult.execResult.returnValue)
+
+  return results[0]
+}
+
+/**
+ * Spins up an ephemeral EVM instance for executing the bytecode of a solidity verifier
+ * @param proof Json serialized proof file
+ * @param bytecode The bytecode of a compiled solidity verifier.
+ * @param bytecode_vk The bytecode of a contract that stores the vk. (Optional, only required if the vk is stored in a separate contract)
+ * @param evmVersion The evm version to use for the verification. (Default: London)
+ * @returns The result of the evm verification.
+ * @throws If the verify transaction reverts
+ */
+export default async function localEVMVerify(
+  proof: Uint8Array | Uint8ClampedArray,
+  bytecode_verifier: string,
+  bytecode_vk?: string,
+  evmVersion?: Hardfork,
+): Promise<boolean> {
+  try {
+    const hardfork = evmVersion ? evmVersion : Hardfork['Shanghai']
+    const common = new Common({ chain: Chain.Mainnet, hardfork })
+    const accountPk = hexToBytes(
+      '0xe331b6d69882b4cb4ea581d88e0b604039a3de5967688d3dcffdd2270c0fd109', // anvil deterministic Pk 
+    )
+
+    const evm = new EVM({
+      allowUnlimitedContractSize: true,
+      allowUnlimitedInitCodeSize: true,
+    })
+
+    const vm = await VM.create({ common, evm })
+    const accountAddress = Address.fromPrivateKey(accountPk)
+
+    await insertAccount(vm, accountAddress)
+
+    const verifierAddress = await deployContract(
+      vm,
+      common,
+      accountPk,
+      bytecode_verifier
+    )
+
+    if (bytecode_vk) {
+      const accountPk = hexToBytes("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"); // anvil deterministic Pk
+      const accountAddress = Address.fromPrivateKey(accountPk)
+      await insertAccount(vm, accountAddress)
+      const output = await deployContract(vm, common, accountPk, bytecode_vk)
+      const result = await verify(vm, verifierAddress, accountAddress, proof, output)
+      return true
+    }
+
+    const result = await verify(vm, verifierAddress, accountAddress, proof)
+
+    return result
+  } catch (error) {
+    // log or re-throw the error, depending on your needs
+    console.error('An error occurred:', error)
+    throw error
+  }
+}
--- a/in-browser-evm-verifier/src/utils/account-utils.ts
+++ b/in-browser-evm-verifier/src/utils/account-utils.ts
@@ -0,0 +1,32 @@
+import { VM } from '@ethereumjs/vm'
+import { Account, Address } from '@ethereumjs/util'
+
+export const keyPair = {
+  secretKey:
+    '0x3cd7232cd6f3fc66a57a6bedc1a8ed6c228fff0a327e169c2bcc5e869ed49511',
+  publicKey:
+    '0x0406cc661590d48ee972944b35ad13ff03c7876eae3fd191e8a2f77311b0a3c6613407b5005e63d7d8d76b89d5f900cde691497688bb281e07a5052ff61edebdc0',
+}
+
+export const insertAccount = async (vm: VM, address: Address) => {
+  const acctData = {
+    nonce: 0,
+    balance: BigInt('1000000000000000000'), // 1 eth
+  }
+  const account = Account.fromAccountData(acctData)
+
+  await vm.stateManager.putAccount(address, account)
+}
+
+export const getAccountNonce = async (
+  vm: VM,
+  accountPrivateKey: Uint8Array,
+) => {
+  const address = Address.fromPrivateKey(accountPrivateKey)
+  const account = await vm.stateManager.getAccount(address)
+  if (account) {
+    return account.nonce
+  } else {
+    return BigInt(0)
+  }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
dante	ff563e93a7	fix: bump python version (#761 )	2024-04-02 17:08:26 +01:00
dante	5639d36097	chore: verify aggr wasm unit test (#760 )	2024-04-01 20:54:20 +01:00
dante	4ec8d13082	chore: verify aggr in wasm (#758 )	2024-03-29 23:28:20 +00:00
dante	12735aefd4	chore: reduce softmax recip DR (#756 )	2024-03-27 01:14:29 +00:00
dante	7fe179b8d4	feat: dictionary of reusable constants (#754 )	2024-03-26 13:12:09 +00:00
Ethan Cemer	3be988a6a0	fix: use pnpm in build script for in-browser-evm-verifier (#752 )	2024-03-25 23:23:02 +00:00
dante	3abb3aff56	feat: make selector polynomials optional (#753 )	2024-03-22 09:28:28 +00:00
dante	338788cb8f	fix: lookup safety = 1 during calibration falls OOR (#750 )	2024-03-21 08:53:43 +00:00
Sung Jun Eun	feb3b1b475	fix: array element encapsulation in ezkl_demo.ipynb (#747 )	2024-03-21 08:51:01 +00:00
dante	e134d86756	refactor: apply num-inner cols to constant assignments as well (#749 )	2024-03-20 23:51:38 +00:00
dante	6819a3acf6	chore: more complete coverage tests (#748 )	2024-03-20 18:53:47 +00:00
dante	2ccf056661	fix: logrows reset after graph creation can cause extended K overflow (#745 )	2024-03-20 10:15:11 +00:00
dante	a5bf64b1a2	feat!: ipa commitments (#740 ) BREAKING CHANGE: commitment is now an added flag	2024-03-16 16:31:01 +00:00
Ethan Cemer	56e2326be1	*nuke (#742 )	2024-03-14 14:11:03 -05:00
Ethan Cemer	2be181db35	feat: merge `@ezkljs/verify` package into core repo. (#736 )	2024-03-14 01:13:14 +00:00
jmjac	de9e3f2673	Add __version__ to python bindings (#739 )	2024-03-13 14:22:20 +00:00
dante	a1450f8df7	feat: `gather_nd`/`scatter_nd` support (#737 )	2024-03-11 22:05:40 +00:00
dante	ea535e2ecd	refactor: use linear index constraints for gather and scatter (#735 )	2024-03-09 18:00:21 +00:00
Alexander Camuto	f8aa91ed08	fix: windows compile	2024-03-06 11:40:44 +00:00
dante	a59e3780b2	chore: rm recip_int helper (#733 )	2024-03-05 21:51:14 +00:00
dante	345fb5672a	chore: cleanup unused args (#732 )	2024-03-05 13:43:29 +00:00
dante	70daaff2e4	chore: cleanup calibrate (#731 )	2024-03-04 17:52:11 +00:00
dante	a437d8a51f	feat: "sub"-dynamic tables (#730 )	2024-03-04 10:35:28 +00:00
Ethan Cemer	fe535c1cac	feat: wasm felt to little endian string (#729 ) --------- Co-authored-by: Alexander Camuto <45801863+alexander-camuto@users.noreply.github.com>	2024-03-01 14:06:20 +00:00
dante	3e8dcb001a	chore: test for reduced-srs on wasm bundle (#728 ) --------- Co-authored-by: Ethan <tylercemer@gmail.com>	2024-03-01 13:23:07 +00:00
dante	14786acb95	feat: dynamic lookups (#727 )	2024-03-01 01:44:45 +00:00
dante	80a3c44cb4	feat: lookup-less recip by default (#725 )	2024-02-28 16:35:20 +00:00
dante	1656846d1a	fix: transcript should serialize as lc flag (#726 )	2024-02-26 22:02:47 +00:00
dante	88098b8190	fix!: cleanup felt serialization language in python and wasm (#724 ) BREAKING CHANGE: python and wasm felt utilities have new names	2024-02-25 14:06:48 +00:00
dante	6c0c17c9be	fix: include tol check in fwd pass (#723 )	2024-02-23 01:28:59 +00:00
dante	bf69b16fc1	fix: rm optional bool flags (#722 )	2024-02-21 12:45:42 +00:00
dante	74feb829da	feat: parse command `ast` into flag strings (#720 )	2024-02-21 00:38:26 +00:00
dante	d429e7edab	fix: buffer data read and writes (#719 )	2024-02-19 11:49:15 +00:00
dante	f0e5b82787	refactor: selectable key ser (#718 )	2024-02-19 11:26:18 +00:00
dante	3f7261f50b	fix: set buf capacity for witness, settings, proof (#717 )	2024-02-16 21:59:20 +00:00
dante	678a249dcb	feat: allow for reduced n srs for verification (#716 )	2024-02-16 18:28:54 +00:00
dante	0291eb2d0f	fix: reduce verbosity of common operations (#715 )	2024-02-15 17:27:33 +00:00
dante	1b637a70b0	refactor: `print_proof_hex` is redundant with proof file (#713 )	2024-02-14 15:25:28 +00:00
dante	abcd5380db	feat: programmable buffer capacity (#712 )	2024-02-13 15:49:14 +00:00
dante	076b737108	chore: allow for a max circuit area cap (#711 )	2024-02-12 14:36:51 +00:00
dante	97d9832591	refactor: calibration for resources and accuracy over same scale range (#710 )	2024-02-11 15:03:38 +00:00
dante	e0771683a6	chore: update h2 curves (#709 )	2024-02-10 22:54:38 +00:00
dante	319c222307	chore: more descriptive debug logs on forward pass (#708 )	2024-02-10 16:10:33 +00:00
dante	85ee6e7f9d	refactor: use layout as the forward function (#707 )	2024-02-08 21:15:46 +00:00
dante	4c8daf773c	refactor: lookup-less layer norm (#706 )	2024-02-07 21:19:17 +00:00
dante	80041ac523	refactor: equals argument without lookups (#705 )	2024-02-07 14:20:13 +00:00
dante	2a1ee1102c	refactor: range check recip (#703 )	2024-02-05 14:42:26 +00:00
dante	95d4fd4a70	feat: power of 2 div using type system (#702 )	2024-02-04 02:43:38 +00:00
dante	e0d3f4f145	fix: uncomparable values in acc table (#701 )	2024-02-02 15:13:29 +00:00
dante	bceac2fab5	ci: make gpu tests single threaded (#700 )	2024-01-31 18:19:29 +00:00
dante	04d7b5feaa	chore: fold div_rebasing parameter into calibration (#699 )	2024-01-31 10:03:12 +00:00
dante	45fd12a04f	refactor!: make rebasing multiplicative by default (#698 ) BREAKING CHANGE: adds a `required_range_checks` field to `cs`	2024-01-30 18:37:57 +00:00
dante	bc7c33190f	feat: allow for separate vk render on-chain (#697 )	2024-01-25 19:48:13 +00:00
dante	df72e01414	feat: make selector compression optional (#696 )	2024-01-24 00:09:00 +00:00
Tobin South	172e26c00d	fix: link for CLI auto-install (#695 )	2024-01-22 13:00:27 +00:00
Jason Morton	11ac120f23	fix: large test numbering(#689 ) Co-authored-by: dante <45801863+alexander-camuto@users.noreply.github.com>	2024-01-21 21:01:46 +00:00
				`@@ -0,0 +1 @@`
				`{"input_data": [[0.7549541592597961, 0.990360677242279, 0.9473411440849304, 0.3951031565666199, 0.8500555753707886, 0.9352139830589294, 0.11867779493331909, 0.9493132829666138, 0.6588345766067505, 0.1933223009109497, 0.12139874696731567, 0.8547163605690002]]}`
				`@@ -0,0 +1 @@`
				`{"input_data": [[1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0]]}`
				`@@ -0,0 +1 @@`
				`{"input_data": [[0.35387128591537476, 0.030473172664642334, 0.08707714080810547, 0.2429301142692566, 0.45228832960128784, 0.496021032333374, 0.13245105743408203, 0.8497090339660645]]}`
				`@@ -0,0 +1 @@`
				{"input_data": [[0.03297048807144165, 0.46362626552581787, 0.6044231057167053, 0.4949902892112732, 0.48823297023773193, 0.6798646450042725, 0.6824942231178284, 0.03491640090942383, 0.19608813524246216, 0.24129939079284668, 0.9769315123558044, 0.6306831240653992, 0.7690497636795044, 0.252221941947937, 0.9167693853378296, 0.3882681131362915, 0.9307044148445129, 0.33559417724609375, 0.7815426588058472, 0.3435332179069519, 0.7871478796005249, 0.12240773439407349, 0.5295405983924866, 0.4874419569969177, 0.08262640237808228, 0.1124718189239502, 0.5834914445877075, 0.30927878618240356, 0.48899340629577637, 0.9376634955406189, 0.21893149614334106, 0.526070773601532]]}
				`@@ -0,0 +1 @@`
				`{"input_data": [[0.4145222008228302, -0.4043896496295929, 0.7545749545097351]]}`
				`@@ -0,0 +1 @@`
				`{"input_data": [[0.5505883693695068, 0.0766521692276001, 0.12006187438964844, 0.9497959017753601, 0.9100563526153564, 0.968717098236084, 0.5978299379348755, 0.9419963359832764]]}`
				`@@ -0,0 +1 @@`
				`{"input_data": [[0.6996762752532959, 0.42992985248565674, 0.5102168321609497, 0.5540387630462646, 0.8489438891410828, 0.8533616065979004, 0.36736780405044556, 0.5859147310256958]]}`
				`@@ -0,0 +1 @@`
				{"input_data": [[0.7973018884658813, 0.5245689153671265, 0.34149593114852905, 0.1455438733100891, 0.9482707381248474, 0.4221445322036743, 0.001363217830657959, 0.8736765384674072, 0.42954301834106445, 0.7199509739875793, 0.37641745805740356, 0.5920265316963196, 0.42270803451538086, 0.41761744022369385, 0.603948712348938, 0.7250819802284241, 0.047173500061035156, 0.5115441679954529, 0.3743387460708618, 0.16794061660766602, 0.5352339148521423, 0.037976861000061035, 0.65323406457901, 0.5585184097290039, 0.10559147596359253, 0.07827490568161011, 0.6717077493667603, 0.6480781435966492, 0.9780838489532471, 0.8353415131568909, 0.6491701006889343, 0.6573048233985901]]}
				`@@ -0,0 +1 @@`
				`{"input_data": [[0.18563222885131836, 0.4843214750289917, 0.9991059899330139, 0.02534431219100952, 0.8105666041374207, 0.9658406376838684, 0.681107759475708, 0.5365872979164124]]}`