ci: update version string in docs

fix: should update using bash when possible (#813 )
refactor: rm boxed errors (opaque) (#810 )
2026-01-13 16:27:59 -05:00 · 2024-06-10 16:14:16 +00:00 · 2024-06-10 12:13:59 -04:00 · 2024-06-08 22:41:47 -04:00 · 2024-06-07 10:30:21 -04:00 · 2024-06-07 10:19:38 -04:00
213 changed files with 23531 additions and 11527 deletions
--- a/.github/workflows/engine.yml
+++ b/.github/workflows/engine.yml
@@ -1,4 +1,4 @@
-name: Build and Publish WASM<>JS Bindings
+name: Build and Publish EZKL Engine npm package

 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"
@@ -65,7 +62,7 @@ jobs:
              "web/ezkl_bg.wasm",
              "web/ezkl.js",
              "web/ezkl.d.ts",
-              "web/snippets/wasm-bindgen-rayon-7afa899f36665473/src/workerHelpers.js",
+              "web/snippets/**/*",
              "web/package.json",
              "web/utils.js",
              "ezkl.d.ts"
@@ -82,6 +79,10 @@ jobs:
        run: |
          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" pkg/nodejs/ezkl.js

+      - name: Replace `import.meta.url` with `import.meta.resolve` definition in workerHelpers.js
+        run: |
+          find ./pkg/web/snippets -type f -name "*.js" -exec sed -i "s|import.meta.url|import.meta.resolve|" {} +
+
      - name: Add serialize and deserialize methods to nodejs bundle
        run: |
          echo '
@@ -95,7 +96,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 +104,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 +127,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 +135,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 +178,58 @@ jobs:
          npm publish
        env:
          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+
+  in-browser-evm-ver-publish:
+    name: publish-in-browser-evm-verifier-package
+    needs: [publish-wasm-bindings]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - uses: actions/checkout@v4
+      - name: Update version in package.json
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          sed -i "s|\"version\": \".*\"|\"version\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
+      - name: Prepare tag and fetch package integrity
+        run: |
+          CLEANED_TAG=${{ github.ref_name }} # Get the tag from ref_name
+          CLEANED_TAG="${CLEANED_TAG#v}" # Remove leading 'v'
+          echo "CLEANED_TAG=${CLEANED_TAG}" >> $GITHUB_ENV # Set it as an environment variable for later steps
+          ENGINE_INTEGRITY=$(npm view @ezkljs/engine@$CLEANED_TAG dist.integrity)
+          echo "ENGINE_INTEGRITY=$ENGINE_INTEGRITY" >> $GITHUB_ENV
+      - name: Update @ezkljs/engine version in package.json
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          sed -i "s|\"@ezkljs/engine\": \".*\"|\"@ezkljs/engine\": \"$CLEANED_TAG\"|" in-browser-evm-verifier/package.json
+      - name: Update the engine import in in-browser-evm-verifier to use @ezkljs/engine package instead of the local one;
+        run: |
+          sed -i "s|import { encodeVerifierCalldata } from '../nodejs/ezkl';|import { encodeVerifierCalldata } from '@ezkljs/engine';|" in-browser-evm-verifier/src/index.ts
+      - name: Update pnpm-lock.yaml versions and integrity
+        run: |
+          awk -v integrity="$ENGINE_INTEGRITY" -v tag="$CLEANED_TAG" '
+          NR==30{$0="    specifier: \"" tag "\""}
+          NR==31{$0="    version: \"" tag "\""}
+          NR==400{$0="  /@ezkljs/engine@" tag ":"}
+          NR==401{$0="    resolution: {integrity: \"" integrity "\"}"} 1' in-browser-evm-verifier/pnpm-lock.yaml > temp.yaml && mv temp.yaml in-browser-evm-verifier/pnpm-lock.yaml  
+      - name: Use pnpm 8
+        uses: pnpm/action-setup@v2
+        with:
+          version: 8
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "18.12.1"
+          registry-url: "https://registry.npmjs.org"
+      - name: Publish to npm
+        run: |
+          cd in-browser-evm-verifier
+          pnpm install --frozen-lockfile
+          pnpm run build
+          pnpm publish --no-git-checks
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}  
--- a/.github/workflows/large-tests.yml
+++ b/.github/workflows/large-tests.yml
@@ -11,7 +11,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2023-08-24
+          toolchain: nightly-2024-02-06
          override: true
          components: rustfmt, clippy
      - name: nanoGPT Mock
--- 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
@@ -40,7 +40,7 @@ jobs:

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

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

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

@@ -110,12 +111,12 @@ jobs:
    if: startsWith(github.ref, 'refs/tags/')
    strategy:
      matrix:
-        target: [x86_64, i686]
+        target: [x86_64]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v4
        with:
-          python-version: 3.7
+          python-version: 3.12
          architecture: x64

      - name: Set Cargo.toml version to match github tag
@@ -128,6 +129,7 @@ jobs:
          mv Cargo.lock Cargo.lock.orig
          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig >Cargo.lock

+
      - name: Install required libraries
        shell: bash
        run: |
@@ -139,6 +141,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 +178,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 +230,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 +265,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 +289,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
@@ -345,3 +361,17 @@ jobs:
        with:
          repository-url: https://test.pypi.org/legacy/
          packages-dir: ./
+
+  doc-publish:
+    name: Trigger ReadTheDocs Build
+    runs-on: ubuntu-latest
+    needs: pypi-publish
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Trigger RTDs build
+        uses: dfm/rtds-action@v1
+        with:
+          webhook_url: ${{ secrets.RTDS_WEBHOOK_URL }}
+          webhook_token: ${{ secrets.RTDS_WEBHOOK_TOKEN }}
+          commit_ref: ${{ github.ref_name }}
--- 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"]
@@ -104,28 +102,32 @@ jobs:
      PCRE2_SYS_STATIC: 1
    strategy:
      matrix:
-        build: [windows-msvc, macos, macos-aarch64, linux-musl, linux-gnu]
+        build: [windows-msvc, macos, macos-aarch64, linux-musl, linux-gnu, linux-aarch64]
        include:
          - build: windows-msvc
            os: windows-latest
-            rust: nightly-2023-06-27
+            rust: nightly-2024-02-06
            target: x86_64-pc-windows-msvc
          - build: macos
            os: macos-13
-            rust: nightly-2023-06-27
+            rust: nightly-2024-02-06
            target: x86_64-apple-darwin
          - build: macos-aarch64
            os: macos-13
-            rust: nightly-2023-06-27
+            rust: nightly-2024-02-06
            target: aarch64-apple-darwin
          - build: linux-musl
            os: ubuntu-22.04
-            rust: nightly-2023-06-27
+            rust: nightly-2024-02-06
            target: x86_64-unknown-linux-musl
          - build: linux-gnu
            os: ubuntu-22.04
-            rust: nightly-2023-06-27
+            rust: nightly-2024-02-06
            target: x86_64-unknown-linux-gnu
+          - build: linux-aarch64
+            os: ubuntu-22.04
+            rust: nightly-2024-02-06
+            target: aarch64-unknown-linux-gnu

    steps:
      - name: Checkout repo
@@ -183,7 +185,7 @@ jobs:
        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry

      - name: Strip release binary
-        if: matrix.build != 'windows-msvc'
+        if: matrix.build != 'windows-msvc' && matrix.build != 'linux-aarch64'
        run: strip "target/${{ matrix.target }}/release/ezkl"

      - name: Strip release binary (Windows)
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -26,7 +26,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-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,30 @@ 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 --frozen-lockfile
+          pnpm install --dir ./in-browser-evm-verifier --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)
@@ -327,6 +341,10 @@ jobs:
        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_output_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + on chain inputs & outputs)
        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_output_prove_and_verify --test-threads 1
+      - name: KZG prove and verify tests (EVM + on chain inputs & kzg outputs + params)
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_kzg_output_kzg_params_prove_and_verify --test-threads 1
+      - name: KZG prove and verify tests (EVM + on chain outputs & kzg inputs + params)
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_output_kzg_input_kzg_params_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM + on chain inputs & outputs hashes)
        run: cargo nextest run --release --verbose tests_evm::kzg_evm_on_chain_input_output_hashed_prove_and_verify --test-threads 1
      - name: KZG prove and verify tests (EVM)
@@ -340,23 +358,20 @@ jobs:

  prove-and-verify-tests:
    runs-on: non-gpu
-    needs: [build, library-tests]
+    needs: [build, library-tests, docs]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        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
@@ -367,9 +382,9 @@ jobs:
        with:
          node-version: "18.12.1"
          cache: "pnpm"
-      - name: Install dependencies
+      - name: Install dependencies for js tests
        run: |
-          pnpm install --no-frozen-lockfile
+          pnpm install --frozen-lockfile
        env:
          CI: false
          NODE_ENV: development
@@ -385,6 +400,16 @@ jobs:
          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" tests/wasm/nodejs/ezkl.js
      - name: KZG prove and verify tests (public outputs + column overflow)
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w
+      - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_
+      - name: KZG prove and verify tests (hashed inputs + column overflow)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_hashed_inputs_
+      - name: KZG prove and verify tests (public outputs)
+        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_tight_lookup_::t
+      - name: IPA prove and verify tests
+        run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_::t --test-threads 1
+      - name: IPA prove and verify tests (ipa outputs)
+        run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_ipa_output
      - name: KZG prove and verify tests single inner col
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_single_col
      - name: KZG prove and verify tests triple inner col
@@ -395,12 +420,8 @@ jobs:
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_octuple_col --test-threads 8
      - name: KZG prove and verify tests (kzg outputs)
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output
-      - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_
      - name: KZG prove and verify tests (public outputs)
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t
-      - name: KZG prove and verify tests (public 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)
@@ -416,11 +437,11 @@ 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:
@@ -443,44 +464,21 @@ jobs:
      - name: KZG prove and verify tests (hashed outputs)
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1

-  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
-
  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:
@@ -491,7 +489,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
@@ -503,29 +501,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
@@ -535,7 +533,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

@@ -546,15 +544,13 @@ 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
        with:
          crate: cargo-nextest
          locked: true
-      - name: Download MNIST
-        run: sh data.sh
      - name: Examples
        run: cargo nextest run --release tests_examples

@@ -565,34 +561,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
+        run: source .env/bin/activate; pip install pytest-asyncio; 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
@@ -600,9 +598,9 @@ 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
@@ -616,14 +614,32 @@ jobs:

  python-integration-tests:
    runs-on: large-self-hosted
+    services:
+      # Label used to access the service container
+      postgres:
+        # Docker Hub image
+        image: postgres
+        env:
+          POSTGRES_USER: ubuntu
+          POSTGRES_HOST_AUTH_METHOD: trust
+        # Set health checks to wait until postgres has started
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+          -v /var/run/postgresql:/var/run/postgresql
+        ports:
+          # Maps tcp port 5432 on service container to the host
+          - 5432:5432
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v4
        with:
-          python-version: "3.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
@@ -633,11 +649,17 @@ 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: Postgres tutorials
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::postgres_ --no-capture
+      - name: Tictactoe tutorials
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_ --test-threads 1
      # - name: authenticate-kaggle-cli
      #   shell: bash
      #   env:
@@ -648,12 +670,8 @@ jobs:
      #     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_ --no-capture
+        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: Tictactoe tutorials
-        run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_ --no-capture
-      # - name: Postgres tutorials
-      #   run: source .env/bin/activate; cargo nextest run py_tests::tests::postgres_ --test-threads 1
--- a/.github/workflows/tagging.yml
+++ b/.github/workflows/tagging.yml
@@ -14,6 +14,40 @@ jobs:
      - uses: actions/checkout@v4
      - name: Bump version and push tag
        id: tag_version
-        uses: mathieudutour/github-tag-action@v6.1
+        uses: mathieudutour/github-tag-action@v6.2
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set Cargo.toml version to match github tag for docs
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ steps.tag_version.outputs.new_tag }}
+        run: |
+          mv docs/python/src/conf.py docs/python/src/conf.py.orig
+          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" docs/python/src/conf.py.orig >docs/python/src/conf.py
+          rm docs/python/src/conf.py.orig
+          mv docs/python/requirements-docs.txt docs/python/requirements-docs.txt.orig
+          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" docs/python/requirements-docs.txt.orig >docs/python/requirements-docs.txt
+          rm docs/python/requirements-docs.txt.orig
+
+      - name: Commit files and create tag
+        env:
+          RELEASE_TAG: ${{ steps.tag_version.outputs.new_tag }}
+        run: |
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git fetch --tags
+          git checkout -b release-$RELEASE_TAG
+          git add .
+          git commit -m "ci: update version string in docs"
+          git tag -d $RELEASE_TAG
+          git tag $RELEASE_TAG
+
+      - name: Push changes
+        uses: ad-m/github-push-action@master
+        env:
+          RELEASE_TAG: ${{ steps.tag_version.outputs.new_tag }}
+        with:
+          branch: release-${{ steps.tag_version.outputs.new_tag }}
+          force: true
+          tags: true
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,5 @@
 target
 pkg
-data
 *.csv
 !examples/notebooks/eth_price.csv
 *.ipynb_checkpoints
@@ -45,6 +44,9 @@ var/
 *.whl
 *.bak
 node_modules
+/dist
 timingData.json
 !tests/wasm/pk.key
-!tests/wasm/vk.key
+!tests/wasm/vk.key
+docs/python/build
+!tests/wasm/vk_aggr.key
--- a/.python-version
+++ b/.python-version
@@ -0,0 +1 @@
+3.12.1
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -0,0 +1,26 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.12"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: ./docs/python/src/conf.py
+
+# Optionally build your docs in additional formats such as PDF and ePub
+# formats:
+#    - pdf
+#    - epub
+
+# Optional but recommended, declare the Python requirements required
+# to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+python:
+  install:
+  - requirements: ./docs/python/requirements-docs.txt
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,70 +15,101 @@ crate-type = ["cdylib", "rlib"]


 [dependencies]
-halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch= "main" }
-halo2_proofs = { git = "https://github.com/zkonduit/halo2", branch= "main"  }
-halo2curves = { version = "0.6.0", features = ["derive_serde"] }
+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"] }
+clap_complete = "4.5.2"
 serde = { version = "1.0.126", features = ["derive"], optional = true }
-serde_json = { version = "1.0.97", default_features = false, features = ["float_roundtrip", "raw_value"], optional = true }
+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= "main" }
-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" }
+metal = { git = "https://github.com/gfx-rs/metal-rs", optional = true }
+semver = "1.0.22"

 # 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}
+alloy = { git = "https://github.com/alloy-rs/alloy", version = "0.1.0", rev="5fbf57bac99edef9d8475190109a7ea9fb7e5e83", features = ["provider-http", "signers", "contract", "rpc-types-eth", "signer-wallet", "node-bindings"] }
+foundry-compilers = {version = "0.4.1", features = ["svm-solc"]}
+ethabi = "18"
+indicatif = { version = "0.17.5", features = ["rayon"] }
+gag = { version = "1.0.0", default_features = false }
 instant = { version = "0.1" }
-reqwest = { version = "0.11.14", default-features = false, features = ["default-tls", "multipart", "stream"] }
+reqwest = { version = "0.12.4", default-features = false, features = [
+    "default-tls",
+    "multipart",
+    "stream",
+] }
 openssl = { version = "0.10.55", features = ["vendored"] }
-postgres = "0.19.5"
+tokio-postgres = "0.7.10"
 pg_bigdecimal = "0.1.5"
+futures-util = "0.3.30"
 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.35", default_features = false, features = [
+    "macros",
+    "rt-multi-thread"
+] }
 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-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 }
+pyo3 = { version = "0.21.2", features = [
+    "extension-module",
+    "abi3-py37",
+    "macros",
+], default_features = false, optional = true }
+pyo3-asyncio = { git = "https://github.com/jopemachine/pyo3-asyncio/", branch="migration-pyo3-0.21", features = [
+    "attributes",
+    "tokio-runtime",
+], default_features = false, optional = true }
+pyo3-log = { version = "0.10.0", default_features = false, optional = true }
+tract-onnx = { git = "https://github.com/sonos/tract/", rev = "05ebf550aa9922b221af4635c21a67a8d2af12a9", default_features = false, optional = true }
 tabled = { version = "0.12.0", optional = true }

+objc = { version = "0.2.4", optional = true }
+

 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
-colored = { version = "2.0.0",  default_features = false, optional = true}
-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"
@@ -149,19 +180,38 @@ required-features = ["ezkl"]

 [features]
 web = ["wasm-bindgen-rayon"]
-default = ["ezkl", "mv-lookup"]
-render = ["halo2_proofs/dev-graph", "plotters"]
+default = ["ezkl", "mv-lookup", "no-banner"]
 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 = []
+metal = ["dep:metal", "dep:objc"]

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

@@ -70,10 +72,14 @@ curl https://raw.githubusercontent.com/zkonduit/ezkl/main/install_ezkl_cli.sh |

 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 🔨

@@ -85,9 +91,9 @@ You can install the library from source
 cargo install --locked --path .
 ```

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


 #### building python bindings
@@ -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/abis/QuantizeData.json
+++ b/abis/QuantizeData.json
@@ -20,9 +20,9 @@
 		"name": "quantize_data",
 		"outputs": [
 			{
-				"internalType": "int128[]",
+				"internalType": "int64[]",
 				"name": "quantized_data",
-				"type": "int128[]"
+				"type": "int64[]"
 			}
 		],
 		"stateMutability": "pure",
@@ -31,9 +31,9 @@
 	{
 		"inputs": [
 			{
-				"internalType": "int128[]",
+				"internalType": "int64[]",
 				"name": "quantized_data",
-				"type": "int128[]"
+				"type": "int64[]"
 			}
 		],
 		"name": "to_field_element",
--- 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;
@@ -67,8 +70,8 @@ impl Circuit<Fr> for MyCircuit {
                        &mut region,
                        &[self.image.clone(), self.kernel.clone(), self.bias.clone()],
                        Box::new(PolyOp::Conv {
-                            padding: [(0, 0); 2],
-                            stride: (1, 1),
+                            padding: vec![(0, 0)],
+                            stride: vec![1; 2],
                        }),
                    )
                    .unwrap();
@@ -121,28 +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, true,
-                    )
-                    .unwrap();
+                    create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                        .unwrap();
                });
            });

-            let pk =
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-                    .unwrap();
+            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, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            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, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            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
@@ -4,17 +4,20 @@ 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: Range = (-32768, 32768);
@@ -112,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, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            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
@@ -4,17 +4,20 @@ use ezkl::circuit::*;
 use ezkl::circuit::lookup::LookupOp;
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::table::Range;
-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: Range = (-8180, 8180);
@@ -115,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, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            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, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            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;
@@ -62,9 +65,9 @@ impl Circuit<Fr> for MyCircuit {
                        &mut region,
                        &[self.image.clone()],
                        Box::new(HybridOp::SumPool {
-                            padding: [(0, 0); 2],
-                            stride: (1, 1),
-                            kernel_shape: (2, 2),
+                            padding: vec![(0, 0); 2],
+                            stride: vec![1, 1],
+                            kernel_shape: vec![2, 2],
                            normalized: false,
                        }),
                    )
@@ -101,28 +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, true,
-                    )
-                    .unwrap();
+                    create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                        .unwrap();
                });
            });

-            let pk =
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-                    .unwrap();
+            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, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            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, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            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, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        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,
-                    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
@@ -2,11 +2,12 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::table::Range;
 use ezkl::circuit::{ops::lookup::LookupOp, BaseConfig as Config, CheckMode};
-use ezkl::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},
@@ -14,6 +15,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::Rng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;

 const BITS: Range = (-32768, 32768);
 static mut LEN: usize = 4;
@@ -91,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, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

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

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

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

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

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

    uint256 constant INPUT_CALLS = 0;

@@ -69,7 +237,7 @@ contract DataAttestation is LoadInstances {

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

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

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

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

--- a/contracts/LoadInstances.sol
+++ b/contracts/LoadInstances.sol
@@ -1,92 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-contract LoadInstances {
-    /**
-     * @dev Parse the instances array from the Halo2Verifier encoded calldata. 
-     * @notice must pass encoded bytes from memory
-     * @param encoded - verifier calldata
-     */
-    function getInstancesMemory(
-        bytes memory encoded
-    ) internal pure returns (uint256[] memory instances) {
-        bytes4 funcSig;
-        uint256 instances_offset;
-        uint256 instances_length;
-        assembly {
-            // fetch function sig. Either `verifyProof(bytes,uint256[])` or `verifyProof(address,bytes,uint256[])`
-            funcSig := mload(add(encoded, 0x20))
-
-            // Fetch instances offset which is 4 + 32 + 32 bytes away from
-            // start of encoded for `verifyProof(bytes,uint256[])`,
-            // and 4 + 32 + 32 +32 away for `verifyProof(address,bytes,uint256[])`
-
-            instances_offset := mload(
-                add(encoded, add(0x44, mul(0x20, eq(funcSig, 0xaf83a18d))))
-            )
-
-            instances_length := mload(add(add(encoded, 0x24), instances_offset))
-        }
-        instances = new uint256[](instances_length); // Allocate memory for the instances array.
-        assembly {
-            // Now instances points to the start of the array data
-            // (right after the length field).
-            for {
-                let i := 0x20
-            } lt(i, add(mul(instances_length, 0x20), 0x20)) {
-                i := add(i, 0x20)
-            } {
-                mstore(
-                    add(instances, i),
-                    mload(add(add(encoded, add(i, 0x24)), instances_offset))
-                )
-            }
-        }
-    }
-    /**
-     * @dev Parse the instances array from the Halo2Verifier encoded calldata. 
-     * @notice must pass encoded bytes from calldata
-     * @param encoded - verifier calldata
-     */
-    function getInstancesCalldata(
-        bytes calldata encoded
-    ) internal pure returns (uint256[] memory instances) {
-        bytes4 funcSig;
-        uint256 instances_offset;
-        uint256 instances_length;
-        assembly {
-            // fetch function sig. Either `verifyProof(bytes,uint256[])` or `verifyProof(address,bytes,uint256[])`
-            funcSig := calldataload(encoded.offset)
-
-            // Fetch instances offset which is 4 + 32 + 32 bytes away from
-            // start of encoded for `verifyProof(bytes,uint256[])`,
-            // and 4 + 32 + 32 +32 away for `verifyProof(address,bytes,uint256[])`
-
-            instances_offset := calldataload(
-                add(
-                    encoded.offset,
-                    add(0x24, mul(0x20, eq(funcSig, 0xaf83a18d)))
-                )
-            )
-
-            instances_length := calldataload(add(add(encoded.offset, 0x04), instances_offset))
-        }
-        instances = new uint256[](instances_length); // Allocate memory for the instances array.
-        assembly{
-            // Now instances points to the start of the array data
-            // (right after the length field).
-
-            for {
-                let i := 0x20
-            } lt(i, add(mul(instances_length, 0x20), 0x20)) {
-                i := add(i, 0x20)
-            } {
-                mstore(
-                    add(instances, i),
-                    calldataload(
-                        add(add(encoded.offset, add(i, 0x04)), instances_offset)
-                    )
-                )
-            }
-        }
-    }
-}
--- a/contracts/QuantizeData.sol
+++ b/contracts/QuantizeData.sol
@@ -1,135 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0
-
-pragma solidity ^0.8.17;
-
-contract QuantizeData {
-    /**
-     * @notice EZKL P value
-     * @dev In order to prevent the verifier from accepting two version of the same instance, n and the quantity (n + P),  where n + P <= 2^256, we require that all instances are stricly less than P. a
-     * @dev The reason for this is that the assmebly code of the verifier performs all arithmetic operations modulo P and as a consequence can't distinguish between n and n + P.
-     */
-    uint256 constant ORDER =
-        uint256(
-            0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
-        );
-
-    /**
-     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
-     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
-     * with further edits by Uniswap Labs also under MIT license.
-     */
-    function mulDiv(
-        uint256 x,
-        uint256 y,
-        uint256 denominator
-    ) internal pure returns (uint256 result) {
-        unchecked {
-            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
-            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
-            // variables such that product = prod1 * 2^256 + prod0.
-            uint256 prod0; // Least significant 256 bits of the product
-            uint256 prod1; // Most significant 256 bits of the product
-            assembly {
-                let mm := mulmod(x, y, not(0))
-                prod0 := mul(x, y)
-                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
-            }
-
-            // Handle non-overflow cases, 256 by 256 division.
-            if (prod1 == 0) {
-                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
-                // The surrounding unchecked block does not change this fact.
-                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
-                return prod0 / denominator;
-            }
-
-            // Make sure the result is less than 2^256. Also prevents denominator == 0.
-            require(denominator > prod1, "Math: mulDiv overflow");
-
-            ///////////////////////////////////////////////
-            // 512 by 256 division.
-            ///////////////////////////////////////////////
-
-            // Make division exact by subtracting the remainder from [prod1 prod0].
-            uint256 remainder;
-            assembly {
-                // Compute remainder using mulmod.
-                remainder := mulmod(x, y, denominator)
-
-                // Subtract 256 bit number from 512 bit number.
-                prod1 := sub(prod1, gt(remainder, prod0))
-                prod0 := sub(prod0, remainder)
-            }
-
-            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
-            // See https://cs.stackexchange.com/q/138556/92363.
-
-            // Does not overflow because the denominator cannot be zero at this stage in the function.
-            uint256 twos = denominator & (~denominator + 1);
-            assembly {
-                // Divide denominator by twos.
-                denominator := div(denominator, twos)
-
-                // Divide [prod1 prod0] by twos.
-                prod0 := div(prod0, twos)
-
-                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
-                twos := add(div(sub(0, twos), twos), 1)
-            }
-
-            // Shift in bits from prod1 into prod0.
-            prod0 |= prod1 * twos;
-
-            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
-            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
-            // four bits. That is, denominator * inv = 1 mod 2^4.
-            uint256 inverse = (3 * denominator) ^ 2;
-
-            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
-            // in modular arithmetic, doubling the correct bits in each step.
-            inverse *= 2 - denominator * inverse; // inverse mod 2^8
-            inverse *= 2 - denominator * inverse; // inverse mod 2^16
-            inverse *= 2 - denominator * inverse; // inverse mod 2^32
-            inverse *= 2 - denominator * inverse; // inverse mod 2^64
-            inverse *= 2 - denominator * inverse; // inverse mod 2^128
-            inverse *= 2 - denominator * inverse; // inverse mod 2^256
-
-            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
-            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
-            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
-            // is no longer required.
-            result = prod0 * inverse;
-            return result;
-        }
-    }
-
-    function quantize_data(
-        bytes[] memory data,
-        uint256[] memory decimals,
-        uint256[] memory scales
-    ) external pure returns (int256[] memory quantized_data) {
-        quantized_data = new int256[](data.length);
-        for (uint i; i < data.length; i++) {
-            int x = abi.decode(data[i], (int256));
-            bool neg = x < 0;
-            if (neg) x = -x;
-            uint denom = 10 ** decimals[i];
-            uint scale = 1 << scales[i];
-            uint output = mulDiv(uint256(x), scale, denom);
-            if (mulmod(uint256(x), scale, denom) * 2 >= denom) {
-                output += 1;
-            }
-
-            quantized_data[i] = neg ? -int256(output) : int256(output);
-        }
-    }
-
-    function to_field_element(
-        int128[] memory quantized_data
-    ) public pure returns (uint256[] memory output) {
-        output = new uint256[](quantized_data.length);
-        for (uint i; i < quantized_data.length; i++) {
-            output[i] = uint256(quantized_data[i] + int(ORDER)) % ORDER;
-        }
-    }
-}
--- a/contracts/TestReads.sol
+++ b/contracts/TestReads.sol
@@ -1,12 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.17;
-
-contract TestReads {
-    int[] public arr;
-
-    constructor(int256[] memory _numbers) {
-        for (uint256 i = 0; i < _numbers.length; i++) {
-            arr.push(_numbers[i]);
-        }
-    }
-}
--- a/data.sh
+++ b/data.sh
@@ -1,11 +0,0 @@
-#! /bin/bash
-
-mkdir data
-cd data
-
-wget http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
-wget http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
-wget http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
-wget http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
-
-gzip -d *.gz
--- a/docs/python/build.sh
+++ b/docs/python/build.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+sphinx-build ./src build
--- a/docs/python/requirements-docs.txt
+++ b/docs/python/requirements-docs.txt
@@ -0,0 +1,4 @@
+ezkl==11.3.3
+sphinx
+sphinx-rtd-theme
+sphinxcontrib-napoleon
--- a/docs/python/src/conf.py
+++ b/docs/python/src/conf.py
@@ -0,0 +1,29 @@
+import ezkl
+
+project = 'ezkl'
+release = '11.3.3'
+version = release
+
+
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.autosummary',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.todo',
+    'sphinx.ext.inheritance_diagram',
+    'sphinx.ext.autosectionlabel',
+    'sphinx.ext.napoleon',
+    'sphinx_rtd_theme',
+]
+
+autosummary_generate = True
+autosummary_imported_members = True
+
+templates_path = ['_templates']
+exclude_patterns = []
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = 'sphinx_rtd_theme'
+html_static_path = ['_static']
--- a/docs/python/src/index.rst
+++ b/docs/python/src/index.rst
@@ -0,0 +1,11 @@
+.. extension documentation master file, created by
+   sphinx-quickstart on Mon Jun 19 15:02:05 2023.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+ezkl python bindings
+================================================
+
+.. automodule:: ezkl
+   :members:
+   :undoc-members:
--- 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},
@@ -41,8 +42,8 @@ const NUM_INNER_COLS: usize = 1;
 struct Config<
    const LEN: usize, //LEN = CHOUT x OH x OW flattened //not supported yet in rust stable
    const CLASSES: usize,
-    const LOOKUP_MIN: i128,
-    const LOOKUP_MAX: i128,
+    const LOOKUP_MIN: i64,
+    const LOOKUP_MAX: i64,
    // Convolution
    const KERNEL_HEIGHT: usize,
    const KERNEL_WIDTH: usize,
@@ -65,8 +66,8 @@ struct Config<
 struct MyCircuit<
    const LEN: usize, //LEN = CHOUT x OH x OW flattened
    const CLASSES: usize,
-    const LOOKUP_MIN: i128,
-    const LOOKUP_MAX: i128,
+    const LOOKUP_MIN: i64,
+    const LOOKUP_MAX: i64,
    // Convolution
    const KERNEL_HEIGHT: usize,
    const KERNEL_WIDTH: usize,
@@ -89,8 +90,8 @@ struct MyCircuit<
 impl<
        const LEN: usize,
        const CLASSES: usize,
-        const LOOKUP_MIN: i128,
-        const LOOKUP_MAX: i128,
+        const LOOKUP_MIN: i64,
+        const LOOKUP_MAX: i64,
        // Convolution
        const KERNEL_HEIGHT: usize,
        const KERNEL_WIDTH: usize,
@@ -202,8 +203,8 @@ where
                    let mut region = RegionCtx::new(region, 0, NUM_INNER_COLS);

                    let op = PolyOp::Conv {
-                        padding: [(PADDING, PADDING); 2],
-                        stride: (STRIDE, STRIDE),
+                        padding: vec![(PADDING, PADDING); 2],
+                        stride: vec![STRIDE; 2],
                    };
                    let x = config
                        .layer_config
@@ -307,6 +308,7 @@ pub fn runconv() {
        tst_lbl: _,
        ..
    } = MnistBuilder::new()
+        .base_path("examples/data")
        .label_format_digit()
        .training_set_length(50_000)
        .validation_set_length(10_000)
@@ -489,6 +491,7 @@ pub fn runconv() {
        strategy,
        pi_for_real_prover,
        &mut transcript,
+        params.n(),
    );
    assert!(verify.is_ok());

--- a/examples/data/t10k-images-idx3-ubyte
+++ b/examples/data/t10k-images-idx3-ubyte
--- a/examples/data/t10k-labels-idx1-ubyte
+++ b/examples/data/t10k-labels-idx1-ubyte
--- a/examples/data/train-images-idx3-ubyte
+++ b/examples/data/train-images-idx3-ubyte
--- a/examples/data/train-labels-idx1-ubyte
+++ b/examples/data/train-labels-idx1-ubyte
--- a/examples/mlp_4d_einsum.rs
+++ b/examples/mlp_4d_einsum.rs
@@ -23,8 +23,8 @@ struct MyConfig {
 #[derive(Clone)]
 struct MyCircuit<
    const LEN: usize, //LEN = CHOUT x OH x OW flattened
-    const LOOKUP_MIN: i128,
-    const LOOKUP_MAX: i128,
+    const LOOKUP_MIN: i64,
+    const LOOKUP_MAX: i64,
 > {
    // Given the stateless MyConfig type information, a DNN trace is determined by its input and the parameters of its layers.
    // Computing the trace still requires a forward pass. The intermediate activations are stored only by the layouter.
@@ -34,7 +34,7 @@ struct MyCircuit<
    _marker: PhantomData<F>,
 }

-impl<const LEN: usize, const LOOKUP_MIN: i128, const LOOKUP_MAX: i128> Circuit<F>
+impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
    for MyCircuit<LEN, LOOKUP_MIN, LOOKUP_MAX>
 {
    type Config = MyConfig;
--- a/examples/notebooks/data_attest.ipynb
+++ b/examples/notebooks/data_attest.ipynb
@@ -251,7 +251,7 @@
                "with open(cal_path, \"w\") as f:\n",
                "    json.dump(cal_data, f)\n",
                "\n",
-                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -307,7 +307,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "ezkl.setup_test_evm_witness(\n",
+                "await ezkl.setup_test_evm_witness(\n",
                "    data_path,\n",
                "    compiled_model_path,\n",
                "    # we write the call data to the same file as the input data\n",
@@ -333,7 +333,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "res = ezkl.get_srs( settings_path)\n"
+                "res = await ezkl.get_srs( settings_path)\n"
            ]
        },
        {
@@ -354,7 +354,7 @@
                "\n",
                "witness_path = \"witness.json\"\n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
            ]
        },
        {
@@ -462,7 +462,7 @@
                "abi_path = 'test.abi'\n",
                "sol_code_path = 'test.sol'\n",
                "\n",
-                "res = ezkl.create_evm_verifier(\n",
+                "res = await ezkl.create_evm_verifier(\n",
                "        vk_path,\n",
                "        \n",
                "        settings_path,\n",
@@ -482,7 +482,7 @@
                "\n",
                "addr_path_verifier = \"addr_verifier.txt\"\n",
                "\n",
-                "res = ezkl.deploy_evm(\n",
+                "res = await ezkl.deploy_evm(\n",
                "    addr_path_verifier,\n",
                "    sol_code_path,\n",
                "    'http://127.0.0.1:3030'\n",
@@ -510,7 +510,7 @@
                "sol_code_path = 'test.sol'\n",
                "input_path = 'input.json'\n",
                "\n",
-                "res = ezkl.create_evm_data_attestation(\n",
+                "res = await ezkl.create_evm_data_attestation(\n",
                "        input_path,\n",
                "        settings_path,\n",
                "        sol_code_path,\n",
@@ -535,7 +535,7 @@
            "source": [
                "addr_path_da = \"addr_da.txt\"\n",
                "\n",
-                "res = ezkl.deploy_da_evm(\n",
+                "res = await ezkl.deploy_da_evm(\n",
                "        addr_path_da,\n",
                "        input_path,\n",
                "        settings_path,\n",
@@ -567,7 +567,7 @@
                "with open(addr_path_da, 'r') as f:\n",
                "    addr_da = f.read()\n",
                "\n",
-                "res = ezkl.verify_evm(\n",
+                "res = await ezkl.verify_evm(\n",
                "    addr,\n",
                "    proof_path,\n",
                "    RPC_URL,\n",
@@ -592,7 +592,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.2"
        },
        "orig_nbformat": 4
    },
--- a/examples/notebooks/data_attest_hashed.ipynb
+++ b/examples/notebooks/data_attest_hashed.ipynb
@@ -249,7 +249,7 @@
                "with open(cal_path, \"w\") as f:\n",
                "    json.dump(cal_data, f)\n",
                "\n",
-                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -278,7 +278,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "res = ezkl.get_srs( settings_path)\n"
+                "res = await ezkl.get_srs( settings_path)\n"
            ]
        },
        {
@@ -299,7 +299,7 @@
                "\n",
                "witness_path = \"witness.json\"\n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "\n"
            ]
        },
@@ -309,7 +309,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "print(ezkl.string_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.string_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",
@@ -518,7 +518,7 @@
                "abi_path = 'test.abi'\n",
                "sol_code_path = 'test.sol'\n",
                "\n",
-                "res = ezkl.create_evm_verifier(\n",
+                "res = await ezkl.create_evm_verifier(\n",
                "        vk_path,\n",
                "        \n",
                "        settings_path,\n",
@@ -538,7 +538,7 @@
                "\n",
                "addr_path_verifier = \"addr_verifier.txt\"\n",
                "\n",
-                "res = ezkl.deploy_evm(\n",
+                "res = await ezkl.deploy_evm(\n",
                "    addr_path_verifier,\n",
                "    sol_code_path,\n",
                "    'http://127.0.0.1:3030'\n",
@@ -566,7 +566,7 @@
                "sol_code_path = 'test.sol'\n",
                "input_path = 'input.json'\n",
                "\n",
-                "res = ezkl.create_evm_data_attestation(\n",
+                "res = await ezkl.create_evm_data_attestation(\n",
                "        input_path,\n",
                "        settings_path,\n",
                "        sol_code_path,\n",
@@ -591,7 +591,7 @@
            "source": [
                "addr_path_da = \"addr_da.txt\"\n",
                "\n",
-                "res = ezkl.deploy_da_evm(\n",
+                "res = await ezkl.deploy_da_evm(\n",
                "        addr_path_da,\n",
                "        input_path,\n",
                "        settings_path,\n",
@@ -623,7 +623,7 @@
                "with open(addr_path_da, 'r') as f:\n",
                "    addr_da = f.read()\n",
                "\n",
-                "res = ezkl.verify_evm(\n",
+                "res = await ezkl.verify_evm(\n",
                "    addr,\n",
                "    proof_path,\n",
                "    RPC_URL,\n",
@@ -648,10 +648,10 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.9.13"
+            "version": "3.9.15"
        },
        "orig_nbformat": 4
    },
    "nbformat": 4,
    "nbformat_minor": 2
-}
+}
--- a/examples/notebooks/data_attest_kzg_vis.ipynb
+++ b/examples/notebooks/data_attest_kzg_vis.ipynb
@@ -0,0 +1,604 @@
+{
+    "cells": [
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "# data-attest-kzg-vis\n",
+                "\n",
+                "Here's an example leveraging EZKL whereby the inputs to the model are read and attested to from an on-chain source and the params and outputs are committed to using kzg-commitments. \n",
+                "\n",
+                "In this setup:\n",
+                "- the inputs and outputs are publicly known to the prover and verifier\n",
+                "- the on chain inputs will be fetched and then fed directly into the circuit\n",
+                "- the quantization of the on-chain inputs happens within the evm and is replicated at proving time \n",
+                "- The kzg commitment to the params and inputs will be read from the proof and checked to make sure it matches the expected commitment stored on-chain.\n"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "First we import the necessary dependencies and set up logging to be as informative as possible. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# check if notebook is in colab\n",
+                "try:\n",
+                "    # install ezkl\n",
+                "    import google.colab\n",
+                "    import subprocess\n",
+                "    import sys\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
+                "\n",
+                "# rely on local installation of ezkl if the notebook is not in colab\n",
+                "except:\n",
+                "    pass\n",
+                "\n",
+                "\n",
+                "from torch import nn\n",
+                "import ezkl\n",
+                "import os\n",
+                "import json\n",
+                "import logging\n",
+                "\n",
+                "# uncomment for more descriptive logging \n",
+                "FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
+                "logging.basicConfig(format=FORMAT)\n",
+                "logging.getLogger().setLevel(logging.DEBUG)\n"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Now we define our model. It is a very simple PyTorch model that has just one layer, an average pooling 2D layer. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import torch\n",
+                "# Defines the model\n",
+                "\n",
+                "class MyModel(nn.Module):\n",
+                "    def __init__(self):\n",
+                "        super(MyModel, self).__init__()\n",
+                "        self.layer = nn.AvgPool2d(2, 1, (1, 1))\n",
+                "\n",
+                "    def forward(self, x):\n",
+                "        return self.layer(x)[0]\n",
+                "\n",
+                "\n",
+                "circuit = MyModel()\n",
+                "\n",
+                "# this is where you'd train your model"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "We omit training for purposes of this demonstration. We've marked where training would happen in the cell above. \n",
+                "Now we export the model to onnx and create a corresponding (randomly generated) input. This input data will eventually be stored on chain and read from according to the call_data field in the graph input.\n",
+                "\n",
+                "You can replace the random `x` with real data if you so wish. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "x = 0.1*torch.rand(1,*[3, 2, 2], requires_grad=True)\n",
+                "\n",
+                "# Flips the neural net into inference mode\n",
+                "circuit.eval()\n",
+                "\n",
+                "    # Export the model\n",
+                "torch.onnx.export(circuit,               # model being run\n",
+                "                      x,                   # model input (or a tuple for multiple inputs)\n",
+                "                      \"network.onnx\",            # where to save the model (can be a file or file-like object)\n",
+                "                      export_params=True,        # store the trained parameter weights inside the model file\n",
+                "                      opset_version=10,          # the ONNX version to export the model to\n",
+                "                      do_constant_folding=True,  # whether to execute constant folding for optimization\n",
+                "                      input_names = ['input'],   # the model's input names\n",
+                "                      output_names = ['output'], # the model's output names\n",
+                "                      dynamic_axes={'input' : {0 : 'batch_size'},    # variable length axes\n",
+                "                                    'output' : {0 : 'batch_size'}})\n",
+                "\n",
+                "data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
+                "\n",
+                "data = dict(input_data = [data_array])\n",
+                "\n",
+                "    # Serialize data into file:\n",
+                "json.dump(data, open(\"input.json\", 'w' ))\n",
+                "\n"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "We now define a function that will create a new anvil instance which we will deploy our test contract too. This contract will contain in its storage the data that we will read from and attest to. In production you would not need to set up a local anvil instance. Instead you would replace RPC_URL with the actual RPC endpoint of the chain you are deploying your verifiers too, reading from the data on said chain."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import subprocess\n",
+                "import time\n",
+                "import threading\n",
+                "\n",
+                "# make sure anvil is running locally\n",
+                "# $ anvil -p 3030\n",
+                "\n",
+                "RPC_URL = \"http://localhost:3030\"\n",
+                "\n",
+                "# Save process globally\n",
+                "anvil_process = None\n",
+                "\n",
+                "def start_anvil():\n",
+                "    global anvil_process\n",
+                "    if anvil_process is None:\n",
+                "        anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--code-size-limit=41943040\"])\n",
+                "        if anvil_process.returncode is not None:\n",
+                "            raise Exception(\"failed to start anvil process\")\n",
+                "        time.sleep(3)\n",
+                "\n",
+                "def stop_anvil():\n",
+                "    global anvil_process\n",
+                "    if anvil_process is not None:\n",
+                "        anvil_process.terminate()\n",
+                "        anvil_process = None\n"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
+                "- `input_visibility` defines the visibility of the model inputs\n",
+                "- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
+                "- `output_visibility` defines the visibility of the model outputs\n",
+                "\n",
+                "Here we create the following setup:\n",
+                "- `input_visibility`: \"public\"\n",
+                "- `param_visibility`: \"polycommitment\" \n",
+                "- `output_visibility`: \"polycommitment\"\n",
+                "\n",
+                "**Note**:\n",
+                "When we set this to polycommitment, we are saying that the model parameters are committed to using a polynomial commitment scheme. This commitment will be stored on chain as a constant stored in the DA contract, and the proof will contain the commitment to the parameters. The DA verification will then check that the commitment in the proof matches the commitment stored on chain. \n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import ezkl\n",
+                "\n",
+                "model_path = os.path.join('network.onnx')\n",
+                "compiled_model_path = os.path.join('network.compiled')\n",
+                "pk_path = os.path.join('test.pk')\n",
+                "vk_path = os.path.join('test.vk')\n",
+                "settings_path = os.path.join('settings.json')\n",
+                "srs_path = os.path.join('kzg.srs')\n",
+                "data_path = os.path.join('input.json')\n",
+                "\n",
+                "run_args = ezkl.PyRunArgs()\n",
+                "run_args.input_visibility = \"public\"\n",
+                "run_args.param_visibility = \"polycommit\"\n",
+                "run_args.output_visibility = \"polycommit\"\n",
+                "run_args.num_inner_cols = 1\n",
+                "run_args.variables = [(\"batch_size\", 1)]\n",
+                "\n",
+                "\n",
+                "\n"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
+                "\n",
+                "You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "!RUST_LOG=trace\n",
+                "# TODO: Dictionary outputs\n",
+                "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
+                "assert res == True"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# generate a bunch of dummy calibration data\n",
+                "cal_data = {\n",
+                "    \"input_data\": [(0.1*torch.rand(2, *[3, 2, 2])).flatten().tolist()],\n",
+                "}\n",
+                "\n",
+                "cal_path = os.path.join('val_data.json')\n",
+                "# save as json file\n",
+                "with open(cal_path, \"w\") as f:\n",
+                "    json.dump(cal_data, f)\n",
+                "\n",
+                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
+                "assert res == True"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "The graph input for on chain data sources is formatted completely differently compared to file based data sources.\n",
+                "\n",
+                "- For file data sources, the raw floating point values that eventually get quantized, converted into field elements and stored in `witness.json` to be consumed by the circuit are stored. The output data contains the expected floating point values returned as outputs from running your vanilla pytorch model on the given inputs.\n",
+                "- For on chain data sources, the input_data field contains all the data necessary to read and format the on chain data into something digestable by EZKL (aka field elements :-D). \n",
+                "Here is what the schema for an on-chain data source graph input file should look like:\n",
+                "    \n",
+                "```json\n",
+                "{\n",
+                "  \"input_data\": {\n",
+                "    \"rpc\": \"http://localhost:3030\", // The rpc endpoint of the chain you are deploying your verifier to\n",
+                "    \"calls\": [\n",
+                "      {\n",
+                "        \"call_data\": [\n",
+                "          [\n",
+                "            \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000000\", // The abi encoded call data to a view function that returns a single on-chain data point (we only support uint256 returns for now)\n",
+                "            7 // The number of decimal places of the large uint256 value. This is our way of representing large wei values as floating points on chain, since the evm only natively supports integer values.\n",
+                "          ],\n",
+                "          [\n",
+                "            \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000001\",\n",
+                "            5\n",
+                "          ],\n",
+                "          [\n",
+                "            \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000002\",\n",
+                "            5\n",
+                "          ]\n",
+                "        ],\n",
+                "        \"address\": \"5fbdb2315678afecb367f032d93f642f64180aa3\" // The address of the contract that we are calling to get the data. \n",
+                "      }\n",
+                "    ]\n",
+                "  }\n",
+                "}"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "await ezkl.setup_test_evm_witness(\n",
+                "    data_path,\n",
+                "    compiled_model_path,\n",
+                "    # we write the call data to the same file as the input data\n",
+                "    data_path,\n",
+                "    input_source=ezkl.PyTestDataSource.OnChain,\n",
+                "    output_source=ezkl.PyTestDataSource.File,\n",
+                "    rpc_url=RPC_URL)"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
+                "\n",
+                "These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "res = await ezkl.get_srs( settings_path)\n"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "We now need to generate the circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "!export RUST_BACKTRACE=1\n",
+                "\n",
+                "witness_path = \"witness.json\"\n",
+                "\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# HERE WE SETUP THE CIRCUIT PARAMS\n",
+                "# WE GOT KEYS\n",
+                "# WE GOT CIRCUIT PARAMETERS\n",
+                "# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
+                "res = ezkl.setup(\n",
+                "        compiled_model_path,\n",
+                "        vk_path,\n",
+                "        pk_path,\n",
+                "    )\n",
+                "\n",
+                "assert res == True\n",
+                "assert os.path.isfile(vk_path)\n",
+                "assert os.path.isfile(pk_path)\n",
+                "assert os.path.isfile(settings_path)"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Now we generate a full proof. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# GENERATE A PROOF\n",
+                "\n",
+                "proof_path = os.path.join('test.pf')\n",
+                "\n",
+                "res = ezkl.prove(\n",
+                "        witness_path,\n",
+                "        compiled_model_path,\n",
+                "        pk_path,\n",
+                "        proof_path,\n",
+                "        \n",
+                "        \"single\",\n",
+                "    )\n",
+                "\n",
+                "print(res)\n",
+                "assert os.path.isfile(proof_path)"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "And verify it as a sanity check. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# VERIFY IT\n",
+                "\n",
+                "res = ezkl.verify(\n",
+                "        proof_path,\n",
+                "        settings_path,\n",
+                "        vk_path,\n",
+                "        \n",
+                "    )\n",
+                "\n",
+                "assert res == True\n",
+                "print(\"verified\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "We can now create and then deploy a vanilla evm verifier."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "abi_path = 'test.abi'\n",
+                "sol_code_path = 'test.sol'\n",
+                "\n",
+                "res = await ezkl.create_evm_verifier(\n",
+                "        vk_path,\n",
+                "        \n",
+                "        settings_path,\n",
+                "        sol_code_path,\n",
+                "        abi_path,\n",
+                "    )\n",
+                "assert res == True"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "\n",
+                "addr_path_verifier = \"addr_verifier.txt\"\n",
+                "\n",
+                "res = await ezkl.deploy_evm(\n",
+                "    addr_path_verifier,\n",
+                "    sol_code_path,\n",
+                "    'http://127.0.0.1:3030'\n",
+                ")\n",
+                "\n",
+                "assert res == True"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "When deploying a DA with kzg commitments, we need to make sure to also pass a witness file that contains the commitments to the parameters and inputs. This is because the verifier will need to check that the commitments in the proof match the commitments stored on chain."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "\n",
+                "abi_path = 'test.abi'\n",
+                "sol_code_path = 'test.sol'\n",
+                "input_path = 'input.json'\n",
+                "\n",
+                "res = await ezkl.create_evm_data_attestation(\n",
+                "        input_path,\n",
+                "        settings_path,\n",
+                "        sol_code_path,\n",
+                "        abi_path,\n",
+                "        witness_path = witness_path,\n",
+                "    )"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Now we can deploy the data attest verifier contract. For security reasons, this binding will only deploy to a local anvil instance, using accounts generated by anvil. \n",
+                "So should only be used for testing purposes."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "addr_path_da = \"addr_da.txt\"\n",
+                "\n",
+                "res = await ezkl.deploy_da_evm(\n",
+                "        addr_path_da,\n",
+                "        input_path,\n",
+                "        settings_path,\n",
+                "        sol_code_path,\n",
+                "        RPC_URL,\n",
+                "    )\n"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# read the verifier address\n",
+                "addr_verifier = None\n",
+                "with open(addr_path_verifier, 'r') as f:\n",
+                "    addr = f.read()\n",
+                "#read the data attestation address\n",
+                "addr_da = None\n",
+                "with open(addr_path_da, 'r') as f:\n",
+                "    addr_da = f.read()\n",
+                "\n",
+                "res = await ezkl.verify_evm(\n",
+                "    addr,\n",
+                "    proof_path,\n",
+                "    RPC_URL,\n",
+                "    addr_da,\n",
+                ")"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "ezkl",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.9.13"
+        },
+        "orig_nbformat": 4
+    },
+    "nbformat": 4,
+    "nbformat_minor": 2
+}
--- a/examples/notebooks/decision_tree.ipynb
+++ b/examples/notebooks/decision_tree.ipynb
@@ -150,7 +150,7 @@
                "res = ezkl.gen_settings(model_path, settings_path)\n",
                "assert res == True\n",
                "\n",
-                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True"
            ]
        },
@@ -170,7 +170,7 @@
                "with open(cal_path, \"w\") as f:\n",
                "    json.dump(cal_data, f)\n",
                "\n",
-                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -192,7 +192,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -204,7 +204,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -303,4 +303,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/ezkl_demo.ipynb
+++ b/examples/notebooks/ezkl_demo.ipynb
@@ -352,14 +352,8 @@
        "# Specify all the files we need\n",
        "\n",
        "model_path = os.path.join('network.onnx')\n",
-        "compiled_model_path = os.path.join('network.ezkl')\n",
-        "pk_path = os.path.join('test.pk')\n",
-        "vk_path = os.path.join('test.vk')\n",
-        "settings_path = os.path.join('settings.json')\n",
-        "\n",
-        "witness_path = os.path.join('witness.json')\n",
        "data_path = os.path.join('input.json')\n",
-        "cal_data_path = os.path.join('cal_data.json')"
+        "cal_data_path = os.path.join('calibration.json')"
      ]
    },
    {
@@ -424,7 +418,7 @@
      "source": [
        "!RUST_LOG=trace\n",
        "# TODO: Dictionary outputs\n",
-        "res = ezkl.gen_settings(model_path, settings_path)\n",
+        "res = ezkl.gen_settings()\n",
        "assert res == True\n",
        "\n"
      ]
@@ -443,7 +437,7 @@
        "\n",
        "# Optimize for resources, we cap logrows at 12 to reduce setup and proving time, at the expense of accuracy\n",
        "# You may want to increase the max logrows if accuracy is a concern\n",
-        "res = ezkl.calibrate_settings(cal_data_path, model_path, settings_path, \"resources\", max_logrows = 12, scales = [2])"
+        "res = await ezkl.calibrate_settings(target = \"resources\", max_logrows = 12, scales = [2])"
      ]
    },
    {
@@ -463,7 +457,7 @@
      },
      "outputs": [],
      "source": [
-        "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
+        "res = ezkl.compile_circuit()\n",
        "assert res == True"
      ]
    },
@@ -484,7 +478,7 @@
      },
      "outputs": [],
      "source": [
-        "res = ezkl.get_srs( settings_path)"
+        "res = await ezkl.get_srs()"
      ]
    },
    {
@@ -504,17 +498,10 @@
      },
      "outputs": [],
      "source": [
-        "res = ezkl.setup(\n",
-        "        compiled_model_path,\n",
-        "        vk_path,\n",
-        "        pk_path,\n",
-        "    )\n",
+        "res = ezkl.setup()\n",
        "\n",
        "\n",
-        "assert res == True\n",
-        "assert os.path.isfile(vk_path)\n",
-        "assert os.path.isfile(pk_path)\n",
-        "assert os.path.isfile(settings_path)"
+        "assert res == True"
      ]
    },
    {
@@ -539,7 +526,7 @@
        "# now generate the witness file\n",
        "witness_path = os.path.join('witness.json')\n",
        "\n",
-        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = await ezkl.gen_witness()\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
@@ -559,13 +546,7 @@
        "\n",
        "proof_path = os.path.join('proof.json')\n",
        "\n",
-        "proof = ezkl.prove(\n",
-        "        witness_path,\n",
-        "        compiled_model_path,\n",
-        "        pk_path,\n",
-        "        proof_path,\n",
-        "        \"single\",\n",
-        "    )\n",
+        "proof = ezkl.prove(proof_type=\"single\", proof_path=proof_path)\n",
        "\n",
        "print(proof)\n",
        "assert os.path.isfile(proof_path)"
@@ -585,11 +566,7 @@
      "source": [
        "# verify our proof\n",
        "\n",
-        "res = ezkl.verify(\n",
-        "        proof_path,\n",
-        "        settings_path,\n",
-        "        vk_path,\n",
-        "    )\n",
+        "res = ezkl.verify()\n",
        "\n",
        "assert res == True\n",
        "print(\"verified\")"
@@ -664,12 +641,9 @@
        "sol_code_path = os.path.join('Verifier.sol')\n",
        "abi_path = os.path.join('Verifier.abi')\n",
        "\n",
-        "res = ezkl.create_evm_verifier(\n",
-        "        vk_path,\n",
-        "        \n",
-        "        settings_path,\n",
-        "        sol_code_path,\n",
-        "        abi_path\n",
+        "res = await ezkl.create_evm_verifier(\n",
+        "        sol_code_path=sol_code_path,\n",
+        "        abi_path=abi_path, \n",
        "    )\n",
        "\n",
        "assert res == True\n",
@@ -695,17 +669,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.string_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\"])"
      ]
    },
    {
@@ -755,7 +731,7 @@
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
-      "version": "3.9.15"
+      "version": "3.12.2"
    }
  },
  "nbformat": 4,
--- a/examples/notebooks/gcn.ipynb
+++ b/examples/notebooks/gcn.ipynb
@@ -467,7 +467,7 @@
      "outputs": [],
      "source": [
        "\n",
-        "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+        "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
        "assert res == True"
      ]
    },
@@ -494,7 +494,7 @@
      "outputs": [],
      "source": [
        "# srs path\n",
-        "res = ezkl.get_srs( settings_path)"
+        "res = await ezkl.get_srs( settings_path)"
      ]
    },
    {
@@ -508,7 +508,7 @@
      "source": [
        "# now generate the witness file\n",
        "\n",
-        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
@@ -625,4 +625,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/generalized_inverse.ipynb
+++ b/examples/notebooks/generalized_inverse.ipynb
@@ -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)"
      ]
@@ -195,7 +195,7 @@
        "json.dump(data, open(cal_path, 'w'))\n",
        "\n",
        "\n",
-        "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+        "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
        "assert res == True\n"
      ]
    },
@@ -222,7 +222,7 @@
      "outputs": [],
      "source": [
        "# srs path\n",
-        "res = ezkl.get_srs( settings_path)"
+        "res = await ezkl.get_srs( settings_path)"
      ]
    },
    {
@@ -236,7 +236,7 @@
      "source": [
        "# now generate the witness file\n",
        "\n",
-        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
@@ -340,4 +340,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/gradient_boosted_trees.ipynb
+++ b/examples/notebooks/gradient_boosted_trees.ipynb
@@ -179,7 +179,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -202,7 +202,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -214,7 +214,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -313,4 +313,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/hashed_vis.ipynb
+++ b/examples/notebooks/hashed_vis.ipynb
@@ -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",
@@ -241,7 +241,7 @@
                "with open(cal_path, \"w\") as f:\n",
                "    json.dump(cal_data, f)\n",
                "\n",
-                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -270,7 +270,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "res = ezkl.get_srs( settings_path)\n"
+                "res = await ezkl.get_srs( settings_path)\n"
            ]
        },
        {
@@ -291,7 +291,7 @@
                "\n",
                "witness_path = \"witness.json\"\n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
            ]
        },
        {
@@ -420,7 +420,7 @@
                "abi_path = 'test.abi'\n",
                "sol_code_path = 'test.sol'\n",
                "\n",
-                "res = ezkl.create_evm_verifier(\n",
+                "res = await ezkl.create_evm_verifier(\n",
                "        vk_path,\n",
                "        \n",
                "        settings_path,\n",
@@ -451,7 +451,7 @@
                "\n",
                "address_path = os.path.join(\"address.json\")\n",
                "\n",
-                "res = ezkl.deploy_evm(\n",
+                "res = await ezkl.deploy_evm(\n",
                "    address_path,\n",
                "    sol_code_path,\n",
                "    'http://127.0.0.1:3030'\n",
@@ -472,7 +472,7 @@
                "# make sure anvil is running locally\n",
                "# $ anvil -p 3030\n",
                "\n",
-                "res = ezkl.verify_evm(\n",
+                "res = await ezkl.verify_evm(\n",
                "    addr,\n",
                "    proof_path,\n",
                "    \"http://127.0.0.1:3030\"\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",
@@ -151,7 +152,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -174,7 +175,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs(settings_path = settings_path)"
+                "res = await ezkl.get_srs(settings_path = settings_path)"
            ]
        },
        {
@@ -187,7 +188,7 @@
                "# now generate the witness file \n",
                "witness_path = \"witness.json\"\n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -283,4 +284,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/kmeans.ipynb
+++ b/examples/notebooks/kmeans.ipynb
@@ -155,7 +155,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -178,7 +178,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -190,7 +190,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -289,4 +289,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/kzg_vis.ipynb
+++ b/examples/notebooks/kzg_vis.ipynb
@@ -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",
@@ -233,7 +233,7 @@
                "with open(cal_path, \"w\") as f:\n",
                "    json.dump(cal_data, f)\n",
                "\n",
-                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -262,7 +262,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "res = ezkl.get_srs( settings_path)\n"
+                "res = await ezkl.get_srs( settings_path)\n"
            ]
        },
        {
@@ -315,7 +315,7 @@
                "\n",
                "witness_path = \"witness.json\"\n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n"
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n"
            ]
        },
        {
@@ -429,7 +429,7 @@
                "abi_path = 'test.abi'\n",
                "sol_code_path = 'test.sol'\n",
                "\n",
-                "res = ezkl.create_evm_verifier(\n",
+                "res = await ezkl.create_evm_verifier(\n",
                "        vk_path,\n",
                "        \n",
                "        settings_path,\n",
@@ -460,7 +460,7 @@
                "\n",
                "address_path = os.path.join(\"address.json\")\n",
                "\n",
-                "res = ezkl.deploy_evm(\n",
+                "res = await ezkl.deploy_evm(\n",
                "    address_path,\n",
                "    sol_code_path,\n",
                "    'http://127.0.0.1:3030'\n",
@@ -481,7 +481,7 @@
                "# make sure anvil is running locally\n",
                "# $ anvil -p 3030\n",
                "\n",
-                "res = ezkl.verify_evm(\n",
+                "res = await ezkl.verify_evm(\n",
                "    addr,\n",
                "    proof_path,\n",
                "    \"http://127.0.0.1:3030\"\n",
@@ -512,4 +512,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 2
-}
+}
--- a/examples/notebooks/lightgbm.ipynb
+++ b/examples/notebooks/lightgbm.ipynb
@@ -193,7 +193,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -216,7 +216,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -228,7 +228,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -347,4 +347,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/linear_regression.ipynb
+++ b/examples/notebooks/linear_regression.ipynb
@@ -142,7 +142,7 @@
                "# Serialize data into file:\n",
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
-                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -165,7 +165,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -177,7 +177,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -276,4 +276,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/little_transformer.ipynb
+++ b/examples/notebooks/little_transformer.ipynb
@@ -347,7 +347,7 @@
                "# Serialize data into file:\n",
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
-                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -370,7 +370,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -383,7 +383,7 @@
                "# now generate the witness file \n",
                "witness_path = \"gan_witness.json\"\n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -490,4 +490,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/logistic_regression.ipynb
+++ b/examples/notebooks/logistic_regression.ipynb
@@ -0,0 +1,279 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
+            "metadata": {},
+            "source": [
+                "## Logistic Regression\n",
+                "\n",
+                "\n",
+                "Sklearn based models are slightly finicky to get into a suitable onnx format. \n",
+                "This notebook showcases how to do so using the `hummingbird-ml` python package for a Logistic Regression model. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "95613ee9",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# check if notebook is in colab\n",
+                "try:\n",
+                "    # install ezkl\n",
+                "    import google.colab\n",
+                "    import subprocess\n",
+                "    import sys\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"hummingbird-ml\"])\n",
+                "\n",
+                "# rely on local installation of ezkl if the notebook is not in colab\n",
+                "except:\n",
+                "    pass\n",
+                "\n",
+                "import os\n",
+                "import torch\n",
+                "import ezkl\n",
+                "import json\n",
+                "from hummingbird.ml import convert\n",
+                "\n",
+                "\n",
+                "# here we create and (potentially train a model)\n",
+                "\n",
+                "# make sure you have the dependencies required here already installed\n",
+                "import numpy as np\n",
+                "from sklearn.linear_model import LogisticRegression\n",
+                "X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])\n",
+                "# y = 1 * x_0 + 2 * x_1 + 3\n",
+                "y = np.dot(X, np.array([1, 2])) + 3\n",
+                "reg = LogisticRegression().fit(X, y)\n",
+                "reg.score(X, y)\n",
+                "\n",
+                "circuit = convert(reg, \"torch\", X[:1]).model\n",
+                "\n",
+                "\n",
+                "\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "b37637c4",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "model_path = os.path.join('network.onnx')\n",
+                "compiled_model_path = os.path.join('network.compiled')\n",
+                "pk_path = os.path.join('test.pk')\n",
+                "vk_path = os.path.join('test.vk')\n",
+                "settings_path = os.path.join('settings.json')\n",
+                "\n",
+                "witness_path = os.path.join('witness.json')\n",
+                "data_path = os.path.join('input.json')"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "82db373a",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "\n",
+                "\n",
+                "# export to onnx format\n",
+                "# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
+                "\n",
+                "# Input to the model\n",
+                "shape = X.shape[1:]\n",
+                "x = torch.rand(1, *shape, requires_grad=True)\n",
+                "torch_out = circuit(x)\n",
+                "# Export the model\n",
+                "torch.onnx.export(circuit,               # model being run\n",
+                "                  # model input (or a tuple for multiple inputs)\n",
+                "                  x,\n",
+                "                  # where to save the model (can be a file or file-like object)\n",
+                "                  \"network.onnx\",\n",
+                "                  export_params=True,        # store the trained parameter weights inside the model file\n",
+                "                  opset_version=10,          # the ONNX version to export the model to\n",
+                "                  do_constant_folding=True,  # whether to execute constant folding for optimization\n",
+                "                  input_names=['input'],   # the model's input names\n",
+                "                  output_names=['output'],  # the model's output names\n",
+                "                  dynamic_axes={'input': {0: 'batch_size'},    # variable length axes\n",
+                "                                'output': {0: 'batch_size'}})\n",
+                "\n",
+                "d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
+                "\n",
+                "data = dict(input_shapes=[shape],\n",
+                "            input_data=[d],\n",
+                "            output_data=[((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])\n",
+                "\n",
+                "# Serialize data into file:\n",
+                "json.dump(data, open(\"input.json\", 'w'))\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "d5e374a2",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "!RUST_LOG=trace\n",
+                "# TODO: Dictionary outputs\n",
+                "res = ezkl.gen_settings(model_path, settings_path)\n",
+                "assert res == True\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "cal_path = os.path.join(\"calibration.json\")\n",
+                "\n",
+                "data_array = (torch.randn(20, *shape).detach().numpy()).reshape([-1]).tolist()\n",
+                "\n",
+                "data = dict(input_data = [data_array])\n",
+                "\n",
+                "# Serialize data into file:\n",
+                "json.dump(data, open(cal_path, 'w'))\n",
+                "\n",
+                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "assert res == True\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "3aa4f090",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
+                "assert res == True"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "8b74dcee",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# srs path\n",
+                "res = await ezkl.get_srs( settings_path)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "18c8b7c7",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# now generate the witness file \n",
+                "\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "assert os.path.isfile(witness_path)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "b1c561a8",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "\n",
+                "# HERE WE SETUP THE CIRCUIT PARAMS\n",
+                "# WE GOT KEYS\n",
+                "# WE GOT CIRCUIT PARAMETERS\n",
+                "# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
+                "\n",
+                "\n",
+                "\n",
+                "res = ezkl.setup(\n",
+                "        compiled_model_path,\n",
+                "        vk_path,\n",
+                "        pk_path,\n",
+                "        \n",
+                "    )\n",
+                "\n",
+                "assert res == True\n",
+                "assert os.path.isfile(vk_path)\n",
+                "assert os.path.isfile(pk_path)\n",
+                "assert os.path.isfile(settings_path)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "c384cbc8",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# GENERATE A PROOF\n",
+                "\n",
+                "\n",
+                "proof_path = os.path.join('test.pf')\n",
+                "\n",
+                "res = ezkl.prove(\n",
+                "        witness_path,\n",
+                "        compiled_model_path,\n",
+                "        pk_path,\n",
+                "        proof_path,\n",
+                "        \n",
+                "        \"single\",\n",
+                "    )\n",
+                "\n",
+                "print(res)\n",
+                "assert os.path.isfile(proof_path)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "76f00d41",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# VERIFY IT\n",
+                "\n",
+                "res = ezkl.verify(\n",
+                "        proof_path,\n",
+                "        settings_path,\n",
+                "        vk_path,\n",
+                "        \n",
+                "    )\n",
+                "\n",
+                "assert res == True\n",
+                "print(\"verified\")"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "Python 3 (ipykernel)",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.12.2"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}
--- a/examples/notebooks/lstm.ipynb
+++ b/examples/notebooks/lstm.ipynb
@@ -139,7 +139,7 @@
                "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
                "assert res == True\n",
                "\n",
-                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n"
            ]
        },
@@ -180,7 +180,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -193,7 +193,7 @@
                "# now generate the witness file \n",
                "witness_path = \"lstmwitness.json\"\n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -300,4 +300,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/mean_postgres.ipynb
+++ b/examples/notebooks/mean_postgres.ipynb
@@ -7,9 +7,9 @@
        "## Mean of ERC20 transfer amounts\n",
        "\n",
        "This notebook shows how to calculate the mean of ERC20 transfer amounts, pulling data in from a Postgres database. First we install and get the necessary libraries running. \n",
-        "The first of which is [e2pg](https://github.com/indexsupply/x/tree/main/docs/e2pg), which is a library that allows us to pull data from the Ethereum blockchain into a Postgres database.\n",
+        "The first of which is [shovel](https://indexsupply.com/shovel/docs/#getting-started), which is a library that allows us to pull data from the Ethereum blockchain into a Postgres database.\n",
        "\n",
-        "Make sure you install postgres if needed https://postgresapp.com/. \n",
+        "Make sure you install postgres if needed https://indexsupply.com/shovel/docs/#getting-started. \n",
        "\n"
      ]
    },
@@ -21,23 +21,84 @@
      "source": [
        "import os\n",
        "import getpass\n",
-        "\n",
+        "import json\n",
+        "import time\n",
+        "import subprocess\n",
        "\n",
        "# swap out for the relevant linux/amd64, darwin/arm64, darwin/amd64, windows/amd64\n",
-        "os.system(\"curl -LO https://indexsupply.net/bin/main/linux/amd64/e2pg\")\n",
-        "os.system(\"chmod +x e2pg\")\n",
+        "os.system(\"curl -LO https://indexsupply.net/bin/1.0/linux/amd64/shovel\")\n",
+        "os.system(\"chmod +x shovel\")\n",
        "\n",
        "\n",
-        "os.environ[\"PG_URL\"] = \"postgresql://\" + getpass.getuser() + \":@localhost:5432/e2pg\"\n",
-        "os.environ[\"RLPS_URL\"] = \"https://1.rlps.indexsupply.net\"\n",
+        "os.environ[\"PG_URL\"] = \"postgres://\" + getpass.getuser() + \":@localhost:5432/shovel\"\n",
+        "\n",
+        "# create a config.json file with the following contents\n",
+        "config = {\n",
+        "  \"pg_url\": \"$PG_URL\",\n",
+        "  \"eth_sources\": [\n",
+        "    {\"name\": \"mainnet\", \"chain_id\": 1, \"url\": \"https://ethereum-rpc.publicnode.com\"},\n",
+        "    {\"name\": \"base\", \"chain_id\": 8453, \"url\": \"https://base-rpc.publicnode.com\"}\n",
+        "  ],\n",
+        "  \"integrations\": [{\n",
+        "    \"name\": \"usdc_transfer\",\n",
+        "    \"enabled\": True,\n",
+        "    \"sources\": [{\"name\": \"mainnet\"}, {\"name\": \"base\"}],\n",
+        "    \"table\": {\n",
+        "      \"name\": \"usdc\",\n",
+        "      \"columns\": [\n",
+        "        {\"name\": \"log_addr\",  \"type\": \"bytea\"},\n",
+        "        {\"name\": \"block_num\", \"type\": \"numeric\"},\n",
+        "        {\"name\": \"f\",         \"type\": \"bytea\"},\n",
+        "        {\"name\": \"t\",         \"type\": \"bytea\"},\n",
+        "        {\"name\": \"v\",         \"type\": \"numeric\"}\n",
+        "      ]\n",
+        "    },\n",
+        "    \"block\": [\n",
+        "      {\"name\": \"block_num\", \"column\": \"block_num\"},\n",
+        "      {\n",
+        "        \"name\": \"log_addr\",\n",
+        "        \"column\": \"log_addr\",\n",
+        "        \"filter_op\": \"contains\",\n",
+        "        \"filter_arg\": [\n",
+        "          \"a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48\",\n",
+        "          \"833589fCD6eDb6E08f4c7C32D4f71b54bdA02913\"\n",
+        "        ]\n",
+        "      }\n",
+        "    ],\n",
+        "    \"event\": {\n",
+        "      \"name\": \"Transfer\",\n",
+        "      \"type\": \"event\",\n",
+        "      \"anonymous\": False,\n",
+        "      \"inputs\": [\n",
+        "        {\"indexed\": True,  \"name\": \"from\",  \"type\": \"address\", \"column\": \"f\"},\n",
+        "        {\"indexed\": True,  \"name\": \"to\",    \"type\": \"address\", \"column\": \"t\"},\n",
+        "        {\"indexed\": False, \"name\": \"value\", \"type\": \"uint256\", \"column\": \"v\"}\n",
+        "      ]\n",
+        "    }\n",
+        "  }]\n",
+        "}\n",
+        "\n",
+        "# write the config to a file\n",
+        "with open(\"config.json\", \"w\") as f:\n",
+        "  f.write(json.dumps(config))\n",
+        "\n",
        "\n",
        "# print the two env variables\n",
        "os.system(\"echo $PG_URL\")\n",
-        "os.system(\"echo $RLPS_URL\")\n",
        "\n",
-        "os.system(\"createdb -h localhost -p 5432 e2pg\")\n",
-        "# equivalent of nohup ./e2pg -reset -e $RLPS_URL -pg $PG_URL &\n",
-        "e2pg_process = os.system(\"nohup ./e2pg -e $RLPS_URL -pg $PG_URL &\")\n",
+        "os.system(\"createdb -h localhost -p 5432 shovel\")\n",
+        "\n",
+        "os.system(\"echo shovel is now installed. starting:\")\n",
+        "\n",
+        "command = [\"./shovel\", \"-config\", \"config.json\"]\n",
+        "proc = subprocess.Popen(command)\n",
+        "\n",
+        "os.system(\"echo shovel started.\")\n",
+        "\n",
+        "time.sleep(10)\n",
+        "\n",
+        "# after we've fetched some data -- kill the process\n",
+        "proc.terminate()\n",
        "\n"
      ]
    },
@@ -79,11 +140,13 @@
        "import json\n",
        "import os\n",
        "\n",
-        "# import logging\n",
-        "# # # uncomment for more descriptive logging \n",
-        "# FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
-        "# logging.basicConfig(format=FORMAT)\n",
-        "# logging.getLogger().setLevel(logging.DEBUG)"
+        "import logging\n",
+        "# # uncomment for more descriptive logging \n",
+        "FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
+        "logging.basicConfig(format=FORMAT)\n",
+        "logging.getLogger().setLevel(logging.DEBUG)\n",
+        "\n",
+        "print(\"ezkl version: \", ezkl.__version__)"
      ]
    },
    {
@@ -176,6 +239,7 @@
      },
      "outputs": [],
      "source": [
+        "import getpass\n",
        "# make an input.json file from the df above\n",
        "input_filename = os.path.join('input.json')\n",
        "\n",
@@ -183,9 +247,9 @@
        "  \"host\": \"localhost\",\n",
        "  # make sure you replace this with your own username\n",
        "  \"user\": getpass.getuser(),\n",
-        "  \"dbname\": \"e2pg\",\n",
+        "  \"dbname\": \"shovel\",\n",
        "  \"password\": \"\",\n",
-        "  \"query\": \"SELECT value FROM erc20_transfers ORDER BY block_number DESC LIMIT 5\",\n",
+        "  \"query\": \"SELECT v FROM usdc ORDER BY block_num DESC LIMIT 5\",\n",
        "  \"port\": \"5432\",\n",
        "})\n",
        "\n",
@@ -194,7 +258,7 @@
        "\n",
        "\n",
        "    # Serialize data into file:\n",
-        "json.dump( pg_input_file, open(input_filename, 'w' ))\n"
+        "json.dump(pg_input_file, open(input_filename, 'w' ))\n"
      ]
    },
    {
@@ -210,9 +274,9 @@
        "  \"host\": \"localhost\",\n",
        "  # make sure you replace this with your own username\n",
        "  \"user\": getpass.getuser(),\n",
-        "  \"dbname\": \"e2pg\",\n",
+        "  \"dbname\": \"shovel\",\n",
        "  \"password\": \"\",\n",
-        "  \"query\": \"SELECT value FROM erc20_transfers ORDER BY block_number DESC LIMIT 20\",\n",
+        "  \"query\": \"SELECT v FROM usdc ORDER BY block_num DESC LIMIT 20\",\n",
        "  \"port\": \"5432\",\n",
        "})\n",
        "\n",
@@ -229,22 +293,6 @@
        "**EZKL Workflow**"
      ]
    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "onnx_filename = os.path.join('lol.onnx')\n",
-        "compiled_filename = os.path.join('lol.compiled')\n",
-        "settings_filename = os.path.join('settings.json')\n",
-        "\n",
-        "ezkl.gen_settings(onnx_filename, settings_filename)\n",
-        "\n",
-        "ezkl.calibrate_settings(\n",
-        "    input_filename, onnx_filename, settings_filename, \"resources\")"
-      ]
-    },
    {
      "cell_type": "code",
      "execution_count": null,
@@ -253,10 +301,21 @@
      },
      "outputs": [],
      "source": [
-        "# setup kzg params\n",
-        "params_path = os.path.join('kzg.params')\n",
+        "import subprocess\n",
+        "import os\n",
        "\n",
-        "res = ezkl.get_srs(params_path, settings_filename)"
+        "onnx_filename = os.path.join('lol.onnx')\n",
+        "compiled_filename = os.path.join('lol.compiled')\n",
+        "settings_filename = os.path.join('settings.json')\n",
+        "\n",
+        "# Generate settings using ezkl\n",
+        "res = ezkl.gen_settings(onnx_filename, settings_filename)\n",
+        "\n",
+        "assert res == True\n",
+        "\n",
+        "res = await ezkl.calibrate_settings(input_filename, onnx_filename, settings_filename, \"resources\")\n",
+        "\n",
+        "assert res == True"
      ]
    },
    {
@@ -306,16 +365,13 @@
      "source": [
        "pk_path = os.path.join('test.pk')\n",
        "vk_path = os.path.join('test.vk')\n",
-        "params_path = os.path.join('kzg.params')\n",
        "\n",
        "\n",
        "# setup the proof\n",
        "res = ezkl.setup(\n",
        "        compiled_filename,\n",
        "        vk_path,\n",
-        "        pk_path,\n",
-        "        params_path,\n",
-        "        settings_filename,\n",
+        "        pk_path\n",
        "    )\n",
        "\n",
        "assert res == True\n",
@@ -331,11 +387,14 @@
      "metadata": {},
      "outputs": [],
      "source": [
-        "\n",
        "witness_path = \"witness.json\"\n",
        "\n",
-        "res = ezkl.gen_witness(input_filename, compiled_filename, witness_path)\n",
-        "assert os.path.isfile(witness_path)"
+        "# generate the witness\n",
+        "res = await ezkl.gen_witness(\n",
+        "        input_filename,\n",
+        "        compiled_filename,\n",
+        "        witness_path\n",
+        "    )\n"
      ]
    },
    {
@@ -360,126 +419,14 @@
        "        compiled_filename,\n",
        "        pk_path,\n",
        "        proof_path,\n",
-        "        params_path,\n",
-        "        \"single\",\n",
+        "        \"single\"\n",
        "    )\n",
        "\n",
        "\n",
+        "print(\"proved\")\n",
+        "\n",
        "assert os.path.isfile(proof_path)\n",
-        "\n",
-        "# verify\n",
-        "res = ezkl.verify(\n",
-        "        proof_path,\n",
-        "        settings_filename,\n",
-        "        vk_path,\n",
-        "        params_path,\n",
-        "    )\n",
-        "\n",
-        "assert res == True\n",
-        "print(\"verified\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "W7tAa-DFAtvS"
-      },
-      "source": [
-        "# Part 2 (Using the ZK Computational Graph Onchain!)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "8Ym91kaVAIB6"
-      },
-      "source": [
-        "**Now How Do We Do It Onchain?????**"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 339
-        },
-        "id": "fodkNgwS70FM",
-        "outputId": "827b5efd-f74f-44de-c114-861b3a86daf2"
-      },
-      "outputs": [],
-      "source": [
-        "# first we need to create evm verifier\n",
-        "print(vk_path)\n",
-        "print(params_path)\n",
-        "print(settings_filename)\n",
-        "\n",
-        "\n",
-        "abi_path = 'test.abi'\n",
-        "sol_code_path = 'test.sol'\n",
-        "\n",
-        "res = ezkl.create_evm_verifier(\n",
-        "        vk_path,\n",
-        "        params_path,\n",
-        "        settings_filename,\n",
-        "        sol_code_path,\n",
-        "        abi_path,\n",
-        "    )\n",
-        "assert res == True"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# Make sure anvil is running locally first\n",
-        "# run with $ anvil -p 3030\n",
-        "# we use the default anvil node here\n",
-        "import json\n",
-        "\n",
-        "address_path = os.path.join(\"address.json\")\n",
-        "\n",
-        "res = ezkl.deploy_evm(\n",
-        "    address_path,\n",
-        "    sol_code_path,\n",
-        "    'http://127.0.0.1:3030'\n",
-        ")\n",
-        "\n",
-        "assert res == True\n",
-        "\n",
-        "with open(address_path, 'r') as file:\n",
-        "    addr = file.read().rstrip()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# read the address from addr_path\n",
-        "addr = None\n",
-        "with open(address_path, 'r') as f:\n",
-        "    addr = f.read()\n",
-        "\n",
-        "res = ezkl.verify_evm(\n",
-        "    addr,\n",
-        "    proof_path,\n",
-        "    \"http://127.0.0.1:3030\"\n",
-        ")\n",
-        "assert res == True"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "os.system(\"killall -9 e2pg\");"
+        "\n"
      ]
    }
  ],
@@ -501,7 +448,7 @@
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
-      "version": "3.9.13"
+      "version": "3.12.2"
    }
  },
  "nbformat": 4,
--- a/examples/notebooks/mnist_classifier.ipynb
+++ b/examples/notebooks/mnist_classifier.ipynb
@@ -323,7 +323,7 @@
        "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
        "assert res == True\n",
        "\n",
-        "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[2,7])\n",
+        "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[2,7])\n",
        "assert res == True"
      ]
    },
@@ -348,7 +348,7 @@
      "outputs": [],
      "source": [
        "# srs path\n",
-        "res = ezkl.get_srs(settings_path)"
+        "res = await ezkl.get_srs(settings_path)"
      ]
    },
    {
@@ -362,7 +362,7 @@
        "# now generate the witness file\n",
        "witness_path = \"witness.json\"\n",
        "\n",
-        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
@@ -469,7 +469,7 @@
        "abi_path = 'test.abi'\n",
        "sol_code_path = 'test_1.sol'\n",
        "\n",
-        "res = ezkl.create_evm_verifier(\n",
+        "res = await ezkl.create_evm_verifier(\n",
        "        vk_path,\n",
        "        settings_path,\n",
        "        sol_code_path,\n",
@@ -502,7 +502,7 @@
        "\n",
        "address_path = os.path.join(\"address.json\")\n",
        "\n",
-        "res = ezkl.deploy_evm(\n",
+        "res = await ezkl.deploy_evm(\n",
        "    address_path,\n",
        "    sol_code_path,\n",
        "    'http://127.0.0.1:3030'\n",
@@ -525,7 +525,7 @@
        "# make sure anvil is running locally\n",
        "# $ anvil -p 3030\n",
        "\n",
-        "res = ezkl.verify_evm(\n",
+        "res = await ezkl.verify_evm(\n",
        "    addr,\n",
        "    proof_path,\n",
        "    \"http://127.0.0.1:3030\"\n",
@@ -558,4 +558,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 0
-}
+}
--- a/examples/notebooks/mnist_gan.ipynb
+++ b/examples/notebooks/mnist_gan.ipynb
@@ -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",
@@ -284,7 +289,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[0,6])"
+                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[0,6])"
            ]
        },
        {
@@ -304,7 +309,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -316,7 +321,7 @@
                "# now generate the witness file \n",
                "witness_path = \"gan_witness.json\"\n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -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
@@ -215,7 +215,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -235,7 +235,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -247,7 +247,7 @@
                "# now generate the witness file\n",
                "witness_path = \"ae_witness.json\"\n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -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",
@@ -449,7 +451,7 @@
                "res = ezkl.gen_settings(model_path, settings_path)\n",
                "assert res == True\n",
                "\n",
-                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True\n",
                "print(\"verified\")"
            ]
@@ -471,7 +473,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -483,7 +485,7 @@
                "# now generate the witness file \n",
                "witness_path = \"vae_witness.json\"\n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
--- a/examples/notebooks/nbeats_timeseries_forecasting.ipynb
+++ b/examples/notebooks/nbeats_timeseries_forecasting.ipynb
@@ -845,7 +845,7 @@
        "res = ezkl.gen_settings(model_path, settings_path)\n",
        "assert res == True\n",
        "\n",
-        "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", max_logrows = 20, scales = [3])\n",
+        "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", max_logrows = 20, scales = [3])\n",
        "assert res == True"
      ]
    },
@@ -870,7 +870,7 @@
      "outputs": [],
      "source": [
        "# srs path\n",
-        "res = ezkl.get_srs( settings_path)"
+        "res = await ezkl.get_srs( settings_path)"
      ]
    },
    {
@@ -881,7 +881,7 @@
      },
      "outputs": [],
      "source": [
-        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
@@ -993,4 +993,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 0
-}
+}
--- a/examples/notebooks/proof_splitting.ipynb
+++ b/examples/notebooks/proof_splitting.ipynb
@@ -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)"
            ]
        },
        {
@@ -261,7 +261,7 @@
            "source": [
                "# iterate over each submodel gen-settings, compile circuit and setup zkSNARK\n",
                "\n",
-                "def setup(i):\n",
+                "async def setup(i):\n",
                "    # file names\n",
                "    model_path = os.path.join('network_split_'+str(i)+'.onnx')\n",
                "    settings_path = os.path.join('settings_split_'+str(i)+'.json')\n",
@@ -282,7 +282,7 @@
                "\n",
                "    # generate settings for the current model\n",
                "    res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
-                "    res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", scales=[run_args.input_scale], max_logrows=run_args.logrows)\n",
+                "    res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", scales=[run_args.input_scale], max_logrows=run_args.logrows)\n",
                "    assert res == True\n",
                "\n",
                "    # load settings and print them to the console\n",
@@ -303,11 +303,11 @@
                "    assert os.path.isfile(vk_path)\n",
                "    assert os.path.isfile(pk_path)\n",
                "\n",
-                "    res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
+                "    res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
                "    run_args.input_scale = settings[\"model_output_scales\"][0]\n",
                "\n",
                "for i in range(2):\n",
-                "    setup(i)\n"
+                "    await setup(i)\n"
            ]
        },
        {
@@ -385,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"
            ]
        },
        {
@@ -399,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"
@@ -414,7 +414,7 @@
            "outputs": [],
            "source": [
                "for i in range(2):\n",
-                "    setup(i)"
+                "    await setup(i)"
            ]
        },
        {
@@ -466,7 +466,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.2"
        },
        "orig_nbformat": 4
    },
--- 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"
@@ -193,7 +174,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -215,7 +196,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -227,7 +208,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -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
@@ -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_string(e,7))\n",
-        "    result.append(ezkl.poseidon_hash([ezkl.float_to_string(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",
@@ -215,7 +215,7 @@
      "outputs": [],
      "source": [
        "# srs path\n",
-        "res = ezkl.get_srs( settings_path)"
+        "res = await ezkl.get_srs( settings_path)"
      ]
    },
    {
@@ -229,7 +229,7 @@
      "source": [
        "# now generate the witness file\n",
        "\n",
-        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
@@ -265,7 +265,7 @@
        "    # Serialize data into file:\n",
        "json.dump( data, open(data_path_faulty, 'w' ))\n",
        "\n",
-        "res = ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path_faulty)\n",
+        "res = await ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path_faulty)\n",
        "assert os.path.isfile(witness_path_faulty)"
      ]
    },
@@ -310,7 +310,7 @@
        "# Serialize data into file:\n",
        "json.dump( data, open(data_path_truthy, 'w' ))\n",
        "\n",
-        "res = ezkl.gen_witness(data_path_truthy, compiled_model_path, witness_path_truthy)\n",
+        "res = await ezkl.gen_witness(data_path_truthy, compiled_model_path, witness_path_truthy)\n",
        "assert os.path.isfile(witness_path_truthy)"
      ]
    },
@@ -482,7 +482,7 @@
      "source": [
        "import pytest\n",
        "def test_verification():\n",
-        "    with pytest.raises(RuntimeError, match='Failed to run verify: The constraint system is not satisfied'):\n",
+        "    with pytest.raises(RuntimeError, match='Failed to run verify: \\\\[halo2\\\\] The constraint system is not satisfied'):\n",
        "        ezkl.verify(\n",
        "            proof_path_faulty,\n",
        "            settings_path,\n",
@@ -514,7 +514,7 @@
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
-      "version": "3.9.15"
+      "version": "3.12.3"
    }
  },
  "nbformat": 4,
--- a/examples/notebooks/simple_demo_aggregated_proofs.ipynb
+++ b/examples/notebooks/simple_demo_aggregated_proofs.ipynb
@@ -193,7 +193,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -205,7 +205,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -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 = await ezkl.get_srs(settings_path=None, logrows=21, commitment=ezkl.PyCommitments.KZG)"
            ]
        },
        {
@@ -375,7 +374,7 @@
                "sol_code_path = os.path.join(\"Verifier.sol\")\n",
                "abi_path = os.path.join(\"Verifier_ABI.json\")\n",
                "\n",
-                "res = ezkl.create_evm_verifier_aggr(\n",
+                "res = await ezkl.create_evm_verifier_aggr(\n",
                "    [settings_path],\n",
                "    aggregate_vk_path,\n",
                "    sol_code_path,\n",
@@ -405,4 +404,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/simple_demo_all_public.ipynb
+++ b/examples/notebooks/simple_demo_all_public.ipynb
@@ -157,6 +157,7 @@
        {
            "cell_type": "code",
            "execution_count": null,
+            "id": "b78d3cbf",
            "metadata": {},
            "outputs": [],
            "source": [
@@ -170,7 +171,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -204,7 +205,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -298,7 +299,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.3"
        }
    },
    "nbformat": 4,
--- a/examples/notebooks/simple_demo_public_input_output.ipynb
+++ b/examples/notebooks/simple_demo_public_input_output.ipynb
@@ -169,7 +169,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -191,7 +191,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -203,7 +203,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
--- a/examples/notebooks/simple_demo_public_network_output.ipynb
+++ b/examples/notebooks/simple_demo_public_network_output.ipynb
@@ -170,7 +170,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -192,7 +192,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -204,7 +204,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
--- a/examples/notebooks/sklearn_mlp.ipynb
+++ b/examples/notebooks/sklearn_mlp.ipynb
@@ -149,7 +149,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -171,7 +171,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -183,7 +183,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -282,4 +282,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/solvency.ipynb
+++ b/examples/notebooks/solvency.ipynb
@@ -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_string(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",
@@ -250,7 +250,7 @@
      "outputs": [],
      "source": [
        "# srs path\n",
-        "res = ezkl.get_srs( settings_path)"
+        "res = await ezkl.get_srs( settings_path)"
      ]
    },
    {
@@ -297,13 +297,13 @@
        "\n",
        "witness_path = \"witness.json\"\n",
        "\n",
-        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
+        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
        "assert os.path.isfile(witness_path)\n",
        "\n",
        "# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
        "# 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_string(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_felt(1.0, 0)]\n",
        "json.dump(witness, open(witness_path, \"w\"))"
      ]
    },
@@ -411,13 +411,13 @@
      "source": [
        "# now generate the witness file\n",
        "\n",
-        "res = ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path, vk_path)\n",
+        "res = await ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path, vk_path)\n",
        "assert os.path.isfile(witness_path)\n",
        "\n",
        "# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
        "# 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_string(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_felt(1.0, 0)]\n",
        "json.dump(witness, open(witness_path, \"w\"))\n"
      ]
    },
@@ -478,12 +478,11 @@
        "import pytest\n",
        "\n",
        "def test_verification():\n",
-        "    with pytest.raises(RuntimeError, match='Failed to run verify: The constraint system is not satisfied'):\n",
+        "    with pytest.raises(RuntimeError, match='Failed to run verify: \\\\[halo2\\\\] The constraint system is not satisfied'):\n",
        "        ezkl.verify(\n",
        "            proof_path,\n",
        "            settings_path,\n",
        "            vk_path,\n",
-        "            \n",
        "        )\n",
        "\n",
        "# Run the test function\n",
@@ -510,7 +509,7 @@
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
-      "version": "3.9.13"
+      "version": "3.12.3"
    }
  },
  "nbformat": 4,
--- a/examples/notebooks/stacked_regression.ipynb
+++ b/examples/notebooks/stacked_regression.ipynb
@@ -167,7 +167,7 @@
                "res = ezkl.gen_settings(model_path, settings_path)\n",
                "assert res == True\n",
                "\n",
-                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True"
            ]
        },
@@ -187,7 +187,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -209,7 +209,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -221,7 +221,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -320,4 +320,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/svm.ipynb
+++ b/examples/notebooks/svm.ipynb
@@ -180,7 +180,7 @@
                "json.dump(data, open(cal_path, 'w'))\n",
                "\n",
                "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -202,7 +202,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -214,7 +214,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -420,7 +420,7 @@
                "res = ezkl.gen_settings(model_path, settings_path)\n",
                "assert res == True\n",
                "\n",
-                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                "assert res == True"
            ]
        }
@@ -446,4 +446,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/tictactoe_autoencoder.ipynb
+++ b/examples/notebooks/tictactoe_autoencoder.ipynb
@@ -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\", scales = [4])"
+                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [11])"
            ]
        },
        {
@@ -642,7 +646,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "ezkl.get_srs( settings_path)"
+                "await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -664,7 +668,6 @@
                "    compiled_model_path,\n",
                "    vk_path,\n",
                "    pk_path,\n",
-                "    \n",
                ")"
            ]
        },
@@ -680,7 +683,7 @@
                "    data = json.load(f)\n",
                "    print(len(data['input_data'][0]))\n",
                "\n",
-                "ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
+                "await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
            ]
        },
        {
@@ -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\", scales = [4])"
+                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [4])"
            ]
        },
        {
@@ -567,7 +572,7 @@
                "    data = json.load(f)\n",
                "    print(len(data['input_data'][0]))\n",
                "\n",
-                "ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
+                "await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
            ]
        },
        {
@@ -637,7 +642,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.12.2"
        }
    },
    "nbformat": 4,
--- a/examples/notebooks/variance.ipynb
+++ b/examples/notebooks/variance.ipynb
@@ -24,7 +24,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 1,
      "metadata": {
        "id": "9Byiv2Nc2MsK"
      },
@@ -49,7 +49,11 @@
        "import pandas as pd\n",
        "import requests\n",
        "import json\n",
-        "import os"
+        "import os\n",
+        "\n",
+        "import logging\n",
+        "\n",
+        "logging.basicConfig(level=logging.INFO)"
      ]
    },
    {
@@ -63,7 +67,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
@@ -71,7 +75,15 @@
        "id": "x1vl9ZXF3EEW",
        "outputId": "bda21d02-fe5f-4fb2-8106-f51a8e2e67aa"
      },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "cpu\n"
+          ]
+        }
+      ],
      "source": [
        "from torch import nn\n",
        "import torch\n",
@@ -133,7 +145,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
@@ -141,7 +153,18 @@
        "id": "6RAMplxk5xPk",
        "outputId": "bd2158fe-0c00-44fd-e632-6a3f70cdb7c9"
      },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "1715422870\n",
+            "1714818070\n",
+            "https://api.coingecko.com/api/v3/coins/ethereum/market_chart/range?vs_currency=usd&from=1714818070&to=1715422870\n",
+            "<Response [200]>\n"
+          ]
+        }
+      ],
      "source": [
        "\n",
        "def get_url(coin, currency, start, end):\n",
@@ -174,7 +197,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
@@ -183,7 +206,115 @@
        "id": "WSj1Uxln65vf",
        "outputId": "51422d71-9680-4b51-c4df-e400d20f988b"
      },
-      "outputs": [],
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>time</th>\n",
+              "      <th>prices</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>1714820485367</td>\n",
+              "      <td>3146.785806</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>1714824033868</td>\n",
+              "      <td>3127.968728</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>1714828058243</td>\n",
+              "      <td>3156.141681</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>1714831650751</td>\n",
+              "      <td>3124.834064</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>1714834972229</td>\n",
+              "      <td>3133.115333</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>...</th>\n",
+              "      <td>...</td>\n",
+              "      <td>...</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>163</th>\n",
+              "      <td>1715407579346</td>\n",
+              "      <td>2918.049749</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>164</th>\n",
+              "      <td>1715411090715</td>\n",
+              "      <td>2920.330834</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>165</th>\n",
+              "      <td>1715414554830</td>\n",
+              "      <td>2923.986611</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>166</th>\n",
+              "      <td>1715418419843</td>\n",
+              "      <td>2910.537671</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>167</th>\n",
+              "      <td>1715421675338</td>\n",
+              "      <td>2907.702307</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "<p>168 rows × 2 columns</p>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "              time       prices\n",
+              "0    1714820485367  3146.785806\n",
+              "1    1714824033868  3127.968728\n",
+              "2    1714828058243  3156.141681\n",
+              "3    1714831650751  3124.834064\n",
+              "4    1714834972229  3133.115333\n",
+              "..             ...          ...\n",
+              "163  1715407579346  2918.049749\n",
+              "164  1715411090715  2920.330834\n",
+              "165  1715414554830  2923.986611\n",
+              "166  1715418419843  2910.537671\n",
+              "167  1715421675338  2907.702307\n",
+              "\n",
+              "[168 rows x 2 columns]"
+            ]
+          },
+          "execution_count": 4,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
      "source": [
        "df = pd.DataFrame(new_data)\n",
        "df\n"
@@ -200,7 +331,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 5,
      "metadata": {},
      "outputs": [],
      "source": [
@@ -217,7 +348,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
@@ -225,7 +356,98 @@
        "id": "4MmE9SX66_Il",
        "outputId": "16403639-66a4-4280-ac7f-6966b75de5a3"
      },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "INFO:ezkl.execute:SRS already exists at that path\n",
+            "INFO:ezkl.execute:num calibration batches: 1\n",
+            "INFO:ezkl.execute:read 16777476 bytes from file (vector of len = 16777476)\n",
+            "WARNING:ezkl.execute:\n",
+            "\n",
+            " <------------- Numerical Fidelity Report (input_scale: 4, param_scale: 4, scale_input_multiplier: 10) ------------->\n",
+            "\n",
+            "+------------+--------------+-----------+-----------+----------------+------------------+---------------+---------------+--------------------+--------------------+------------------------+\n",
+            "| mean_error | median_error | max_error | min_error | mean_abs_error | median_abs_error | max_abs_error | min_abs_error | mean_squared_error | mean_percent_error | mean_abs_percent_error |\n",
+            "+------------+--------------+-----------+-----------+----------------+------------------+---------------+---------------+--------------------+--------------------+------------------------+\n",
+            "| -727.9929  | -727.9929    | -727.9929 | -727.9929 | 727.9929       | 727.9929         | 727.9929      | 727.9929      | 529973.7           | -0.24999964        | 0.24999964             |\n",
+            "+------------+--------------+-----------+-----------+----------------+------------------+---------------+---------------+--------------------+--------------------+------------------------+\n",
+            "\n",
+            "\n",
+            "INFO:ezkl.execute:file hash: 41509f380362a8d14401c5ae92073154922fe23e45459ce6f696f58607655db7\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{\n",
+            "  \"run_args\": {\n",
+            "    \"tolerance\": {\n",
+            "      \"val\": 0.0,\n",
+            "      \"scale\": 1.0\n",
+            "    },\n",
+            "    \"input_scale\": 4,\n",
+            "    \"param_scale\": 4,\n",
+            "    \"scale_rebase_multiplier\": 10,\n",
+            "    \"lookup_range\": [\n",
+            "      0,\n",
+            "      0\n",
+            "    ],\n",
+            "    \"logrows\": 6,\n",
+            "    \"num_inner_cols\": 2,\n",
+            "    \"variables\": [\n",
+            "      [\n",
+            "        \"batch_size\",\n",
+            "        1\n",
+            "      ]\n",
+            "    ],\n",
+            "    \"input_visibility\": \"Private\",\n",
+            "    \"output_visibility\": \"Public\",\n",
+            "    \"param_visibility\": \"Private\",\n",
+            "    \"div_rebasing\": false,\n",
+            "    \"rebase_frac_zero_constants\": false,\n",
+            "    \"check_mode\": \"UNSAFE\",\n",
+            "    \"commitment\": \"KZG\"\n",
+            "  },\n",
+            "  \"num_rows\": 21,\n",
+            "  \"total_assignments\": 42,\n",
+            "  \"total_const_size\": 0,\n",
+            "  \"total_dynamic_col_size\": 0,\n",
+            "  \"num_dynamic_lookups\": 0,\n",
+            "  \"num_shuffles\": 0,\n",
+            "  \"total_shuffle_col_size\": 0,\n",
+            "  \"model_instance_shapes\": [\n",
+            "    [\n",
+            "      1\n",
+            "    ]\n",
+            "  ],\n",
+            "  \"model_output_scales\": [\n",
+            "    8\n",
+            "  ],\n",
+            "  \"model_input_scales\": [\n",
+            "    4\n",
+            "  ],\n",
+            "  \"module_sizes\": {\n",
+            "    \"polycommit\": [],\n",
+            "    \"poseidon\": [\n",
+            "      0,\n",
+            "      [\n",
+            "        0\n",
+            "      ]\n",
+            "    ]\n",
+            "  },\n",
+            "  \"required_lookups\": [],\n",
+            "  \"required_range_checks\": [],\n",
+            "  \"check_mode\": \"UNSAFE\",\n",
+            "  \"version\": \"0.0.0\",\n",
+            "  \"num_blinding_factors\": null,\n",
+            "  \"timestamp\": 1715422871248\n",
+            "}\n"
+          ]
+        }
+      ],
      "source": [
        "# generate settings\n",
        "onnx_filename = os.path.join('lol.onnx')\n",
@@ -236,9 +458,9 @@
        "\n",
        "\n",
        "ezkl.gen_settings(onnx_filename, settings_filename)\n",
-        "ezkl.calibrate_settings(\n",
+        "await ezkl.calibrate_settings(\n",
        "    input_filename, onnx_filename, settings_filename, \"resources\", scales = [4])\n",
-        "res = ezkl.get_srs(settings_filename)\n",
+        "res = await ezkl.get_srs(settings_filename)\n",
        "ezkl.compile_circuit(onnx_filename, compiled_filename, settings_filename)\n",
        "\n",
        "# show the settings.json\n",
@@ -259,7 +481,24 @@
      "metadata": {
        "id": "fULvvnK7_CMb"
      },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "INFO:ezkl.pfsys.srs:loading srs from \"/Users/dante/.ezkl/srs/kzg6.srs\"\n",
+            "INFO:ezkl.execute:downsizing params to 6 logrows\n",
+            "INFO:ezkl.graph.model:model layout...\n",
+            "INFO:ezkl.pfsys:VK took 0.8\n",
+            "INFO:ezkl.graph.model:model layout...\n",
+            "INFO:ezkl.pfsys:PK took 0.2\n",
+            "INFO:ezkl.pfsys:saving verification key 💾\n",
+            "INFO:ezkl.pfsys:done saving verification key ✅\n",
+            "INFO:ezkl.pfsys:saving proving key 💾\n",
+            "INFO:ezkl.pfsys:done saving proving key ✅\n"
+          ]
+        }
+      ],
      "source": [
        "pk_path = os.path.join('test.pk')\n",
        "vk_path = os.path.join('test.vk')\n",
@@ -281,20 +520,20 @@
    },
    {
      "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 8,
      "metadata": {},
      "outputs": [],
      "source": [
        "\n",
        "witness_path = \"witness.json\"\n",
        "\n",
-        "res = ezkl.gen_witness(input_filename, compiled_filename, witness_path)\n",
+        "res = await ezkl.gen_witness(input_filename, compiled_filename, witness_path)\n",
        "assert os.path.isfile(witness_path)"
      ]
    },
    {
      "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
@@ -302,7 +541,34 @@
        "id": "Oog3j6Kd-Wed",
        "outputId": "5839d0c1-5b43-476e-c2f8-6707de562260"
      },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "INFO:ezkl.pfsys:loading proving key from \"test.pk\"\n",
+            "INFO:ezkl.pfsys:done loading proving key ✅\n",
+            "INFO:ezkl.pfsys.srs:loading srs from \"/Users/dante/.ezkl/srs/kzg6.srs\"\n",
+            "INFO:ezkl.execute:downsizing params to 6 logrows\n",
+            "INFO:ezkl.pfsys:proof started...\n",
+            "INFO:ezkl.graph.model:model layout...\n",
+            "INFO:ezkl.pfsys:proof took 0.15\n",
+            "INFO:ezkl.pfsys.srs:loading srs from \"/Users/dante/.ezkl/srs/kzg6.srs\"\n",
+            "INFO:ezkl.execute:downsizing params to 6 logrows\n",
+            "INFO:ezkl.pfsys:loading verification key from \"test.vk\"\n",
+            "INFO:ezkl.pfsys:done loading verification key ✅\n",
+            "INFO:ezkl.execute:verify took 0.2\n",
+            "INFO:ezkl.execute:verified: true\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "verified\n"
+          ]
+        }
+      ],
      "source": [
        "# prove the zk circuit\n",
        "# GENERATE A PROOF\n",
@@ -351,7 +617,7 @@
    },
    {
      "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
@@ -360,7 +626,26 @@
        "id": "fodkNgwS70FM",
        "outputId": "827b5efd-f74f-44de-c114-861b3a86daf2"
      },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "INFO:ezkl.pfsys.srs:loading srs from \"/Users/dante/.ezkl/srs/kzg6.srs\"\n",
+            "INFO:ezkl.execute:downsizing params to 6 logrows\n",
+            "INFO:ezkl.pfsys:loading verification key from \"test.vk\"\n",
+            "INFO:ezkl.pfsys:done loading verification key ✅\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "test.vk\n",
+            "settings.json\n"
+          ]
+        }
+      ],
      "source": [
        "# first we need to create evm verifier\n",
        "print(vk_path)\n",
@@ -370,7 +655,7 @@
        "abi_path = 'test.abi'\n",
        "sol_code_path = 'test.sol'\n",
        "\n",
-        "res = ezkl.create_evm_verifier(\n",
+        "res = await ezkl.create_evm_verifier(\n",
        "        vk_path,\n",
        "        settings_filename,\n",
        "        sol_code_path,\n",
@@ -381,9 +666,18 @@
    },
    {
      "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 11,
      "metadata": {},
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "INFO:ezkl.eth:using chain 31337\n",
+            "INFO:ezkl.execute:Contract deployed at: 0x998abeb3e57409262ae5b751f60747921b33613e\n"
+          ]
+        }
+      ],
      "source": [
        "# Make sure anvil is running locally first\n",
        "# run with $ anvil -p 3030\n",
@@ -391,8 +685,9 @@
        "import json\n",
        "\n",
        "address_path = os.path.join(\"address.json\")\n",
-        "\n",
-        "res = ezkl.deploy_evm(\n",
+        "sol_code_path = 'test.sol'\n",
+        "# await\n",
+        "res = await ezkl.deploy_evm(\n",
        "    address_path,\n",
        "    sol_code_path,\n",
        "    'http://127.0.0.1:3030'\n",
@@ -406,16 +701,26 @@
    },
    {
      "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 12,
      "metadata": {},
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "INFO:ezkl.eth:using chain 31337\n",
+            "INFO:ezkl.eth:estimated verify gas cost: 399775\n",
+            "INFO:ezkl.execute:Solidity verification result: true\n"
+          ]
+        }
+      ],
      "source": [
        "# read the address from addr_path\n",
        "addr = None\n",
        "with open(address_path, 'r') as f:\n",
        "    addr = f.read()\n",
        "\n",
-        "res = ezkl.verify_evm(\n",
+        "res = await ezkl.verify_evm(\n",
        "    addr,\n",
        "    proof_path,\n",
        "    \"http://127.0.0.1:3030\"\n",
@@ -451,7 +756,7 @@
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
-      "version": "3.9.15"
+      "version": "3.12.2"
    }
  },
  "nbformat": 4,
--- a/examples/notebooks/verifier_abi.json
+++ b/examples/notebooks/verifier_abi.json
@@ -0,0 +1 @@
+[{"type":"function","name":"verifyProof","inputs":[{"name":"proof","type":"bytes","internalType":"bytes"},{"name":"instances","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"}]
--- a/examples/notebooks/voice_judge.ipynb
+++ b/examples/notebooks/voice_judge.ipynb
@@ -629,7 +629,7 @@
            "source": [
                "\n",
                "\n",
-                "res = ezkl.calibrate_settings(val_data, model_path, settings_path, \"resources\", scales = [4])\n",
+                "res = await ezkl.calibrate_settings(val_data, model_path, settings_path, \"resources\", scales = [4])\n",
                "assert res == True\n",
                "print(\"verified\")\n"
            ]
@@ -660,7 +660,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "res = ezkl.get_srs(settings_path)"
+                "res = await ezkl.get_srs(settings_path)"
            ]
        },
        {
@@ -680,7 +680,7 @@
                "\n",
                "witness_path = \"witness.json\"\n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -807,7 +807,7 @@
                "settings_path = os.path.join('settings.json')\n",
                "\n",
                "\n",
-                "res = ezkl.create_evm_verifier(\n",
+                "res = await ezkl.create_evm_verifier(\n",
                "        vk_path,\n",
                "        \n",
                "        settings_path,\n",
@@ -847,7 +847,7 @@
                "\n",
                "address_path = os.path.join(\"address.json\")\n",
                "\n",
-                "res = ezkl.deploy_evm(\n",
+                "res = await ezkl.deploy_evm(\n",
                "    address_path,\n",
                "    sol_code_path,\n",
                "    'http://127.0.0.1:3030'\n",
@@ -868,7 +868,7 @@
                "# make sure anvil is running locally\n",
                "# $ anvil -p 3030\n",
                "\n",
-                "res = ezkl.verify_evm(\n",
+                "res = await ezkl.verify_evm(\n",
                "    addr,\n",
                "    proof_path,\n",
                "    \"http://127.0.0.1:3030\"\n",
@@ -905,4 +905,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 2
-}
+}
--- a/examples/notebooks/world_rotation.ipynb
+++ b/examples/notebooks/world_rotation.ipynb
@@ -242,6 +242,7 @@
  {
   "cell_type": "code",
   "execution_count": null,
+   "id": "2007dc77",
   "metadata": {},
   "outputs": [],
   "source": [
@@ -257,6 +258,7 @@
  },
  {
   "cell_type": "markdown",
+   "id": "ab993958",
   "metadata": {},
   "source": [
    "As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
@@ -272,7 +274,7 @@
   "outputs": [],
   "source": [
    "# srs path\n",
-    "res = ezkl.get_srs( settings_path)"
+    "res = await ezkl.get_srs( settings_path)"
   ]
  },
  {
@@ -284,12 +286,13 @@
   "source": [
    "# now generate the witness file \n",
    "\n",
-    "witness = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+    "witness = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
    "assert os.path.isfile(witness_path)"
   ]
  },
  {
   "cell_type": "markdown",
+   "id": "ad58432e",
   "metadata": {},
   "source": [
    "Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
@@ -317,6 +320,7 @@
  },
  {
   "cell_type": "markdown",
+   "id": "1746c8d1",
   "metadata": {},
   "source": [
    "We can now create an EVM verifier contract from our circuit. This contract will be deployed to the chain we are using. In this case we are using a local anvil instance."
@@ -325,15 +329,15 @@
  {
   "cell_type": "code",
   "execution_count": null,
+   "id": "d1920c0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "abi_path = 'test.abi'\n",
    "sol_code_path = 'test.sol'\n",
    "\n",
-    "res = ezkl.create_evm_verifier(\n",
+    "res = await ezkl.create_evm_verifier(\n",
    "        vk_path,\n",
-    "        \n",
    "        settings_path,\n",
    "        sol_code_path,\n",
    "        abi_path,\n",
@@ -344,6 +348,7 @@
  {
   "cell_type": "code",
   "execution_count": null,
+   "id": "0fd7f22b",
   "metadata": {},
   "outputs": [],
   "source": [
@@ -351,7 +356,7 @@
    "\n",
    "addr_path_verifier = \"addr_verifier.txt\"\n",
    "\n",
-    "res = ezkl.deploy_evm(\n",
+    "res = await ezkl.deploy_evm(\n",
    "    addr_path_verifier,\n",
    "    sol_code_path,\n",
    "    'http://127.0.0.1:3030'\n",
@@ -362,6 +367,7 @@
  },
  {
   "cell_type": "markdown",
+   "id": "9c0dffab",
   "metadata": {},
   "source": [
    "With the vanilla verifier deployed, we can now create the data attestation contract, which will read in the instances from the calldata to the verifier, attest to them, call the verifier and then return the result. \n",
@@ -371,6 +377,7 @@
  {
   "cell_type": "code",
   "execution_count": null,
+   "id": "cc888848",
   "metadata": {},
   "outputs": [],
   "source": []
@@ -378,6 +385,7 @@
  {
   "cell_type": "code",
   "execution_count": null,
+   "id": "c2db14d7",
   "metadata": {},
   "outputs": [],
   "source": [
@@ -385,7 +393,7 @@
    "sol_code_path = 'test.sol'\n",
    "input_path = 'input.json'\n",
    "\n",
-    "res = ezkl.create_evm_data_attestation(\n",
+    "res = await ezkl.create_evm_data_attestation(\n",
    "        input_path,\n",
    "        settings_path,\n",
    "        sol_code_path,\n",
@@ -396,12 +404,13 @@
  {
   "cell_type": "code",
   "execution_count": null,
+   "id": "5a018ba6",
   "metadata": {},
   "outputs": [],
   "source": [
    "addr_path_da = \"addr_da.txt\"\n",
    "\n",
-    "res = ezkl.deploy_da_evm(\n",
+    "res = await ezkl.deploy_da_evm(\n",
    "        addr_path_da,\n",
    "        input_path,\n",
    "        settings_path,\n",
@@ -412,6 +421,7 @@
  },
  {
   "cell_type": "markdown",
+   "id": "2adad845",
   "metadata": {},
   "source": [
    "Now we can pull in the data from the contract and calculate a new set of coordinates. We then rotate the world by 1 transform and submit the proof to the contract. The contract could then update the world rotation (logic not inserted here). For demo purposes we do this repeatedly, rotating the world by 1 transform. "
@@ -444,6 +454,7 @@
  },
  {
   "cell_type": "markdown",
+   "id": "90eda56e",
   "metadata": {},
   "source": [
    "Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
@@ -503,11 +514,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.string_to_float(witness['outputs'][0][0], out_scale)\n",
-    "arrow_y = ezkl.string_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.string_to_float(witness['outputs'][0][2], out_scale)\n",
-    "arrow_y = ezkl.string_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)"
   ]
  }
@@ -528,7 +539,7 @@
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
-   "version": "3.9.15"
+   "version": "3.12.2"
  }
 },
 "nbformat": 4,
--- a/examples/notebooks/xgboost.ipynb
+++ b/examples/notebooks/xgboost.ipynb
@@ -193,7 +193,7 @@
                "with open(cal_path, \"w\") as f:\n",
                "    json.dump(cal_data, f)\n",
                "\n",
-                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
            ]
        },
        {
@@ -215,7 +215,7 @@
            "outputs": [],
            "source": [
                "# srs path\n",
-                "res = ezkl.get_srs( settings_path)"
+                "res = await ezkl.get_srs( settings_path)"
            ]
        },
        {
@@ -227,7 +227,7 @@
            "source": [
                "# now generate the witness file \n",
                "\n",
-                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                "assert os.path.isfile(witness_path)"
            ]
        },
@@ -346,4 +346,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 5
-}
+}
--- a/examples/onnx/1l_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/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/Show More
+++ b/Show More
Author	SHA1	Message	Date
github-actions[bot]	3640c9aa6d	ci: update version string in docs	2024-06-10 16:14:16 +00:00
dante	00d6873f9a	fix: should update using bash when possible (#813 )	2024-06-10 12:13:59 -04:00
dante	c97ff84198	refactor: rm boxed errors (opaque) (#810 )	2024-06-08 22:41:47 -04:00
dante	f5f8ef56f7	chore: ezkl self update (#809 )	2024-06-07 10:30:21 -04:00
Ethan Cemer	685487c853	feat: DA swap proof commitments (#807 )	2024-06-07 10:19:38 -04:00
dante	33d41c7e49	fix: calldata cmd	2024-05-31 13:19:33 -04:00
dante	e04c959662	fix: sequential dependence between JS releases (#806 )	2024-05-31 08:34:51 -04:00
dante	27b1f2e9d4	fix: move banner to command loop	2024-05-30 17:01:40 -04:00
dante	4a172877af	feat: add autocompletion tooling to cli (#805 )	2024-05-30 16:44:24 -04:00
dante	5a8498894d	feat: create encode-evm-calldata in cli and python (#803 )	2024-05-29 21:03:16 -04:00
Snoppy	095c0ca5b4	chore: fix typos (#802 )	2024-05-29 11:32:11 -04:00
dante	3fa482c9ef	fix: remove error messages in calibration loop (confusing) (#800 )	2024-05-22 09:32:52 +01:00
dante	6be3b1d663	chore: update alloy (#798 )	2024-05-16 12:10:27 +09:00
dante	d5a1d1439c	fix: elif syntax in install script	2024-05-14 03:31:26 +09:00
Ethan Cemer	ff8fd01f86	fix: patch invalid ${{ github.ref_name#v }} syntax on verify release script (#791 )	2024-05-14 02:25:12 +09:00
dante	e9020f942e	fix: python build matrix (#797 )	2024-05-13 13:29:51 +09:00
dante	e7f54cb6ac	fix: windows build (#796 )	2024-05-13 12:47:36 +09:00
dante	ed65e8c090	Revert "fix: revert maturin version (#795 )" This reverts commit `d9f2adad99`.	2024-05-13 12:41:02 +09:00
dante	d9f2adad99	fix: revert maturin version (#795 )	2024-05-13 12:21:35 +09:00
dante	5125aaa090	chore: add aarch64 linux to release pipeline (#788 )	2024-05-13 11:29:49 +09:00
Jseam	f1950e6cd0	docs: add polycommit to RunArgs (#794 )	2024-05-10 22:19:05 +09:00
dante	998ca22c2a	chore: make most command struct args `Option` (#793 )	2024-05-10 22:02:34 +09:00
dante	5c574adc31	chore: logistic regression example (#792 )	2024-05-08 20:30:13 +09:00
dante	749e0ba652	chore: update h2 solidity verifier (#787 )	2024-05-03 01:25:14 +01:00
dante	d464ddf6b6	chore: medium sized lstm example (#785 )	2024-05-01 16:35:11 +01:00
dante	8f6c0aced5	chore: update tract (#784 )	2024-04-30 13:31:33 +01:00
dante	860e9700a8	refactor!: swap integer rep to i64 from i128 (#781 ) BREAKING CHANGE: may break w/ old compiled circuits	2024-04-26 16:16:55 -04:00
Ethan Cemer	32dd4a854f	fix: patch npm package build failure (#782 )	2024-04-25 10:38:06 -04:00
dante	924f7c0420	fix: simplify kzg-commit (#780 )	2024-04-24 11:57:20 -04:00
dante	ae03b6515b	fix: update vis settings on help (#779 )	2024-04-22 16:23:19 -04:00
Ethan Cemer	bae2e9e22b	feat: `kzgCommit` wasm method (#778 )	2024-04-18 19:22:11 -04:00
dante	4a93d31869	fix: accomodate modules in col-overflow (#777 )	2024-04-18 17:13:31 -04:00
dante	88dd83dbe5	fix: default compiled model paths in python (#776 )	2024-04-15 12:01:21 -04:00
Ethan Cemer	f05f83481e	chore: update eth postgres (#769 ) --------- Co-authored-by: dante <45801863+alexander-camuto@users.noreply.github.com>	2024-04-13 08:08:09 -04:00
Ethan Cemer	8aaf518b5e	fix: fix @ezkljs/verify etherumjs deps (#765 )	2024-04-12 18:24:59 -04:00
katsumata	1b7b43e073	fix: Improve EZKL installation script reliability (#774 )	2024-04-09 16:07:39 -04:00
dante	f78618ec59	feat: full ND conv and pool (#770 )	2024-04-06 23:29:30 +01:00
Jseam	0943e534ee	docs: automated sphinx documentation for python bindings (#714 ) --------- Co-authored-by: dante <45801863+alexander-camuto@users.noreply.github.com> Co-authored-by: Ethan Cemer <tylercemer@gmail.com> Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>	2024-04-05 18:33:06 +01:00
dante	316a9a3b40	chore: update tract (#766 )	2024-04-04 18:07:08 +01:00
dante	5389012b68	fix: patch large batch ex (#763 )	2024-04-03 02:33:57 +01:00
dante	48223cca11	fix: make commitment optional for backwards compat (#762 )	2024-04-03 02:26:50 +01:00
dante	32c3a5e159	fix: hold stacked outputs in a separate map	2024-04-02 21:37:20 +01:00
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
				`@@ -0,0 +1 @@`
				`[{"type":"function","name":"verifyProof","inputs":[{"name":"proof","type":"bytes","internalType":"bytes"},{"name":"instances","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"}]`
				`@@ -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": [[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]]}`