refactor: simpler diff less than

BREAKING CHANGE: removes support for iOS, JS, WASM and removes aggregation circuit.

.github/workflows/benchmarks.yml

@@ -6,23 +6,16 @@ on:
         description: "Test scenario tags"
 
 jobs:
-  bench_elgamal:
-    runs-on: self-hosted
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly-2023-06-27
-          override: true
-          components: rustfmt, clippy
-      - name: Bench elgamal
-        run: cargo bench --verbose --bench elgamal
 
   bench_poseidon:
+    permissions:
+      contents: read
     runs-on: self-hosted
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -31,11 +24,15 @@ jobs:
         run: cargo bench --verbose --bench poseidon
 
   bench_einsum_accum_matmul:
+    permissions:
+      contents: read
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -44,11 +41,15 @@ jobs:
         run: cargo bench --verbose --bench accum_einsum_matmul
 
   bench_accum_matmul_relu:
+    permissions:
+      contents: read
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -57,11 +58,15 @@ jobs:
         run: cargo bench --verbose --bench accum_matmul_relu
 
   bench_accum_matmul_relu_overflow:
+    permissions:
+      contents: read
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -70,11 +75,15 @@ jobs:
         run: cargo bench --verbose --bench accum_matmul_relu_overflow
 
   bench_relu:
+    permissions:
+      contents: read
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -83,11 +92,15 @@ jobs:
         run: cargo bench --verbose --bench relu
 
   bench_accum_dot:
+    permissions:
+      contents: read
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -96,11 +109,15 @@ jobs:
         run: cargo bench --verbose --bench accum_dot
 
   bench_accum_conv:
+    permissions:
+      contents: read
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -109,11 +126,15 @@ jobs:
         run: cargo bench --verbose --bench accum_conv
 
   bench_accum_sumpool:
+    permissions:
+      contents: read
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -122,11 +143,15 @@ jobs:
         run: cargo bench --verbose --bench accum_sumpool
 
   bench_pairwise_add:
+    permissions:
+      contents: read
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -135,11 +160,15 @@ jobs:
         run: cargo bench --verbose --bench pairwise_add
 
   bench_accum_sum:
+    permissions:
+      contents: read
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
           toolchain: nightly-2023-06-27
           override: true
@@ -148,11 +177,15 @@ jobs:
         run: cargo bench --verbose --bench accum_sum
 
   bench_pairwise_pow:
+    permissions:
+      contents: read
     runs-on: self-hosted
     needs: [bench_poseidon]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
           toolchain: nightly-2023-06-27
           override: true

.github/workflows/engine.yml

@@ -1,238 +0,0 @@
-name: Build and Publish EZKL Engine npm package
-
-on:
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: "The tag to release"
-        required: true
-  push:
-    tags:
-      - "*"
-
-defaults:
-  run:
-    working-directory: .
-jobs:
-  publish-wasm-bindings:
-    name: publish-wasm-bindings
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly-2024-07-18
-          override: true
-          components: rustfmt, clippy
-      - uses: jetli/wasm-pack-action@v0.4.0
-        with:
-          # Pin to version 0.12.1
-          version: 'v0.12.1'
-      - name: Add wasm32-unknown-unknown target
-        run: rustup target add wasm32-unknown-unknown
-
-      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
-      - name: Install binaryen
-        run: |
-          set -e
-          curl -L https://github.com/WebAssembly/binaryen/releases/download/version_116/binaryen-version_116-x86_64-linux.tar.gz | tar xzf -
-          export PATH=$PATH:$PWD/binaryen-version_116/bin
-          wasm-opt --version
-      - name: Build wasm files for both web and nodejs compilation targets
-        run: |
-          wasm-pack build --release --target nodejs --out-dir ./pkg/nodejs . -- -Z build-std="panic_abort,std"
-          wasm-pack build --release --target web --out-dir ./pkg/web . -- -Z build-std="panic_abort,std" --features web
-      - name: Create package.json in pkg folder
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          echo '{
-            "name": "@ezkljs/engine",
-            "version": "${{ github.ref_name }}",
-            "dependencies": {
-              "@types/json-bigint": "^1.0.1",
-              "json-bigint": "^1.0.0"
-            },
-            "files": [
-              "nodejs/ezkl_bg.wasm",
-              "nodejs/ezkl.js",
-              "nodejs/ezkl.d.ts",
-              "nodejs/package.json",
-              "nodejs/utils.js",
-              "web/ezkl_bg.wasm",
-              "web/ezkl.js",
-              "web/ezkl.d.ts",
-              "web/snippets/**/*",
-              "web/package.json",
-              "web/utils.js",
-              "ezkl.d.ts"
-            ],
-            "main": "nodejs/ezkl.js",
-            "module": "web/ezkl.js",
-            "types": "nodejs/ezkl.d.ts",
-            "sideEffects": [
-              "web/snippets/*"
-            ]
-          }' > pkg/package.json
-
-      - name: Replace memory definition in nodejs
-        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 '
-          const JSONBig = require("json-bigint");
-
-          function deserialize(buffer) { // buffer is a Uint8ClampedArray | Uint8Array // return a JSON object
-            if (buffer instanceof Uint8ClampedArray) {
-                buffer = new Uint8Array(buffer.buffer);
-            }
-            const string = new TextDecoder().decode(buffer);
-            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") {
-                data = JSONBig.stringify(data);
-            }
-            // 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
-          };
-          ' > pkg/nodejs/utils.js
-      - name: Add serialize and deserialize methods to web bundle
-        run: |
-          echo '
-          import { parse, stringify } from "json-bigint";
-
-          export function deserialize(buffer) { // buffer is a Uint8ClampedArray | Uint8Array // return a JSON object
-            if (buffer instanceof Uint8ClampedArray) {
-                buffer = new Uint8Array(buffer.buffer);
-            }
-            const string = new TextDecoder().decode(buffer);
-            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") {
-                data = stringify(data);
-            }
-            // Step 2: Encode the JSON String
-            const uint8Array = new TextEncoder().encode(data);
-
-            // Step 3: Convert to Uint8ClampedArray
-            return new Uint8ClampedArray(uint8Array.buffer);
-          }
-          ' > pkg/web/utils.js
-      - name: Expose serialize and deserialize imports in nodejs target
-        run: |
-          sed -i '53i// import serialize and deserialize from utils.js\nconst { serialize, deserialize } = require(`./utils.js`);\nmodule.exports.serialize = serialize;\nmodule.exports.deserialize = deserialize;' pkg/nodejs/ezkl.js
-      - name: Expose serialize and deserialize imports in web target
-        run: |
-          sed -i '51i\
-          // import serialize and deserialize from utils.js\
-          import { serialize, deserialize } from '\''./utils.js'\'';\
-          export { serialize, deserialize };' pkg/web/ezkl.js
-      - name: Add serialize and deserialize imports to nodejs ezkl.d.ts
-        run: |
-          sed -i '1i\
-          export declare function serialize(data: object | string): Uint8ClampedArray;\
-          export declare function deserialize(buffer: Uint8ClampedArray | Uint8Array): any;' pkg/nodejs/ezkl.d.ts
-
-      - name: Add serialize and deserialize imports to web ezkl.d.ts
-        run: |
-          sed -i '1i\
-          export declare function serialize(data: object | string): Uint8ClampedArray;\
-          export declare function deserialize(buffer: Uint8ClampedArray | Uint8Array): any;' pkg/web/ezkl.d.ts
-
-      - name: Create README.md in pkg folder
-        run: |
-          curl -s "https://raw.githubusercontent.com/zkonduit/ezkljs-engine/main/README.md" > ./pkg/README.md
-
-      - 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 pkg
-          npm install
-          npm ci
-          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 }}  

.github/workflows/large-tests.yml

@@ -6,12 +6,16 @@ on:
         description: "Test scenario tags"
 jobs:
   large-tests:
+    permissions:
+      contents: read
     runs-on: kaiju
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
-          toolchain: nightly-2024-07-18
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
+        with:
+          toolchain: nightly-2025-05-01
           override: true
           components: rustfmt, clippy
       - name: nanoGPT Mock

.github/workflows/pypi-gpu.yml

@@ -18,39 +18,59 @@ defaults:
 jobs:
 
   linux:
+    permissions:
+      contents: read
+      packages: write
     runs-on: GPU
     strategy:
       matrix:
         target: [x86_64]
+    env:
+      RELEASE_TAG: ${{ github.ref_name }}
+      RUSTFLAGS: "-C linker=gcc"
+      OPENSSL_NO_VENDOR: 1
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
         with:
           python-version: 3.12
           architecture: x64
 
-      - name: Set pyproject.toml version to match github tag
+
+
+      - name: Install build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential g++ gcc cmake libclang-dev llvm-dev libstdc++-12-dev libc6 libc6-dev libssl-dev pkg-config
+
+      - name: Force rebuild icicle dependencies
+        run: cargo clean -p icicle-runtime -p icicle-core -p icicle-hash -p icicle-bn254
+
+      - name: Set pyproject.toml version to match github tag and rename ezkl to ezkl-gpu
         shell: bash
         run: |
             mv pyproject.toml pyproject.toml.orig
-            sed "s/ezkl/ezkl-gpu/" pyproject.toml.orig >pyproject.toml
-            sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" pyproject.toml.orig >pyproject.toml
+            sed "s/ezkl/ezkl-gpu/" pyproject.toml.orig > pyproject.toml.tmp
+            sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" pyproject.toml.tmp > pyproject.toml
 
-      - uses: actions-rs/toolchain@v1
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
           toolchain: nightly-2023-06-27
           override: true
           components: rustfmt, clippy
+          cache: false
 
-      - name: Set Cargo.toml version to match github tag
+      - name: Set Cargo.toml version to match github tag and rename ezkl to ezkl-gpu
         shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
+        # the ezkl substitution here looks for the first instance of name = "ezkl" and changes it to "ezkl-gpu"
         run: |
           mv Cargo.toml Cargo.toml.orig
-          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.toml.orig >Cargo.toml
+          sed "0,/name = \"ezkl\"/s/name = \"ezkl\"/name = \"ezkl-gpu\"/" Cargo.toml.orig > Cargo.toml.tmp
+          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.toml.tmp > Cargo.toml
           mv Cargo.lock Cargo.lock.orig
-          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig >Cargo.lock
+          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig > Cargo.lock
 
       - name: Install required libraries
         shell: bash
@@ -58,12 +78,12 @@ jobs:
           sudo apt-get update && sudo apt-get install -y openssl pkg-config libssl-dev
 
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
         with:
           target: ${{ matrix.target }}
           manylinux: auto
           container: off
-          args: --release --out dist --features python-bindings,icicle
+          args: --release --out dist --features python-bindings,gpu-accelerated
 
       - name: Install built wheel
         if: matrix.target == 'x86_64'
@@ -71,7 +91,7 @@ jobs:
           pip install ezkl-gpu --no-index --find-links dist --force-reinstall
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08  #v4.6.0
         with:
           name: wheels
           path: dist
@@ -87,7 +107,7 @@ jobs:
     # needs: [ macos, windows, linux, linux-cross, musllinux, musllinux-cross ]
     needs: [linux]
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16  #v4.1.8
         with:
           name: wheels
       - name: List Files
@@ -99,14 +119,14 @@ jobs:
       # publishes to PyPI
       - name: Publish package distributions to PyPI
         continue-on-error: true
-        uses: pypa/gh-action-pypi-publish@unstable/v1
+        uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc  #v1.12.4
         with:
-          packages-dir: ./
+          packages-dir: ./wheels
 
       # publishes to TestPyPI
       - name: Publish package distribution to TestPyPI
         continue-on-error: true
-        uses: pypa/gh-action-pypi-publish@unstable/v1
+        uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc  #v1.12.4
         with:
           repository-url: https://test.pypi.org/legacy/
-          packages-dir: ./
+          packages-dir: ./wheels

.github/workflows/pypi.yml

@@ -16,36 +16,54 @@ defaults:
 
 jobs:
   macos:
+    permissions:
+      contents: read
     runs-on: macos-latest
     if: startsWith(github.ref, 'refs/tags/')
     strategy:
       matrix:
         target: [x86_64, universal2-apple-darwin]
+    env:
+        RELEASE_TAG: ${{ github.ref_name }}
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
         with:
           python-version: 3.12
           architecture: x64
 
+      - name: Set pyproject.toml version to match github tag
+        shell: bash
+        run: |
+          mv pyproject.toml pyproject.toml.orig
+          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" pyproject.toml.orig >pyproject.toml
+
       - name: Set Cargo.toml version to match github tag
         shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
         run: |
           mv Cargo.toml Cargo.toml.orig
           sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.toml.orig >Cargo.toml
           mv Cargo.lock Cargo.lock.orig
           sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig >Cargo.lock
 
-      - uses: actions-rs/toolchain@v1
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2025-05-01
           override: true
           components: rustfmt, clippy
+          cache: false
 
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        if: matrix.target == 'universal2-apple-darwin'
+        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist --features python-bindings
+      - name: Build wheels
+        if: matrix.target == 'x86_64'
+        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
         with:
           target: ${{ matrix.target }}
           args: --release --out dist --features python-bindings
@@ -56,24 +74,36 @@ jobs:
           python -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08  #v4.6.0
         with:
-          name: wheels
+          name: dist-macos-${{ matrix.target }}
           path: dist
 
   windows:
+    permissions:
+      contents: read
     runs-on: windows-latest
     if: startsWith(github.ref, 'refs/tags/')
     strategy:
       matrix:
         target: [x64, x86]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
         with:
           python-version: 3.12
           architecture: ${{ matrix.target }}
 
+      - name: Set pyproject.toml version to match github tag
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          mv pyproject.toml pyproject.toml.orig
+          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" pyproject.toml.orig >pyproject.toml
+
       - name: Set Cargo.toml version to match github tag
         shell: bash
         env:
@@ -84,14 +114,15 @@ jobs:
           mv Cargo.lock Cargo.lock.orig
           sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig >Cargo.lock
 
-      - uses: actions-rs/toolchain@v1
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
         with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2025-05-01
           override: true
           components: rustfmt, clippy
+          cache: false
 
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
         with:
           target: ${{ matrix.target }}
           args: --release --out dist --features python-bindings
@@ -101,24 +132,36 @@ jobs:
           python -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08  #v4.6.0 #v4.6.0
         with:
-          name: wheels
+          name: dist-windows-${{ matrix.target }}
           path: dist
 
   linux:
+    permissions:
+      contents: read
     runs-on: ubuntu-latest
     if: startsWith(github.ref, 'refs/tags/')
     strategy:
       matrix:
         target: [x86_64]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
         with:
           python-version: 3.12
           architecture: x64
 
+      - name: Set pyproject.toml version to match github tag
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          mv pyproject.toml pyproject.toml.orig
+          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" pyproject.toml.orig >pyproject.toml
+
       - name: Set Cargo.toml version to match github tag
         shell: bash
         env:
@@ -129,14 +172,13 @@ 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: |
           sudo apt-get update && sudo apt-get install -y openssl pkg-config libssl-dev
 
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
         with:
           target: ${{ matrix.target }}
           manylinux: auto
@@ -163,63 +205,14 @@ jobs:
           python -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08  #v4.6.0
         with:
-          name: wheels
+          name: dist-linux-${{ matrix.target }}
           path: dist
 
-  #  There's a problem with the maturin-action toolchain for arm arch leading to failed builds
-  # linux-cross:
-  #   runs-on: ubuntu-latest
-  #   strategy:
-  #     matrix:
-  #       target: [aarch64, armv7]
-  #   steps:
-  #   - uses: actions/checkout@v4
-  #   - uses: actions/setup-python@v4
-  #     with:
-  #       python-version: 3.12
-
-  #   - name: Install cross-compilation tools for aarch64
-  #     if: matrix.target == 'aarch64'
-  #     run: |
-  #       sudo apt-get update
-  #       sudo apt-get install -y gcc make gcc-aarch64-linux-gnu binutils-aarch64-linux-gnu libc6-dev-arm64-cross libusb-1.0-0-dev libatomic1-arm64-cross
-
-  #   - name: Install cross-compilation tools for armv7
-  #     if: matrix.target == 'armv7'
-  #     run: |
-  #       sudo apt-get update
-  #       sudo apt-get install -y gcc make gcc-arm-linux-gnueabihf binutils-arm-linux-gnueabihf libc6-dev-armhf-cross libusb-1.0-0-dev libatomic1-armhf-cross
-
-  #   - name: Build wheels
-  #     uses: PyO3/maturin-action@v1
-  #     with:
-  #       target: ${{ matrix.target }}
-  #       manylinux: auto
-  #       args: --release --out dist --features python-bindings
-
-  #   - uses: uraimo/run-on-arch-action@v2.5.0
-  #     name: Install built wheel
-  #     with:
-  #       arch: ${{ matrix.target }}
-  #       distro: ubuntu20.04
-  #       githubToken: ${{ github.token }}
-  #       install: |
-  #         apt-get update
-  #         apt-get install -y --no-install-recommends python3 python3-pip
-  #         pip3 install -U pip
-  #       run: |
-  #         pip3 install ezkl --no-index --find-links dist/ --force-reinstall
-  #         python3 -c "import ezkl"
-
-  #   - name: Upload wheels
-  #     uses: actions/upload-artifact@v3
-  #     with:
-  #       name: wheels
-  #       path: dist
-
   musllinux:
+    permissions:
+      contents: read
     runs-on: ubuntu-latest
     if: startsWith(github.ref, 'refs/tags/')
     strategy:
@@ -227,8 +220,10 @@ jobs:
         target:
           - x86_64-unknown-linux-musl
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
         with:
           python-version: 3.12
           architecture: x64
@@ -250,13 +245,14 @@ jobs:
           sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.toml.orig >Cargo.toml
           mv Cargo.lock Cargo.lock.orig
           sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig >Cargo.lock
+
       - name: Install required libraries
         shell: bash
         run: |
           sudo apt-get update && sudo apt-get install -y pkg-config libssl-dev
 
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
         with:
           target: ${{ matrix.target }}
           manylinux: musllinux_1_2
@@ -264,7 +260,7 @@ jobs:
 
       - name: Install built wheel
         if: matrix.target == 'x86_64-unknown-linux-musl'
-        uses: addnab/docker-run-action@v3
+        uses: addnab/docker-run-action@3e77f186b7a929ef010f183a9e24c0f9955ea609
         with:
           image: alpine:latest
           options: -v ${{ github.workspace }}:/io -w /io
@@ -277,12 +273,14 @@ jobs:
             python3 -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08  #v4.6.0
         with:
-          name: wheels
+          name: dist-musllinux-${{ matrix.target }}
           path: dist
 
   musllinux-cross:
+    permissions:
+      contents: read
     runs-on: ubuntu-latest
     if: startsWith(github.ref, 'refs/tags/')
     strategy:
@@ -291,11 +289,21 @@ jobs:
           - target: aarch64-unknown-linux-musl
             arch: aarch64
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
         with:
           python-version: 3.12
 
+      - name: Set pyproject.toml version to match github tag
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          mv pyproject.toml pyproject.toml.orig
+          sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" pyproject.toml.orig >pyproject.toml
+
       - name: Set Cargo.toml version to match github tag
         shell: bash
         env:
@@ -307,13 +315,13 @@ jobs:
           sed "s/0\\.0\\.0/${RELEASE_TAG//v}/" Cargo.lock.orig >Cargo.lock
 
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@5f8a1b3b0aad13193f46c9131f9b9e663def8ce5  #v1.46.0
         with:
           target: ${{ matrix.platform.target }}
           manylinux: musllinux_1_2
           args: --release --out dist --features python-bindings
 
-      - uses: uraimo/run-on-arch-action@v2.8.1
+      - uses: uraimo/run-on-arch-action@5397f9e30a9b62422f302092631c99ae1effcd9e  #v2.8.1
         name: Install built wheel
         with:
           arch: ${{ matrix.platform.arch }}
@@ -328,9 +336,9 @@ jobs:
             python3 -c "import ezkl"
 
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08  #v4.6.0
         with:
-          name: wheels
+          name: dist-musllinux-${{ matrix.platform.target }}
           path: dist
 
   pypi-publish:
@@ -339,44 +347,43 @@ jobs:
     permissions:
       id-token: write
     if: "startsWith(github.ref, 'refs/tags/')"
-    # TODO: Uncomment if linux-cross is working
-    # needs: [ macos, windows, linux, linux-cross, musllinux, musllinux-cross ]
     needs: [macos, windows, linux, musllinux, musllinux-cross]
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16  #v4.1.8
         with:
-          name: wheels
+          pattern: dist-*
+          merge-multiple: true
+          path: wheels
       - name: List Files
         run: ls -R
 
-      # Both publish steps will fail if there is no trusted publisher setup
-      # On failure the publish step will then simply continue to the next one
+      # # publishes to TestPyPI
+      # - name: Publish package distribution to TestPyPI
+      #   uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc  #v1.12.4
+      #   with:
+      #     repository-url: https://test.pypi.org/legacy/
+      #     packages-dir: ./
 
       # publishes to PyPI
       - name: Publish package distributions to PyPI
-        continue-on-error: true
-        uses: pypa/gh-action-pypi-publish@unstable/v1
+        uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc  #v1.12.4
         with:
-          packages-dir: ./
+          packages-dir: ./wheels
 
-      # publishes to TestPyPI
-      - name: Publish package distribution to TestPyPI
-        continue-on-error: true
-        uses: pypa/gh-action-pypi-publish@unstable/v1
-        with:
-          repository-url: https://test.pypi.org/legacy/
-          packages-dir: ./
 
   doc-publish:
+    permissions:
+      contents: read
     name: Trigger ReadTheDocs Build
     runs-on: ubuntu-latest
     needs: pypi-publish
     steps:
       - uses: actions/checkout@v4
-
+        with:
+          persist-credentials: false
       - name: Trigger RTDs build
-        uses: dfm/rtds-action@v1
+        uses: dfm/rtds-action@618148c547f4b56cdf4fa4dcf3a94c91ce025f2d
         with:
           webhook_url: ${{ secrets.RTDS_WEBHOOK_URL }}
           webhook_token: ${{ secrets.RTDS_WEBHOOK_TOKEN }}
-          commit_ref: ${{ github.ref_name }}
+          commit_ref: ${{ github.ref_name }}

.github/workflows/release.yml

@@ -10,6 +10,9 @@ on:
       - "*"
 jobs:
   create-release:
+    permissions:
+      contents: read
+      packages: write
     name: create-release
     runs-on: ubuntu-22.04
     if: startsWith(github.ref, 'refs/tags/')
@@ -23,16 +26,18 @@ jobs:
         shell: bash
         run: |
           echo "EZKL_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-          echo "version is: ${{ env.EZKL_VERSION }}"
 
       - name: Create Github Release
         id: create-release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@c95fe1489396fe8a9eb87c0abf8aa5b2ef267fda  #v2.2.1
         with:
           token: ${{ secrets.RELEASE_TOKEN }}
           tag_name: ${{ env.EZKL_VERSION }}
 
   build-release-gpu:
+    permissions:
+      contents: read
+      packages: write
     name: build-release-gpu
     needs: ["create-release"]
     runs-on: GPU
@@ -42,20 +47,32 @@ jobs:
       TARGET_DIR: ./target
       RUST_BACKTRACE: 1
       PCRE2_SYS_STATIC: 1
+      RUSTFLAGS: "-C linker=gcc"
+      OPENSSL_NO_VENDOR: 1
     steps:
-      - uses: actions-rs/toolchain@v1
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48   #v1.0.6
         with:
-          toolchain: nightly-2024-07-18
+          toolchain: nightly-2025-05-01
           override: true
           components: rustfmt, clippy
+          cache: false
       - name: Checkout repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+
+      - name: Install build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential g++ gcc cmake libclang-dev llvm-dev libstdc++-12-dev libc6 libc6-dev libssl-dev pkg-config
+
+      - name: Force rebuild icicle dependencies
+        run: cargo clean -p icicle-runtime -p icicle-core -p icicle-hash -p icicle-bn254
 
       - name: Get release version from tag
         shell: bash
         run: |
           echo "EZKL_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-          echo "version is: ${{ env.EZKL_VERSION }}"
 
       - name: Set Cargo.toml version to match github tag
         shell: bash
@@ -71,7 +88,7 @@ jobs:
           sudo apt-get update
 
       - name: Build release binary
-        run: cargo build --release -Z sparse-registry --features icicle
+        run: cargo build --release -Z sparse-registry --features gpu-accelerated
 
       - name: Build archive
         shell: bash
@@ -81,7 +98,7 @@ jobs:
           echo "ASSET=build-artifacts/ezkl-linux-gpu.tar.gz" >> $GITHUB_ENV
 
       - name: Upload release archive
-        uses: actions/upload-release-asset@v1.0.2
+        uses: actions/upload-release-asset@e8f9f06c4b078e705bd2ea027f0926603fc9b4d5  #v1.0.2
         env:
           GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
         with:
@@ -91,6 +108,10 @@ jobs:
           asset_content_type: application/octet-stream
 
   build-release:
+    permissions:
+      contents: read
+      packages: write
+      issues: write
     name: build-release
     needs: ["create-release"]
     runs-on: ${{ matrix.os }}
@@ -106,38 +127,39 @@ jobs:
         include:
           - build: windows-msvc
             os: windows-latest
-            rust: nightly-2024-07-18
+            rust: nightly-2025-05-01
             target: x86_64-pc-windows-msvc
           - build: macos
             os: macos-13
-            rust: nightly-2024-07-18
+            rust: nightly-2025-05-01
             target: x86_64-apple-darwin
           - build: macos-aarch64
             os: macos-13
-            rust: nightly-2024-07-18
+            rust: nightly-2025-05-01
             target: aarch64-apple-darwin
           - build: linux-musl
             os: ubuntu-22.04
-            rust: nightly-2024-07-18
+            rust: nightly-2025-05-01
             target: x86_64-unknown-linux-musl
           - build: linux-gnu
             os: ubuntu-22.04
-            rust: nightly-2024-07-18
+            rust: nightly-2025-05-01
             target: x86_64-unknown-linux-gnu
           - build: linux-aarch64
             os: ubuntu-22.04
-            rust: nightly-2024-07-18
+            rust: nightly-2025-05-01
             target: aarch64-unknown-linux-gnu
 
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
 
       - name: Get release version from tag
         shell: bash
         run: |
           echo "EZKL_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-          echo "version is: ${{ env.EZKL_VERSION }}"
 
       - name: Set Cargo.toml version to match github tag
         shell: bash
@@ -155,7 +177,7 @@ jobs:
           fi
 
       - name: Install Rust
-        uses: dtolnay/rust-toolchain@nightly
+        uses: dtolnay/rust-toolchain@4f94fbe7e03939b0e674bcc9ca609a16088f63ff  #nightly branch, TODO: update when required
         with:
           target: ${{ matrix.target }}
 
@@ -181,13 +203,17 @@ jobs:
           echo "target flag is: ${{ env.TARGET_FLAGS }}"
           echo "target dir is: ${{ env.TARGET_DIR }}"
 
-      - name: Build release binary (no asm)
-        if: matrix.build != 'linux-gnu'
-        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry
+      - name: Build release binary (no asm or metal)
+        if: matrix.build != 'linux-gnu' && matrix.build != 'macos-aarch64'
+        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry --features mimalloc
 
       - name: Build release binary (asm)
         if: matrix.build == 'linux-gnu'
-        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry --features asm
+        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry --features mimalloc
+
+      - name: Build release binary (metal)
+        if: matrix.build == 'macos-aarch64'
+        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry --features macos-metal,mimalloc
 
       - name: Strip release binary
         if: matrix.build != 'windows-msvc' && matrix.build != 'linux-aarch64'
@@ -214,7 +240,7 @@ jobs:
           echo "ASSET=build-artifacts/ezkl-win.zip" >> $GITHUB_ENV
 
       - name: Upload release archive
-        uses: actions/upload-release-asset@v1.0.2
+        uses: actions/upload-release-asset@e8f9f06c4b078e705bd2ea027f0926603fc9b4d5  #v1.0.2
         env:
           GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
         with:

.github/workflows/static-analysis.yml

@@ -0,0 +1,32 @@
+name: Static Analysis
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  analyze:
+    permissions:
+      contents: read
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
+        with:
+          persist-credentials: false
+      - uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48  #v1.0.6
+        with:
+          toolchain: nightly-2025-05-01
+          override: true
+          components: rustfmt, clippy
+
+      # Run Zizmor static analysis
+
+      - name: Install Zizmor
+        run: cargo install --locked zizmor
+
+      - name: Run Zizmor Analysis
+        run: zizmor .
+
+

.github/workflows/swift-pm.yml

@@ -1,129 +0,0 @@
-name: Build and Publish EZKL iOS SPM package
-
-on:
-  push:
-    tags:
-      # Only support SemVer versioning tags
-      - 'v[0-9]+.[0-9]+.[0-9]+'
-      - '[0-9]+.[0-9]+.[0-9]+'
-
-jobs:
-  build-and-update:
-    runs-on: macos-latest
-    env:
-      EZKL_SWIFT_PACKAGE_REPO: github.com/zkonduit/ezkl-swift-package.git
-
-    steps:
-      - name: Checkout EZKL
-        uses: actions/checkout@v3
-
-      - name: Extract TAG from github.ref_name
-        run: |
-          # github.ref_name is provided by GitHub Actions and contains the tag name directly.
-          TAG="${{ github.ref_name }}"
-          echo "Original TAG: $TAG"
-          # Remove leading 'v' if present to match the Swift Package Manager version format.
-          NEW_TAG=${TAG#v}
-          echo "Stripped TAG: $NEW_TAG"
-          echo "TAG=$NEW_TAG" >> $GITHUB_ENV
-
-      - name: Install Rust (nightly)
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly
-          override: true
-
-      - name: Build EzklCoreBindings
-        run: CONFIGURATION=release cargo run --bin ios_gen_bindings --features "ios-bindings uuid camino uniffi_bindgen" --no-default-features
-
-      - name: Clone ezkl-swift-package repository
-        run: |
-          git clone https://${{ env.EZKL_SWIFT_PACKAGE_REPO }}
-
-      - name: Copy EzklCoreBindings
-        run: |
-          rm -rf ezkl-swift-package/Sources/EzklCoreBindings
-          cp -r build/EzklCoreBindings ezkl-swift-package/Sources/
-
-      - name: Copy Test Files
-        run: |
-          rm -rf ezkl-swift-package/Tests/EzklAssets/*
-          cp tests/assets/kzg ezkl-swift-package/Tests/EzklAssets/kzg.srs
-          cp tests/assets/input.json ezkl-swift-package/Tests/EzklAssets/input.json
-          cp tests/assets/model.compiled ezkl-swift-package/Tests/EzklAssets/network.ezkl
-          cp tests/assets/settings.json ezkl-swift-package/Tests/EzklAssets/settings.json
-
-      - name: Check for changes
-        id: check_changes
-        run: |
-          cd ezkl-swift-package
-          if git diff --quiet Sources/EzklCoreBindings Tests/EzklAssets; then
-            echo "no_changes=true" >> $GITHUB_OUTPUT
-          else
-            echo "no_changes=false" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Set up Xcode environment
-        if: steps.check_changes.outputs.no_changes == 'false'
-        run: |
-          sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
-          sudo xcodebuild -license accept
-
-      - name: Run Package Tests
-        if: steps.check_changes.outputs.no_changes == 'false'
-        run: |
-          cd ezkl-swift-package
-          xcodebuild test \
-            -scheme EzklPackage \
-            -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=17.5' \
-            -resultBundlePath ../testResults
-
-      - name: Run Example App Tests
-        if: steps.check_changes.outputs.no_changes == 'false'
-        run: |
-          cd ezkl-swift-package/Example
-          xcodebuild test \
-            -project Example.xcodeproj \
-            -scheme EzklApp \
-            -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=17.5' \
-            -parallel-testing-enabled NO \
-            -resultBundlePath ../../exampleTestResults \
-            -skip-testing:EzklAppUITests/EzklAppUITests/testButtonClicksInOrder
-
-      - name: Setup Git
-        run: |
-          cd ezkl-swift-package
-          git config user.name "GitHub Action"
-          git config user.email "action@github.com"
-          git remote set-url origin https://zkonduit:${EZKL_SWIFT_PACKAGE_REPO_TOKEN}@${{ env.EZKL_SWIFT_PACKAGE_REPO }}
-        env:
-          EZKL_SWIFT_PACKAGE_REPO_TOKEN: ${{ secrets.EZKL_PORTER_TOKEN }}
-
-      - name: Commit and Push Changes
-        if: steps.check_changes.outputs.no_changes == 'false'
-        run: |
-          cd ezkl-swift-package
-          git add Sources/EzklCoreBindings Tests/EzklAssets
-          git commit -m "Automatically updated EzklCoreBindings for EZKL"
-          
-          if ! git push origin; then
-            echo "::error::Failed to push changes to ${{ env.EZKL_SWIFT_PACKAGE_REPO }}. Please ensure that EZKL_PORTER_TOKEN has the correct permissions."
-            exit 1
-          fi
-
-      - name: Tag the latest commit
-        run: |
-          cd ezkl-swift-package
-          source $GITHUB_ENV
-          
-          # Tag the latest commit on the current branch
-          if git rev-parse "$TAG" >/dev/null 2>&1; then
-            echo "Tag $TAG already exists locally. Skipping tag creation."
-          else
-            git tag "$TAG"
-          fi
-
-          if ! git push origin "$TAG"; then
-            echo "::error::Failed to push tag '$TAG' to ${{ env.EZKL_SWIFT_PACKAGE_REPO }}. Please ensure EZKL_PORTER_TOKEN has correct permissions."
-            exit 1
-          fi

.github/workflows/tagging.yml

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

.gitignore

@@ -9,6 +9,7 @@ pkg
 !AttestData.sol
 !VerifierBase.sol
 !LoadInstances.sol
+!AttestData.t.sol
 *.pf
 *.vk
 *.pk
@@ -49,3 +50,7 @@ timingData.json
 !tests/assets/vk.key
 docs/python/build
 !tests/assets/vk_aggr.key
+cache
+out
+!tests/assets/wasm.code
+!tests/assets/wasm.sol

Cargo.toml

@@ -16,12 +16,12 @@ crate-type = ["cdylib", "rlib", "staticlib"]
 
 
 [dependencies]
-halo2_gadgets = { git = "https://github.com/zkonduit/halo2" }
+halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch= "ac/conditional-compilation-icicle2" }
 halo2curves = { git = "https://github.com/privacy-scaling-explorations/halo2curves", rev = "b753a832e92d5c86c5c997327a9cf9de86a18851", features = [
     "derive_serde",
 ] }
-halo2_proofs = { git = "https://github.com/zkonduit/halo2", package = "halo2_proofs", features = [
-    "circuit-params",
+halo2_proofs = { git = "https://github.com/zkonduit/halo2", package = "halo2_proofs", branch= "ac/conditional-compilation-icicle2", features = [
+    "circuit-params", "mv-lookup"
 ] }
 rand = { version = "0.8", default-features = false }
 itertools = { version = "0.10.3", default-features = false }
@@ -33,21 +33,24 @@ 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",
+    "derive_serde", "mv-lookup"
+] }
+halo2_solidity_verifier = { git = "https://github.com/zkonduit/ezkl-verifier", branch = "main", optional = true, features = [
+    "evm", "mv-lookup",
 ] }
-halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier", optional = true }
 maybe-rayon = { version = "0.1.1", default-features = false }
 bincode = { version = "1.3.3", default-features = false }
 unzip-n = "0.1.2"
 num = "0.4.1"
-portable-atomic = { version = "1.6.0", optional = true }
 tosubcommand = { git = "https://github.com/zkonduit/enum_to_subcommand", package = "tosubcommand", optional = true }
 semver = { version = "1.0.22", optional = true }
 
+
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-serde_json = { version = "1.0.97", features = ["float_roundtrip", "raw_value"] }
 
 # evm related deps
+serde_json = { version = "1.0.97", features = ["float_roundtrip", "raw_value"] }
+
 alloy = { git = "https://github.com/alloy-rs/alloy", version = "0.1.0", rev = "5fbf57bac99edef9d8475190109a7ea9fb7e5e83", features = [
     "provider-http",
     "signers",
@@ -57,6 +60,7 @@ alloy = { git = "https://github.com/alloy-rs/alloy", version = "0.1.0", rev = "5
     "node-bindings",
 
 ], optional = true }
+
 foundry-compilers = { version = "0.4.1", features = [
     "svm-solc",
 ], optional = true }
@@ -70,38 +74,31 @@ reqwest = { version = "0.12.4", default-features = false, features = [
     "stream",
 ], optional = true }
 openssl = { version = "0.10.55", features = ["vendored"], optional = true }
-tokio-postgres = { version = "0.7.10", optional = true }
-pg_bigdecimal = { version = "0.1.5", optional = true }
 lazy_static = { version = "1.4.0", optional = true }
 colored_json = { version = "3.0.1", default-features = false, optional = true }
-regex = { version = "1", default-features = false, optional = true }
 tokio = { version = "1.35.0", default-features = false, features = [
     "macros",
     "rt-multi-thread",
 ], optional = true }
-pyo3 = { version = "0.23.2", features = [
+pyo3 = { version = "0.24.2", features = [
     "extension-module",
     "abi3-py37",
     "macros",
 ], default-features = false, optional = true }
-pyo3-async-runtimes = { git = "https://github.com/PyO3/pyo3-async-runtimes", version = "0.23.0", features = [
+pyo3-async-runtimes = { git = "https://github.com/PyO3/pyo3-async-runtimes", version = "0.24.0", features = [
     "attributes",
     "tokio-runtime",
 ], default-features = false, optional = true }
 pyo3-log = { version = "0.12.0", default-features = false, optional = true }
 tract-onnx = { git = "https://github.com/sonos/tract/", rev = "37132e0397d0a73e5bd3a8615d932dabe44f6736", default-features = false, optional = true }
 tabled = { version = "0.12.0", optional = true }
-metal = { git = "https://github.com/gfx-rs/metal-rs", optional = true }
 objc = { version = "0.2.4", optional = true }
-mimalloc = { version = "0.1", optional = true }
 pyo3-stub-gen = { version = "0.6.0", optional = true }
+jemallocator = { version = "0.5", optional = true }
+mimalloc = { version = "0.1", optional = true }
+# GPU / device related things (optional - only enabled with gpu-accelerated feature)
+icicle-runtime = { git = "https://github.com/ingonyama-zk/icicle", branch="emir/gate_eval_2", package="icicle-runtime", optional = true }
 
-# universal bindings
-uniffi = { version = "=0.28.0", optional = true }
-getrandom = { version = "0.2.8", optional = true }
-uniffi_bindgen = { version = "=0.28.0", optional = true }
-camino = { version = "^1.1", optional = true }
-uuid = { version = "1.10.0", features = ["v4"], optional = true }
 
 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
 colored = { version = "2.0.0", default-features = false, optional = true }
@@ -211,9 +208,7 @@ test = false
 bench = false
 required-features = ["ezkl"]
 
-[[bin]]
-name = "ios_gen_bindings"
-required-features = ["ios-bindings", "uuid", "camino", "uniffi_bindgen"]
+
 
 [[bin]]
 name = "py_stub_gen"
@@ -222,79 +217,84 @@ required-features = ["python-bindings"]
 [features]
 web = ["wasm-bindgen-rayon"]
 default = [
+    "eth",
+    "dep:halo2_solidity_verifier",
     "ezkl",
-    "mv-lookup",
     "precompute-coset",
     "no-banner",
     "parallel-poly-read",
+    "reusable-verifier",
 ]
 onnx = ["dep:tract-onnx"]
 python-bindings = ["pyo3", "pyo3-log", "pyo3-async-runtimes", "pyo3-stub-gen"]
-ios-bindings = ["mv-lookup", "precompute-coset", "parallel-poly-read", "uniffi"]
-ios-bindings-test = ["ios-bindings", "uniffi/bindgen-tests"]
+logging = ["dep:colored", "dep:env_logger", "dep:chrono"]
 ezkl = [
     "onnx",
-    "dep:colored",
-    "dep:env_logger",
     "tabled/color",
     "serde_json/std",
     "colored_json",
-    "dep:alloy",
-    "dep:foundry-compilers",
     "dep:ethabi",
     "dep:indicatif",
     "dep:gag",
     "dep:reqwest",
-    "dep:openssl",
-    "dep:tokio-postgres",
-    "dep:pg_bigdecimal",
     "dep:lazy_static",
-    "dep:regex",
     "dep:tokio",
-    "dep:mimalloc",
+    "dep:openssl",
     "dep:chrono",
     "dep:sha256",
-    "dep:portable-atomic",
     "dep:clap_complete",
-    "dep:halo2_solidity_verifier",
     "dep:semver",
     "dep:clap",
     "dep:tosubcommand",
+    "logging",
 ]
+eth = ["dep:alloy", "dep:foundry-compilers", "dep:ethabi"]
 parallel-poly-read = [
     "halo2_proofs/circuit-params",
     "halo2_proofs/parallel-poly-read",
 ]
-mv-lookup = [
-    "halo2_proofs/mv-lookup",
-    "snark-verifier/mv-lookup",
-    "halo2_solidity_verifier/mv-lookup",
-]
+mv-lookup = ["halo2_proofs/mv-lookup", "snark-verifier/mv-lookup"]
 asm = ["halo2curves/asm", "halo2_proofs/asm"]
 precompute-coset = ["halo2_proofs/precompute-coset"]
 det-prove = []
-icicle = ["halo2_proofs/icicle_gpu"]
+gpu-accelerated = ["halo2_proofs/gpu-accelerated", "dep:icicle-runtime"]
 empty-cmd = []
 no-banner = []
 no-update = []
+macos-metal = ["halo2_proofs/macos"]
+ios-metal = ["halo2_proofs/ios"]
+jemalloc = ["dep:jemallocator"]
+mimalloc = ["dep:mimalloc"]
+reusable-verifier = []
 
 
 [patch.'https://github.com/zkonduit/halo2']
-halo2_proofs = { git = "https://github.com/zkonduit/halo2#0654e92bdf725fd44d849bfef3643870a8c7d50b", package = "halo2_proofs" }
+halo2_proofs = { git = "https://github.com/zkonduit/halo2#1dd2090741f006fd031a07da7f3c9dfce5e0015e", package = "halo2_proofs", branch= "ac/conditional-compilation-icicle2", features = [
+    "circuit-params", "mv-lookup"
+] }
+
+[patch.'https://github.com/zkonduit/halo2#f441c920be45f8f05d2c06a173d82e8885a5ed4d']
+halo2_proofs = { git = "https://github.com/zkonduit/halo2#1dd2090741f006fd031a07da7f3c9dfce5e0015e", package = "halo2_proofs", branch= "ac/conditional-compilation-icicle2", features = [
+    "circuit-params", "mv-lookup"
+] }
+
 
 [patch.crates-io]
 uniffi_testing = { git = "https://github.com/ElusAegis/uniffi-rs", branch = "feat/testing-feature-build-fix" }
 
 [profile.release]
+# debug = true
 rustflags = ["-C", "relocation-model=pic"]
 lto = "fat"
 codegen-units = 1
 # panic = "abort"
 
 
+[profile.test-runs]
+inherits = "dev"
+opt-level = 3
+
 [package.metadata.wasm-pack.profile.release]
-wasm-opt = [
-    "-O4",
-    "--flexible-inline-max-function-size",
-    "4294967295",
-]
+wasm-opt = ["-O4", "--flexible-inline-max-function-size", "4294967295"]
+
+

README.md

@@ -43,7 +43,7 @@ The generated proofs can then be verified with much less computational resources
 
 ----------------------
 
-### getting started ⚙️
+### Getting Started ⚙️
 
 The easiest way to get started is to try out a notebook. 
 
@@ -76,12 +76,7 @@ For more details visit the [docs](https://docs.ezkl.xyz). The CLI is faster than
 
 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 🔨
+### Building the Project 🔨
 
 #### Rust CLI
 
@@ -96,7 +91,7 @@ cargo install --locked --path .
 
 
 
-#### building python bindings
+#### Building Python Bindings
 Python bindings exists and can be built using `maturin`. You will need `rust` and `cargo` to be installed.
 
 ```bash
@@ -126,7 +121,7 @@ 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`.
 
-### contributing 🌎
+### Contributing 🌎
 
 If you're interested in contributing and are unsure where to start, reach out to one of the maintainers:
 
@@ -144,13 +139,21 @@ More broadly:
 
 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
 
-Ezkl is unaudited, beta software undergoing rapid development. There may be bugs. No guarantees of security are made and it should not be relied on in production.
+### Audits & Security
 
-> 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. 
+[v21.0.0](https://github.com/zkonduit/ezkl/releases/tag/v21.0.0) has been audited by Trail of Bits, the report can be found [here](https://github.com/trailofbits/publications/blob/master/reviews/2025-03-zkonduit-ezkl-securityreview.pdf).
 
-### no warranty
+> 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.
 
-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,
+
+Check out `docs/advanced_security` for more advanced information on potential threat vectors that are specific to zero-knowledge inference, quantization, and to machine learning models generally.
+
+
+### No Warranty
+
+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.
+
+Copyright (c) 2025 Zkonduit Inc. 
+

abis/DataAttestationMulti.json

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

abis/DataAttestationSingle.json

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

abis/QuantizeData.json

@@ -1,98 +0,0 @@
-[
-	{
-		"inputs": [
-			{
-				"internalType": "int256[]",
-				"name": "quantized_data",
-				"type": "int256[]"
-			}
-		],
-		"name": "check_is_valid_field_element",
-		"outputs": [
-			{
-				"internalType": "uint256[]",
-				"name": "output",
-				"type": "uint256[]"
-			}
-		],
-		"stateMutability": "pure",
-		"type": "function"
-	},
-	{
-		"inputs": [
-			{
-				"internalType": "bytes[]",
-				"name": "data",
-				"type": "bytes[]"
-			},
-			{
-				"internalType": "uint256[]",
-				"name": "decimals",
-				"type": "uint256[]"
-			},
-			{
-				"internalType": "uint256[]",
-				"name": "scales",
-				"type": "uint256[]"
-			}
-		],
-		"name": "quantize_data_multi",
-		"outputs": [
-			{
-				"internalType": "int256[]",
-				"name": "quantized_data",
-				"type": "int256[]"
-			}
-		],
-		"stateMutability": "pure",
-		"type": "function"
-	},
-	{
-		"inputs": [
-			{
-				"internalType": "bytes",
-				"name": "data",
-				"type": "bytes"
-			},
-			{
-				"internalType": "uint256",
-				"name": "decimals",
-				"type": "uint256"
-			},
-			{
-				"internalType": "uint256[]",
-				"name": "scales",
-				"type": "uint256[]"
-			}
-		],
-		"name": "quantize_data_single",
-		"outputs": [
-			{
-				"internalType": "int256[]",
-				"name": "quantized_data",
-				"type": "int256[]"
-			}
-		],
-		"stateMutability": "pure",
-		"type": "function"
-	},
-	{
-		"inputs": [
-			{
-				"internalType": "int64[]",
-				"name": "quantized_data",
-				"type": "int64[]"
-			}
-		],
-		"name": "to_field_element",
-		"outputs": [
-			{
-				"internalType": "uint256[]",
-				"name": "output",
-				"type": "uint256[]"
-			}
-		],
-		"stateMutability": "pure",
-		"type": "function"
-	}
-]

abis/TestReads.json

@@ -1,32 +0,0 @@
-[
-	{
-		"inputs": [
-			{
-				"internalType": "int256[]",
-				"name": "_numbers",
-				"type": "int256[]"
-			}
-		],
-		"stateMutability": "nonpayable",
-		"type": "constructor"
-	},
-	{
-		"inputs": [
-			{
-				"internalType": "uint256",
-				"name": "",
-				"type": "uint256"
-			}
-		],
-		"name": "arr",
-		"outputs": [
-			{
-				"internalType": "int256",
-				"name": "",
-				"type": "int256"
-			}
-		],
-		"stateMutability": "view",
-		"type": "function"
-	}
-]

benches/accum_conv.rs

@@ -4,7 +4,6 @@ use ezkl::circuit::*;
 use ezkl::pfsys::create_keys;
 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;
@@ -68,11 +67,13 @@ impl Circuit<Fr> for MyCircuit {
                 config
                     .layout(
                         &mut region,
-                        &[self.image.clone(), self.kernel.clone(), self.bias.clone()],
+                        &[&self.image, &self.kernel, &self.bias],
                         Box::new(PolyOp::Conv {
                             padding: vec![(0, 0)],
                             stride: vec![1; 2],
                             group: 1,
+                            data_format: DataFormat::NCHW,
+                            kernel_format: KernelFormat::OIHW,
                         }),
                     )
                     .unwrap();
@@ -151,8 +152,6 @@ fn runcnvrl(c: &mut Criterion) {
                         &params,
                         &pk,
                         CheckMode::UNSAFE,
-                        ezkl::Commitments::KZG,
-                        TranscriptType::EVM,
                         None,
                         None,
                     );

benches/accum_dot.rs

@@ -2,7 +2,6 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
 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;
@@ -15,6 +14,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use rand::rngs::OsRng;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
@@ -59,7 +59,7 @@ impl Circuit<Fr> for MyCircuit {
                 config
                     .layout(
                         &mut region,
-                        &self.inputs,
+                        &self.inputs.iter().collect_vec(),
                         Box::new(PolyOp::Einsum {
                             equation: "i,i->".to_string(),
                         }),
@@ -119,8 +119,6 @@ fn rundot(c: &mut Criterion) {
                     &params,
                     &pk,
                     CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
                     None,
                 );

benches/accum_einsum_matmul.rs

@@ -1,52 +1,78 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use criterion::{
+    criterion_group, criterion_main, AxisScale, BenchmarkId, Criterion, PlotConfiguration,
+    Throughput,
+};
+use ezkl::circuit::einsum::analysis::analyze_einsum_usage;
+use ezkl::circuit::einsum::circuit_params::SingleEinsumParams;
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit;
-use ezkl::pfsys::TranscriptType;
-use ezkl::pfsys::{create_keys, srs::gen_srs};
+use ezkl::pfsys::srs::gen_srs;
+use ezkl::pfsys::{create_keys, create_proof_circuit};
 use ezkl::tensor::*;
+use halo2_proofs::circuit::floor_planner::V1;
 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::multiopen::{ProverSHPLONK, VerifierSHPLONK};
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     arithmetic::Field,
-    circuit::{Layouter, SimpleFloorPlanner, Value},
+    circuit::{Layouter, Value},
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use halo2curves::ff::PrimeField;
+use itertools::Itertools;
 use rand::rngs::OsRng;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
-use std::marker::PhantomData;
+use std::collections::HashMap;
 
 static mut LEN: usize = 4;
-const K: usize = 16;
+static mut K: usize = 15;
 
 #[derive(Clone)]
-struct MyCircuit {
-    inputs: [ValTensor<Fr>; 2],
-    _marker: PhantomData<Fr>,
+struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
+    inputs: [ValTensor<F>; 2],
+    einsum_params: SingleEinsumParams<F>,
 }
 
-impl Circuit<Fr> for MyCircuit {
+impl Circuit<Fr> for MyCircuit<Fr> {
     type Config = BaseConfig<Fr>;
-    type FloorPlanner = SimpleFloorPlanner;
-    type Params = ();
+    type FloorPlanner = V1;
+    type Params = SingleEinsumParams<Fr>;
 
     fn without_witnesses(&self) -> Self {
         self.clone()
     }
 
-    fn configure(cs: &mut ConstraintSystem<Fr>) -> Self::Config {
-        let len = unsafe { LEN };
+    fn configure_with_params(cs: &mut ConstraintSystem<Fr>, params: Self::Params) -> Self::Config {
+        let mut config = Self::Config::default();
 
-        let a = VarTensor::new_advice(cs, K, 1, len * len);
+        let mut equations = HashMap::new();
+        equations.insert((0, params.equation), params.input_axes_to_dims);
+        let analysis = analyze_einsum_usage(&equations).unwrap();
+        let num_einsum_inner_cols = 1;
+        unsafe {
+            config
+                .configure_einsums(cs, &analysis, num_einsum_inner_cols, K)
+                .unwrap();
+            let _constant = VarTensor::constant_cols(cs, K, 2, false);
+        }
 
-        let b = VarTensor::new_advice(cs, K, 1, len * len);
+        config
+    }
 
-        let output = VarTensor::new_advice(cs, K, 1, (len + 1) * len);
+    fn params(&self) -> Self::Params {
+        SingleEinsumParams::<Fr>::new(
+            &self.einsum_params.equation,
+            &[
+                &self.inputs[0].get_inner().unwrap(),
+                &self.inputs[1].get_inner().unwrap(),
+            ],
+        )
+        .unwrap()
+    }
 
-        Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE)
+    fn configure(_cs: &mut ConstraintSystem<Fr>) -> Self::Config {
+        unimplemented!("call configure_with_params instead")
     }
 
     fn synthesize(
@@ -54,16 +80,33 @@ impl Circuit<Fr> for MyCircuit {
         mut config: Self::Config,
         mut layouter: impl Layouter<Fr>,
     ) -> Result<(), Error> {
+        let challenges = config
+            .einsums
+            .as_ref()
+            .ok_or(Error::Synthesis)?
+            .challenges()
+            .unwrap()
+            .iter()
+            .map(|c| layouter.get_challenge(*c))
+            .collect_vec();
+
         layouter.assign_region(
             || "",
             |region| {
-                let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
+                let mut region = region::RegionCtx::new_with_challenges(
+                    region,
+                    0,
+                    1,
+                    1024,
+                    2,
+                    challenges.clone(),
+                );
                 config
                     .layout(
                         &mut region,
-                        &self.inputs,
+                        &self.inputs.iter().collect_vec(),
                         Box::new(PolyOp::Einsum {
-                            equation: "ab,bc->ac".to_string(),
+                            equation: self.einsum_params.equation.clone(),
                         }),
                     )
                     .unwrap();
@@ -76,41 +119,49 @@ impl Circuit<Fr> for MyCircuit {
 
 fn runmatmul(c: &mut Criterion) {
     let mut group = c.benchmark_group("accum_einsum_matmul");
-    let params = gen_srs::<KZGCommitmentScheme<_>>(17);
-    for &len in [4, 32].iter() {
-        unsafe {
-            LEN = len;
+    group.plot_config(PlotConfiguration::default().summary_scale(AxisScale::Linear));
+    group.sampling_mode(criterion::SamplingMode::Flat);
+    group.sample_size(10);
+    let len = 128;
+    unsafe {
+        LEN = len;
+    }
+    for k in 16..17 {
+        let params = unsafe {
+            K = k;
+            gen_srs::<KZGCommitmentScheme<_>>(K as u32)
         };
 
         let mut a = Tensor::from((0..len * len).map(|_| Value::known(Fr::random(OsRng))));
         a.reshape(&[len, len]).unwrap();
 
-        // parameters
         let mut b = Tensor::from((0..len * len).map(|_| Value::known(Fr::random(OsRng))));
         b.reshape(&[len, len]).unwrap();
 
+        let einsum_params = SingleEinsumParams::<Fr>::new("ij,jk->ik", &[&a, &b]).unwrap();
+
         let circuit = MyCircuit {
             inputs: [ValTensor::from(a), ValTensor::from(b)],
-            _marker: PhantomData,
+            einsum_params,
         };
 
         group.throughput(Throughput::Elements(len as u64));
-        group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
+        group.bench_with_input(BenchmarkId::new("pk", k), &k, |b, &_| {
             b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit<Fr>>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit<Fr>>(&circuit, &params, false)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
-        group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
+        group.bench_with_input(BenchmarkId::new("prove", k), &k, |b, &_| {
             b.iter(|| {
                 let prover = create_proof_circuit::<
                     KZGCommitmentScheme<_>,
-                    MyCircuit,
+                    MyCircuit<Fr>,
                     ProverSHPLONK<_>,
                     VerifierSHPLONK<_>,
                     SingleStrategy<_>,
@@ -123,8 +174,6 @@ fn runmatmul(c: &mut Criterion) {
                     &params,
                     &pk,
                     CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
                     None,
                 );

benches/accum_matmul_sigmoid.rs

@@ -5,7 +5,7 @@ use ezkl::circuit::*;
 use ezkl::circuit::lookup::LookupOp;
 use ezkl::circuit::poly::PolyOp;
 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;
@@ -17,6 +17,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
 
@@ -86,13 +87,13 @@ impl Circuit<Fr> for MyCircuit {
                 let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 let output = config
                     .base_config
-                    .layout(&mut region, &self.inputs, Box::new(op))
+                    .layout(&mut region, &self.inputs.iter().collect_vec(), Box::new(op))
                     .unwrap();
                 let _output = config
                     .base_config
                     .layout(
                         &mut region,
-                        &[output.unwrap()],
+                        &[&output.unwrap()],
                         Box::new(LookupOp::Sigmoid { scale: 1.0.into() }),
                     )
                     .unwrap();
@@ -153,8 +154,6 @@ fn runmatmul(c: &mut Criterion) {
                     &params,
                     &pk,
                     CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
                     None,
                 );

benches/accum_matmul_sigmoid_overflow.rs

@@ -5,7 +5,7 @@ use ezkl::circuit::lookup::LookupOp;
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::table::Range;
 use ezkl::pfsys::create_proof_circuit;
-use ezkl::pfsys::TranscriptType;
+
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
@@ -17,6 +17,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
 
@@ -87,13 +88,13 @@ impl Circuit<Fr> for MyCircuit {
                 let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 let output = config
                     .base_config
-                    .layout(&mut region, &self.inputs, Box::new(op))
+                    .layout(&mut region, &self.inputs.iter().collect_vec(), Box::new(op))
                     .unwrap();
                 let _output = config
                     .base_config
                     .layout(
                         &mut region,
-                        &[output.unwrap()],
+                        &[&output.unwrap()],
                         Box::new(LookupOp::Sigmoid { scale: 1.0.into() }),
                     )
                     .unwrap();
@@ -156,8 +157,6 @@ fn runmatmul(c: &mut Criterion) {
                     &params,
                     &pk,
                     CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
                     None,
                 );

benches/accum_sum.rs

@@ -2,7 +2,7 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
 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;
@@ -15,6 +15,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use rand::rngs::OsRng;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
@@ -59,7 +60,7 @@ impl Circuit<Fr> for MyCircuit {
                 config
                     .layout(
                         &mut region,
-                        &self.inputs,
+                        &self.inputs.iter().collect_vec(),
                         Box::new(PolyOp::Sum { axes: vec![0] }),
                     )
                     .unwrap();
@@ -115,8 +116,6 @@ fn runsum(c: &mut Criterion) {
                     &params,
                     &pk,
                     CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
                     None,
                 );

benches/accum_sumpool.rs

@@ -4,7 +4,7 @@ use ezkl::circuit::*;
 use ezkl::pfsys::create_keys;
 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;
@@ -63,12 +63,13 @@ impl Circuit<Fr> for MyCircuit {
                 config
                     .layout(
                         &mut region,
-                        &[self.image.clone()],
+                        &[&self.image],
                         Box::new(HybridOp::SumPool {
                             padding: vec![(0, 0); 2],
                             stride: vec![1, 1],
                             kernel_shape: vec![2, 2],
                             normalized: false,
+                            data_format: DataFormat::NCHW,
                         }),
                     )
                     .unwrap();
@@ -130,8 +131,6 @@ fn runsumpool(c: &mut Criterion) {
                         &params,
                         &pk,
                         CheckMode::UNSAFE,
-                        ezkl::Commitments::KZG,
-                        TranscriptType::EVM,
                         None,
                         None,
                     );

benches/pairwise_add.rs

@@ -2,7 +2,7 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
 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;
@@ -15,6 +15,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use rand::rngs::OsRng;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
@@ -57,7 +58,11 @@ impl Circuit<Fr> for MyCircuit {
             |region| {
                 let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
-                    .layout(&mut region, &self.inputs, Box::new(PolyOp::Add))
+                    .layout(
+                        &mut region,
+                        &self.inputs.iter().collect_vec(),
+                        Box::new(PolyOp::Add),
+                    )
                     .unwrap();
                 Ok(())
             },
@@ -113,8 +118,6 @@ fn runadd(c: &mut Criterion) {
                     &params,
                     &pk,
                     CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
                     None,
                 );

benches/pairwise_pow.rs

@@ -3,7 +3,7 @@ use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::*;
 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;
@@ -16,6 +16,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use rand::rngs::OsRng;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
@@ -58,7 +59,11 @@ impl Circuit<Fr> for MyCircuit {
             |region| {
                 let mut region = RegionCtx::new(region, 0, 1, 1024, 2);
                 config
-                    .layout(&mut region, &self.inputs, Box::new(PolyOp::Pow(4)))
+                    .layout(
+                        &mut region,
+                        &self.inputs.iter().collect_vec(),
+                        Box::new(PolyOp::Pow(4)),
+                    )
                     .unwrap();
                 Ok(())
             },
@@ -112,8 +117,6 @@ fn runpow(c: &mut Criterion) {
                     &params,
                     &pk,
                     CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
                     None,
                 );

benches/poseidon.rs

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

benches/relu_lookupless.rs

@@ -4,7 +4,7 @@ use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::{BaseConfig as Config, CheckMode};
 use ezkl::fieldutils::IntegerRep;
 use ezkl::pfsys::create_proof_circuit;
-use ezkl::pfsys::TranscriptType;
+
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
@@ -70,7 +70,7 @@ impl Circuit<Fr> for NLCircuit {
                 config
                     .layout(
                         &mut region,
-                        &[self.input.clone()],
+                        &[&self.input],
                         Box::new(PolyOp::LeakyReLU {
                             slope: 0.0.into(),
                             scale: 1,
@@ -130,8 +130,6 @@ fn runrelu(c: &mut Criterion) {
                     &params,
                     &pk,
                     CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
                     None,
                 );

benches/sigmoid.rs

@@ -4,7 +4,7 @@ use ezkl::circuit::table::Range;
 use ezkl::circuit::{ops::lookup::LookupOp, BaseConfig as Config, CheckMode};
 use ezkl::fieldutils::IntegerRep;
 use ezkl::pfsys::create_proof_circuit;
-use ezkl::pfsys::TranscriptType;
+
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
@@ -67,7 +67,7 @@ impl Circuit<Fr> for NLCircuit {
                 config
                     .layout(
                         &mut region,
-                        &[self.input.clone()],
+                        &[&self.input],
                         Box::new(LookupOp::Sigmoid { scale: 1.0.into() }),
                     )
                     .unwrap();
@@ -124,8 +124,6 @@ fn runrelu(c: &mut Criterion) {
                     &params,
                     &pk,
                     CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
                     None,
                 );

benches/zero_finder.rs

@@ -10,6 +10,7 @@ use rand::Rng;
 
 // Assuming these are your types
 #[derive(Clone)]
+#[allow(dead_code)]
 enum ValType {
     Constant(F),
     AssignedConstant(usize, F),
@@ -21,7 +22,7 @@ fn generate_test_data(size: usize, zero_probability: f64) -> Vec<ValType> {
     let mut rng = rand::thread_rng();
     (0..size)
         .map(|_i| {
-            if rng.gen::<f64>() < zero_probability {
+            if rng.r#gen::<f64>() < zero_probability {
                 ValType::Constant(F::ZERO)
             } else {
                 ValType::Constant(F::ONE) // Or some other non-zero value

build.rs

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

contracts/AttestData.sol

@@ -1,692 +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)
-                    )
-                )
-            }
-        }
-    }
-}
-
-// 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
-    } /// end checkKzgCommits
-}
-
-contract DataAttestationSingle is LoadInstances, SwapProofCommitments {
-    /**
-     * @notice Struct used to make view only call to account to fetch the data that EZKL reads from.
-     * @param the address of the account to make calls to
-     * @param the abi encoded function calls to make to the `contractAddress`
-     */
-    struct AccountCall {
-        address contractAddress;
-        bytes callData;
-        uint256 decimals;
-    }
-    AccountCall public accountCall;
-
-    uint[] scales;
-
-    address public admin;
-
-    /**
-     * @notice EZKL P value
-     * @dev In order to prevent the verifier from accepting two version of the same pubInput, n and the quantity (n + P),  where n + P <= 2^256, we require that all instances are stricly less than P. a
-     * @dev The reason for this is that the assmebly code of the verifier performs all arithmetic operations modulo P and as a consequence can't distinguish between n and n + P.
-     */
-    uint256 constant ORDER =
-        uint256(
-            0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
-        );
-
-    uint256 constant INPUT_LEN = 0;
-
-    uint256 constant OUTPUT_LEN = 0;
-
-    uint8 public instanceOffset;
-
-    /**
-     * @dev Initialize the contract with account calls the EZKL model will read from.
-     * @param _contractAddresses - The calls to all the contracts EZKL reads storage from.
-     * @param _callData - The abi encoded function calls to make to the `contractAddress` that EZKL reads storage from.
-     */
-    constructor(
-        address _contractAddresses,
-        bytes memory _callData,
-        uint256 _decimals,
-        uint[] memory _scales,
-        uint8 _instanceOffset,
-        address _admin
-    ) {
-        admin = _admin;
-        for (uint i; i < _scales.length; i++) {
-            scales.push(1 << _scales[i]);
-        }
-        populateAccountCalls(_contractAddresses, _callData, _decimals);
-        instanceOffset = _instanceOffset;
-    }
-
-    function updateAdmin(address _admin) external {
-        require(msg.sender == admin, "Only admin can update admin");
-        if (_admin == address(0)) {
-            revert();
-        }
-        admin = _admin;
-    }
-
-    function updateAccountCalls(
-        address _contractAddresses,
-        bytes memory _callData,
-        uint256 _decimals
-    ) external {
-        require(msg.sender == admin, "Only admin can update account calls");
-        populateAccountCalls(_contractAddresses, _callData, _decimals);
-    }
-
-    function populateAccountCalls(
-        address _contractAddresses,
-        bytes memory _callData,
-        uint256 _decimals
-    ) internal {
-        AccountCall memory _accountCall = accountCall;
-        _accountCall.contractAddress = _contractAddresses;
-        _accountCall.callData = _callData;
-        _accountCall.decimals = 10 ** _decimals;
-        accountCall = _accountCall;
-    }
-
-    function mulDiv(
-        uint256 x,
-        uint256 y,
-        uint256 denominator
-    ) internal pure returns (uint256 result) {
-        unchecked {
-            uint256 prod0;
-            uint256 prod1;
-            assembly {
-                let mm := mulmod(x, y, not(0))
-                prod0 := mul(x, y)
-                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
-            }
-
-            if (prod1 == 0) {
-                return prod0 / denominator;
-            }
-
-            require(denominator > prod1, "Math: mulDiv overflow");
-
-            uint256 remainder;
-            assembly {
-                remainder := mulmod(x, y, denominator)
-                prod1 := sub(prod1, gt(remainder, prod0))
-                prod0 := sub(prod0, remainder)
-            }
-
-            uint256 twos = denominator & (~denominator + 1);
-            assembly {
-                denominator := div(denominator, twos)
-                prod0 := div(prod0, twos)
-                twos := add(div(sub(0, twos), twos), 1)
-            }
-
-            prod0 |= prod1 * twos;
-
-            uint256 inverse = (3 * denominator) ^ 2;
-
-            inverse *= 2 - denominator * inverse;
-            inverse *= 2 - denominator * inverse;
-            inverse *= 2 - denominator * inverse;
-            inverse *= 2 - denominator * inverse;
-            inverse *= 2 - denominator * inverse;
-            inverse *= 2 - denominator * inverse;
-
-            result = prod0 * inverse;
-            return result;
-        }
-    }
-    /**
-     * @dev Quantize the data returned from the account calls to the scale used by the EZKL model.
-     * @param x - One of the elements of the data returned from the account calls
-     * @param _decimals - Number of base 10 decimals to scale the data by.
-     * @param _scale - The base 2 scale used to convert the floating point value into a fixed point value.
-     *
-     */
-    function quantizeData(
-        int x,
-        uint256 _decimals,
-        uint256 _scale
-    ) internal pure returns (int256 quantized_data) {
-        bool neg = x < 0;
-        if (neg) x = -x;
-        uint output = mulDiv(uint256(x), _scale, _decimals);
-        if (mulmod(uint256(x), _scale, _decimals) * 2 >= _decimals) {
-            output += 1;
-        }
-        quantized_data = neg ? -int256(output) : int256(output);
-    }
-    /**
-     * @dev Make a static call to the account to fetch the data that EZKL reads from.
-     * @param target - The address of the account to make calls to.
-     * @param data  - The abi encoded function calls to make to the `contractAddress` that EZKL reads storage from.
-     * @return The data returned from the account calls. (Must come from either a view or pure function. Will throw an error otherwise)
-     */
-    function staticCall(
-        address target,
-        bytes memory data
-    ) internal view returns (bytes memory) {
-        (bool success, bytes memory returndata) = target.staticcall(data);
-        if (success) {
-            if (returndata.length == 0) {
-                require(
-                    target.code.length > 0,
-                    "Address: call to non-contract"
-                );
-            }
-            return returndata;
-        } else {
-            revert("Address: low-level call failed");
-        }
-    }
-    /**
-     * @dev Convert the fixed point quantized data into a field element.
-     * @param x - The quantized data.
-     * @return field_element - The field element.
-     */
-    function toFieldElement(
-        int256 x
-    ) internal pure returns (uint256 field_element) {
-        // The casting down to uint256 is safe because the order is about 2^254, and the value
-        // of x ranges of -2^127 to 2^127, so x + int(ORDER) is always positive.
-        return uint256(x + int(ORDER)) % ORDER;
-    }
-
-    /**
-     * @dev Make the account calls to fetch the data that EZKL reads from and attest to the data.
-     * @param instances - The public instances to the proof (the data in the proof that publicly accessible to the verifier).
-     */
-    function attestData(uint256[] memory instances) internal view {
-        require(
-            instances.length >= INPUT_LEN + OUTPUT_LEN,
-            "Invalid public inputs length"
-        );
-        AccountCall memory _accountCall = accountCall;
-        uint[] memory _scales = scales;
-        bytes memory returnData = staticCall(
-            _accountCall.contractAddress,
-            _accountCall.callData
-        );
-        int256[] memory x = abi.decode(returnData, (int256[]));
-        uint _offset;
-        int output = quantizeData(x[0], _accountCall.decimals, _scales[0]);
-        uint field_element = toFieldElement(output);
-        for (uint i = 0; i < x.length; i++) {
-            if (field_element != instances[i + instanceOffset]) {
-                _offset += 1;
-            } else {
-                break;
-            }
-        }
-        uint length = x.length - _offset;
-        for (uint i = 1; i < length; i++) {
-            output = quantizeData(x[i], _accountCall.decimals, _scales[i]);
-            field_element = toFieldElement(output);
-            require(
-                field_element == instances[i + instanceOffset + _offset],
-                "Public input does not match"
-            );
-        }
-    }
-
-    /**
-     * @dev Verify the proof with the data attestation.
-     * @param verifier - The address of the verifier contract.
-     * @param encoded - The verifier calldata.
-     */
-    function verifyWithDataAttestation(
-        address verifier,
-        bytes calldata encoded
-    ) public view returns (bool) {
-        require(verifier.code.length > 0, "Address: call to non-contract");
-        attestData(getInstancesCalldata(encoded));
-        // static call the verifier contract to verify the proof
-        (bool success, bytes memory returndata) = verifier.staticcall(encoded);
-
-        if (success) {
-            return abi.decode(returndata, (bool));
-        } else {
-            revert("low-level call to verifier failed");
-        }
-    }
-}
-
-// This contract serves as a Data Attestation Verifier for the EZKL model.
-// It is designed to read and attest to instances of proofs generated from a specified circuit.
-// It is particularly constructed to read only int256 data from specified on-chain contracts' view functions.
-
-// Overview of the contract functionality:
-// 1. Initialization: Through the constructor, it sets up the contract calls that the EZKL model will read from.
-// 2. Data Quantization: Quantizes the returned data into a scaled fixed-point representation. See the `quantizeData` method for details.
-// 3. Static Calls: Makes static calls to fetch data from other contracts. See the `staticCall` method.
-// 4. Field Element Conversion: The fixed-point representation is then converted into a field element modulo P using the `toFieldElement` method.
-// 5. Data Attestation: The `attestData` method validates that the public instances match the data fetched and processed by the contract.
-// 6. Proof Verification: The `verifyWithDataAttestationMulti` method parses the instances out of the encoded calldata and calls the `attestData` method to validate the public instances,
-// 6b. Optional KZG Commitment Verification: It also checks the KZG commitments in the proof against the expected commitments using the `checkKzgCommits` method.
-//  then calls the `verifyProof` method to verify the proof on the verifier.
-
-contract DataAttestationMulti is LoadInstances, SwapProofCommitments {
-    /**
-     * @notice Struct used to make view only calls to accounts to fetch the data that EZKL reads from.
-     * @param the address of the account to make calls to
-     * @param the abi encoded function calls to make to the `contractAddress`
-     */
-    struct AccountCall {
-        address contractAddress;
-        mapping(uint256 => bytes) callData;
-        mapping(uint256 => uint256) decimals;
-        uint callCount;
-    }
-    AccountCall[] public accountCalls;
-
-    uint[] public scales;
-
-    address public admin;
-
-    /**
-     * @notice EZKL P value
-     * @dev In order to prevent the verifier from accepting two version of the same pubInput, n and the quantity (n + P),  where n + P <= 2^256, we require that all instances are stricly less than P. a
-     * @dev The reason for this is that the assmebly code of the verifier performs all arithmetic operations modulo P and as a consequence can't distinguish between n and n + P.
-     */
-    uint256 constant ORDER =
-        uint256(
-            0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
-        );
-
-    uint256 constant INPUT_CALLS = 0;
-
-    uint256 constant OUTPUT_CALLS = 0;
-
-    uint8 public instanceOffset;
-
-    /**
-     * @dev Initialize the contract with account calls the EZKL model will read from.
-     * @param _contractAddresses - The calls to all the contracts EZKL reads storage from.
-     * @param _callData - The abi encoded function calls to make to the `contractAddress` that EZKL reads storage from.
-     */
-    constructor(
-        address[] memory _contractAddresses,
-        bytes[][] memory _callData,
-        uint256[][] memory _decimals,
-        uint[] memory _scales,
-        uint8 _instanceOffset,
-        address _admin
-    ) {
-        admin = _admin;
-        for (uint i; i < _scales.length; i++) {
-            scales.push(1 << _scales[i]);
-        }
-        populateAccountCalls(_contractAddresses, _callData, _decimals);
-        instanceOffset = _instanceOffset;
-    }
-
-    function updateAdmin(address _admin) external {
-        require(msg.sender == admin, "Only admin can update admin");
-        if (_admin == address(0)) {
-            revert();
-        }
-        admin = _admin;
-    }
-
-    function updateAccountCalls(
-        address[] memory _contractAddresses,
-        bytes[][] memory _callData,
-        uint256[][] memory _decimals
-    ) external {
-        require(msg.sender == admin, "Only admin can update account calls");
-        populateAccountCalls(_contractAddresses, _callData, _decimals);
-    }
-
-    function populateAccountCalls(
-        address[] memory _contractAddresses,
-        bytes[][] memory _callData,
-        uint256[][] memory _decimals
-    ) internal {
-        require(
-            _contractAddresses.length == _callData.length &&
-                accountCalls.length == _contractAddresses.length,
-            "Invalid input length"
-        );
-        require(
-            _decimals.length == _contractAddresses.length,
-            "Invalid number of decimals"
-        );
-        // fill in the accountCalls storage array
-        uint counter = 0;
-        for (uint256 i = 0; i < _contractAddresses.length; i++) {
-            AccountCall storage accountCall = accountCalls[i];
-            accountCall.contractAddress = _contractAddresses[i];
-            accountCall.callCount = _callData[i].length;
-            for (uint256 j = 0; j < _callData[i].length; j++) {
-                accountCall.callData[j] = _callData[i][j];
-                accountCall.decimals[j] = 10 ** _decimals[i][j];
-            }
-            // 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"
-        );
-    }
-
-    function mulDiv(
-        uint256 x,
-        uint256 y,
-        uint256 denominator
-    ) internal pure returns (uint256 result) {
-        unchecked {
-            uint256 prod0;
-            uint256 prod1;
-            assembly {
-                let mm := mulmod(x, y, not(0))
-                prod0 := mul(x, y)
-                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
-            }
-
-            if (prod1 == 0) {
-                return prod0 / denominator;
-            }
-
-            require(denominator > prod1, "Math: mulDiv overflow");
-
-            uint256 remainder;
-            assembly {
-                remainder := mulmod(x, y, denominator)
-                prod1 := sub(prod1, gt(remainder, prod0))
-                prod0 := sub(prod0, remainder)
-            }
-
-            uint256 twos = denominator & (~denominator + 1);
-            assembly {
-                denominator := div(denominator, twos)
-                prod0 := div(prod0, twos)
-                twos := add(div(sub(0, twos), twos), 1)
-            }
-
-            prod0 |= prod1 * twos;
-
-            uint256 inverse = (3 * denominator) ^ 2;
-
-            inverse *= 2 - denominator * inverse;
-            inverse *= 2 - denominator * inverse;
-            inverse *= 2 - denominator * inverse;
-            inverse *= 2 - denominator * inverse;
-            inverse *= 2 - denominator * inverse;
-            inverse *= 2 - denominator * inverse;
-
-            result = prod0 * inverse;
-            return result;
-        }
-    }
-    /**
-     * @dev Quantize the data returned from the account calls to the scale used by the EZKL model.
-     * @param 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.
-     */
-    function quantizeData(
-        bytes memory data,
-        uint256 decimals,
-        uint256 scale
-    ) internal pure returns (int256 quantized_data) {
-        int x = abi.decode(data, (int256));
-        bool neg = x < 0;
-        if (neg) x = -x;
-        uint output = mulDiv(uint256(x), scale, decimals);
-        if (mulmod(uint256(x), scale, decimals) * 2 >= decimals) {
-            output += 1;
-        }
-        quantized_data = neg ? -int256(output) : int256(output);
-    }
-    /**
-     * @dev Make a static call to the account to fetch the data that EZKL reads from.
-     * @param target - The address of the account to make calls to.
-     * @param data  - The abi encoded function calls to make to the `contractAddress` that EZKL reads storage from.
-     * @return The data returned from the account calls. (Must come from either a view or pure function. Will throw an error otherwise)
-     */
-    function staticCall(
-        address target,
-        bytes memory data
-    ) internal view returns (bytes memory) {
-        (bool success, bytes memory returndata) = target.staticcall(data);
-        if (success) {
-            if (returndata.length == 0) {
-                require(
-                    target.code.length > 0,
-                    "Address: call to non-contract"
-                );
-            }
-            return returndata;
-        } else {
-            revert("Address: low-level call failed");
-        }
-    }
-    /**
-     * @dev Convert the fixed point quantized data into a field element.
-     * @param x - The quantized data.
-     * @return field_element - The field element.
-     */
-    function toFieldElement(
-        int256 x
-    ) internal pure returns (uint256 field_element) {
-        // The casting down to uint256 is safe because the order is about 2^254, and the value
-        // of x ranges of -2^127 to 2^127, so x + int(ORDER) is always positive.
-        return uint256(x + int(ORDER)) % ORDER;
-    }
-
-    /**
-     * @dev Make the account calls to fetch the data that EZKL reads from and attest to the data.
-     * @param instances - The public instances to the proof (the data in the proof that publicly accessible to the verifier).
-     */
-    function attestData(uint256[] memory instances) internal view {
-        require(
-            instances.length >= INPUT_CALLS + OUTPUT_CALLS,
-            "Invalid public inputs length"
-        );
-        uint256 _accountCount = accountCalls.length;
-        uint counter = 0;
-        for (uint8 i = 0; i < _accountCount; ++i) {
-            address account = accountCalls[i].contractAddress;
-            for (uint8 j = 0; j < accountCalls[i].callCount; j++) {
-                bytes memory returnData = staticCall(
-                    account,
-                    accountCalls[i].callData[j]
-                );
-                uint256 scale = scales[counter];
-                int256 quantized_data = quantizeData(
-                    returnData,
-                    accountCalls[i].decimals[j],
-                    scale
-                );
-                uint256 field_element = toFieldElement(quantized_data);
-                require(
-                    field_element == instances[counter + instanceOffset],
-                    "Public input does not match"
-                );
-                counter++;
-            }
-        }
-    }
-
-    /**
-     * @dev Verify the proof with the data attestation.
-     * @param verifier - The address of the verifier contract.
-     * @param encoded - The verifier calldata.
-     */
-    function verifyWithDataAttestation(
-        address verifier,
-        bytes calldata encoded
-    ) public view returns (bool) {
-        require(verifier.code.length > 0, "Address: call to non-contract");
-        attestData(getInstancesCalldata(encoded));
-        require(checkKzgCommits(encoded), "Invalid KZG commitments");
-        // static call the verifier contract to verify the proof
-        (bool success, bytes memory returndata) = verifier.staticcall(encoded);
-
-        if (success) {
-            return abi.decode(returndata, (bool));
-        } else {
-            revert("low-level call to verifier failed");
-        }
-    }
-}

docs/advanced_security/public_commitments.md

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

docs/advanced_security/quantization_backdoors.md

@@ -0,0 +1,54 @@
+# EZKL Security Note: Quantization-Activated Model Backdoors
+
+## Model backdoors and provenance
+
+Machine learning models inherently suffer from robustness issues, which can lead to various
+kinds of attacks, from backdoors to evasion attacks. These vulnerabilities are a direct byproductof how machine learning models learn and cannot be remediated.
+
+We say a model has a backdoor whenever a specific attacker-chosen trigger in the input leads
+to the model misbehaving. For instance, if we have an image classifier discriminating cats from dogs, the ability to turn any image of a cat into an image classified as a dog by changing a specific pixel pattern constitutes a backdoor.
+
+Backdoors can be introduced using many different vectors. An attacker can introduce a
+backdoor using traditional security vulnerabilities. For instance, they could directly alter the file containing model weights or dynamically hack the Python code of the model. In addition, backdoors can be introduced by the training data through a process known as poisoning. In this case, an attacker adds malicious data points to the dataset before the model is trained so that the model learns to associate the backdoor trigger with the intended misbehavior.
+
+All these vectors constitute a whole range of provenance challenges, as any component of an
+AI system can virtually be an entrypoint for a backdoor. Although provenance is already a
+concern with traditional code, the issue is exacerbated with AI, as retraining a model is
+cost-prohibitive. It is thus impractical to translate the “recompile it yourself” thinking to AI.
+
+## Quantization activated backdoors
+
+Backdoors are a generic concern in AI that is outside the scope of EZKL. However, EZKL may
+activate a specific subset of backdoors. Several academic papers have demonstrated the
+possibility, both in theory and in practice, of implanting undetectable and inactive backdoors in a full precision model that can be reactivated by quantization.
+
+An external attacker may trick the user of an application running EZKL into loading a model
+containing a quantization backdoor. This backdoor is active in the resulting model and circuit but not in the full-precision model supplied to EZKL, compromising the integrity of the target application and the resulting proof.
+
+### When is this a concern for me as a user?
+
+Any untrusted component in your AI stack may be a backdoor vector. In practice, the most
+sensitive parts include:
+
+- Datasets downloaded from the web or containing crowdsourced data
+- Models downloaded from the web even after finetuning
+- Untrusted software dependencies (well-known frameworks such as PyTorch can typically
+be considered trusted)
+- Any component loaded through an unsafe serialization format, such as Pickle.
+Because backdoors are inherent to ML and cannot be eliminated, reviewing the provenance of
+these sensitive components is especially important.
+
+### Responsibilities of the user and EZKL
+
+As EZKL cannot prevent backdoored models from being used, it is the responsibility of the user to review the provenance of all the components in their AI stack to ensure that no backdoor could have been implanted. EZKL shall not be held responsible for misleading prediction proofs resulting from using a backdoored model or for any harm caused to a system or its users due to a misbehaving model.
+
+### Limitations:
+
+- Attack effectiveness depends on calibration settings and internal rescaling operations.
+- Further research needed on backdoor persistence through witness/proof stages.
+- Can be mitigated by evaluating the quantized model (using `ezkl gen-witness`), rather than relying on the evaluation of the original model in pytorch or onnx-runtime as difference in evaluation could reveal a backdoor.
+
+References:
+
+1. [Quantization Backdoors to Deep Learning Commercial Frameworks (Ma et al., 2021)](https://arxiv.org/abs/2108.09187)
+2. [Planting Undetectable Backdoors in Machine Learning Models (Goldwasser et al., 2022)](https://arxiv.org/abs/2204.06974)

examples/accum_einsum_matmul.rs

@@ -0,0 +1,171 @@
+use ezkl::circuit::einsum::analysis::analyze_einsum_usage;
+use ezkl::circuit::poly::PolyOp;
+use ezkl::circuit::*;
+use ezkl::tensor::*;
+use halo2_proofs::circuit::floor_planner::V1;
+use halo2_proofs::dev::MockProver;
+use halo2_proofs::{
+    arithmetic::Field,
+    circuit::{Layouter, Value},
+    plonk::{Circuit, ConstraintSystem, Error},
+};
+use halo2curves::bn256::Fr;
+use halo2curves::ff::PrimeField;
+use itertools::Itertools;
+use rand::rngs::OsRng;
+use std::collections::HashMap;
+use std::marker::PhantomData;
+
+const K: usize = 13;
+
+#[derive(Clone)]
+struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
+    inputs: [ValTensor<F>; 2],
+    einsum: Einsum<F>,
+}
+
+#[derive(Clone, Default)]
+struct Einsum<F: PrimeField + TensorType + PartialOrd> {
+    equation: String,
+    input_axes_to_dims: HashMap<char, usize>,
+    _marker: PhantomData<F>,
+}
+
+impl<F: PrimeField + TensorType + PartialOrd> Einsum<F> {
+    pub fn new(equation: &str, inputs: &[&Tensor<Value<F>>]) -> Result<Self, CircuitError> {
+        let mut eq = equation.split("->");
+        let inputs_eq = eq.next().ok_or(CircuitError::InvalidEinsum)?;
+        let inputs_eq = inputs_eq.split(',').collect::<Vec<_>>();
+
+        // Check that the number of inputs matches the number of inputs in the equation
+        if inputs.len() != inputs_eq.len() {
+            return Err(TensorError::DimMismatch("einsum".to_string()).into());
+        }
+
+        let mut input_axes_to_dims = HashMap::new();
+        for (i, input) in inputs.iter().enumerate() {
+            for j in 0..inputs_eq[i].len() {
+                let c = inputs_eq[i]
+                    .chars()
+                    .nth(j)
+                    .ok_or(CircuitError::InvalidEinsum)?;
+                if let std::collections::hash_map::Entry::Vacant(e) = input_axes_to_dims.entry(c) {
+                    e.insert(input.dims()[j]);
+                } else if input_axes_to_dims[&c] != input.dims()[j] {
+                    return Err(TensorError::DimMismatch("einsum".to_string()).into());
+                }
+            }
+        }
+
+        Ok(Self {
+            equation: equation.to_owned(),
+            input_axes_to_dims,
+            _marker: PhantomData,
+        })
+    }
+}
+
+impl Circuit<Fr> for MyCircuit<Fr> {
+    type Config = BaseConfig<Fr>;
+    type FloorPlanner = V1;
+    type Params = Einsum<Fr>;
+
+    fn without_witnesses(&self) -> Self {
+        self.clone()
+    }
+
+    fn configure_with_params(cs: &mut ConstraintSystem<Fr>, params: Self::Params) -> Self::Config {
+        let mut config = Self::Config::default();
+
+        let mut equations = HashMap::new();
+        equations.insert((0, params.equation), params.input_axes_to_dims);
+        let analysis = analyze_einsum_usage(&equations).unwrap();
+        let num_einsum_inner_cols = 1;
+        config
+            .configure_einsums(cs, &analysis, num_einsum_inner_cols, K)
+            .unwrap();
+
+        config
+    }
+
+    fn params(&self) -> Self::Params {
+        Einsum::<Fr>::new(
+            &self.einsum.equation,
+            &[
+                &self.inputs[0].get_inner().unwrap(),
+                &self.inputs[1].get_inner().unwrap(),
+            ],
+        )
+        .unwrap()
+    }
+
+    fn configure(_cs: &mut ConstraintSystem<Fr>) -> Self::Config {
+        unimplemented!("call configure_with_params instead")
+    }
+
+    fn synthesize(
+        &self,
+        mut config: Self::Config,
+        mut layouter: impl Layouter<Fr>,
+    ) -> Result<(), Error> {
+        let challenges = config
+            .einsums
+            .as_ref()
+            .ok_or(Error::Synthesis)?
+            .challenges()
+            .unwrap()
+            .iter()
+            .map(|c| layouter.get_challenge(*c))
+            .collect_vec();
+
+        layouter.assign_region(
+            || "",
+            |region| {
+                let mut region = region::RegionCtx::new_with_challenges(
+                    region,
+                    0,
+                    1,
+                    1024,
+                    2,
+                    challenges.clone(),
+                );
+                config
+                    .layout(
+                        &mut region,
+                        &self.inputs.iter().collect_vec(),
+                        Box::new(PolyOp::Einsum {
+                            equation: self.einsum.equation.clone(),
+                        }),
+                    )
+                    .unwrap();
+                Ok(())
+            },
+        )?;
+        Ok(())
+    }
+}
+
+fn runmatmul() {
+    let len = 64;
+
+    let mut a = Tensor::from((0..len * len).map(|_| Value::known(Fr::random(OsRng))));
+    a.reshape(&[len, len]).unwrap();
+
+    // parameters
+    let mut b = Tensor::from((0..len * len).map(|_| Value::known(Fr::random(OsRng))));
+    b.reshape(&[len, len]).unwrap();
+
+    let einsum = Einsum::<Fr>::new("ij,jk->ik", &[&a, &b]).unwrap();
+
+    let circuit = MyCircuit {
+        inputs: [ValTensor::from(a), ValTensor::from(b)],
+        einsum,
+    };
+
+    let mock_prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
+    mock_prover.assert_satisfied();
+}
+
+pub fn main() {
+    runmatmul()
+}

examples/batch_mat_mul.rs

@@ -0,0 +1,179 @@
+use ezkl::circuit::einsum::analysis::analyze_einsum_usage;
+use ezkl::circuit::poly::PolyOp;
+use ezkl::circuit::*;
+use ezkl::tensor::*;
+use halo2_proofs::circuit::floor_planner::V1;
+use halo2_proofs::dev::MockProver;
+use halo2_proofs::{
+    arithmetic::Field,
+    circuit::{Layouter, Value},
+    plonk::{Circuit, ConstraintSystem, Error},
+};
+use halo2curves::bn256::Fr;
+use halo2curves::ff::PrimeField;
+use itertools::Itertools;
+use rand::rngs::OsRng;
+use std::collections::HashMap;
+use std::marker::PhantomData;
+
+static mut LEN: usize = 4;
+const K: usize = 11;
+
+#[derive(Clone)]
+struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
+    inputs: [ValTensor<F>; 2],
+    einsum: Einsum<F>,
+}
+
+#[derive(Clone, Default)]
+struct Einsum<F: PrimeField + TensorType + PartialOrd> {
+    equation: String,
+    input_axes_to_dims: HashMap<char, usize>,
+    _marker: PhantomData<F>,
+}
+
+impl<F: PrimeField + TensorType + PartialOrd> Einsum<F> {
+    pub fn new(equation: &str, inputs: &[&Tensor<Value<F>>]) -> Result<Self, CircuitError> {
+        let mut eq = equation.split("->");
+        let inputs_eq = eq.next().ok_or(CircuitError::InvalidEinsum)?;
+        let inputs_eq = inputs_eq.split(',').collect::<Vec<_>>();
+
+        // Check that the number of inputs matches the number of inputs in the equation
+        if inputs.len() != inputs_eq.len() {
+            return Err(TensorError::DimMismatch("einsum".to_string()).into());
+        }
+
+        let mut input_axes_to_dims = HashMap::new();
+        for (i, input) in inputs.iter().enumerate() {
+            for j in 0..inputs_eq[i].len() {
+                let c = inputs_eq[i]
+                    .chars()
+                    .nth(j)
+                    .ok_or(CircuitError::InvalidEinsum)?;
+                if let std::collections::hash_map::Entry::Vacant(e) = input_axes_to_dims.entry(c) {
+                    e.insert(input.dims()[j]);
+                } else if input_axes_to_dims[&c] != input.dims()[j] {
+                    return Err(TensorError::DimMismatch("einsum".to_string()).into());
+                }
+            }
+        }
+
+        Ok(Self {
+            equation: equation.to_owned(),
+            input_axes_to_dims,
+            _marker: PhantomData,
+        })
+    }
+}
+
+impl Circuit<Fr> for MyCircuit<Fr> {
+    type Config = BaseConfig<Fr>;
+    type FloorPlanner = V1;
+    type Params = Einsum<Fr>;
+
+    fn without_witnesses(&self) -> Self {
+        self.clone()
+    }
+
+    fn configure_with_params(cs: &mut ConstraintSystem<Fr>, params: Self::Params) -> Self::Config {
+        let len = unsafe { LEN };
+
+        let a = VarTensor::new_advice(cs, K, 1, len);
+        let b = VarTensor::new_advice(cs, K, 1, len);
+        let output = VarTensor::new_advice(cs, K, 1, len);
+
+        let mut config = Self::Config::configure(cs, &[a, b], &output, CheckMode::UNSAFE);
+
+        let mut equations = HashMap::new();
+        equations.insert((0, params.equation), params.input_axes_to_dims);
+        let analysis = analyze_einsum_usage(&equations).unwrap();
+        let num_einsum_inner_cols = 1;
+        config
+            .configure_einsums(cs, &analysis, num_einsum_inner_cols, K)
+            .unwrap();
+
+        config
+    }
+
+    fn params(&self) -> Self::Params {
+        Einsum::<Fr>::new(
+            &self.einsum.equation,
+            &[
+                &self.inputs[0].get_inner().unwrap(),
+                &self.inputs[1].get_inner().unwrap(),
+            ],
+        )
+        .unwrap()
+    }
+
+    fn configure(_cs: &mut ConstraintSystem<Fr>) -> Self::Config {
+        unimplemented!("call configure_with_params instead")
+    }
+
+    fn synthesize(
+        &self,
+        mut config: Self::Config,
+        mut layouter: impl Layouter<Fr>,
+    ) -> Result<(), Error> {
+        let challenges = config
+            .einsums
+            .as_ref()
+            .ok_or(Error::Synthesis)?
+            .challenges()
+            .unwrap()
+            .iter()
+            .map(|c| layouter.get_challenge(*c))
+            .collect_vec();
+
+        layouter.assign_region(
+            || "",
+            |region| {
+                let mut region = region::RegionCtx::new_with_challenges(
+                    region,
+                    0,
+                    1,
+                    1024,
+                    2,
+                    challenges.clone(),
+                );
+                config
+                    .layout(
+                        &mut region,
+                        &self.inputs.iter().collect_vec(),
+                        Box::new(PolyOp::Einsum {
+                            equation: self.einsum.equation.clone(),
+                        }),
+                    )
+                    .unwrap();
+                Ok(())
+            },
+        )?;
+        Ok(())
+    }
+}
+
+fn runbatchmatmul() {
+    let batch_size = 5;
+    let len = 12;
+
+    let mut a = Tensor::from((0..batch_size * len * len).map(|_| Value::known(Fr::random(OsRng))));
+    a.reshape(&[batch_size, len, len]).unwrap();
+
+    // parameters
+    let mut b = Tensor::from((0..batch_size * len * len).map(|_| Value::known(Fr::random(OsRng))));
+    b.reshape(&[batch_size, len, len]).unwrap();
+
+    let einsum = Einsum::<Fr>::new("ijk,ikl->ijl", &[&a, &b]).unwrap();
+
+    let circuit = MyCircuit {
+        inputs: [ValTensor::from(a), ValTensor::from(b)],
+        einsum,
+    };
+
+    let mock_prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
+    mock_prover.assert_satisfied();
+}
+
+pub fn main() {
+    runbatchmatmul()
+}

examples/conv2d_mnist/main.rs

@@ -208,16 +208,14 @@ where
                         padding: vec![(PADDING, PADDING); 2],
                         stride: vec![STRIDE; 2],
                         group: 1,
+                        data_format: DataFormat::NCHW,
+                        kernel_format: KernelFormat::OIHW,
                     };
                     let x = config
                         .layer_config
                         .layout(
                             &mut region,
-                            &[
-                                self.input.clone(),
-                                self.l0_params[0].clone(),
-                                self.l0_params[1].clone(),
-                            ],
+                            &[&self.input, &self.l0_params[0], &self.l0_params[1]],
                             Box::new(op),
                         )
                         .unwrap();
@@ -226,7 +224,7 @@ where
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x.unwrap()],
+                            &[&x.unwrap()],
                             Box::new(PolyOp::LeakyReLU {
                                 slope: 0.0.into(),
                                 scale: 1,
@@ -238,7 +236,7 @@ where
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x.unwrap()],
+                            &[&x.unwrap()],
                             Box::new(LookupOp::Div { denom: 32.0.into() }),
                         )
                         .unwrap()
@@ -250,7 +248,7 @@ where
                         .layer_config
                         .layout(
                             &mut region,
-                            &[self.l2_params[0].clone(), x],
+                            &[&self.l2_params[0], &x],
                             Box::new(PolyOp::Einsum {
                                 equation: "ij,j->ik".to_string(),
                             }),
@@ -262,7 +260,7 @@ where
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x, self.l2_params[1].clone()],
+                            &[&x, &self.l2_params[1]],
                             Box::new(PolyOp::Add),
                         )
                         .unwrap()

examples/mlp_4d_einsum.rs

@@ -117,10 +117,7 @@ impl<const LEN: usize, const LOOKUP_MIN: IntegerRep, const LOOKUP_MAX: IntegerRe
                         .layer_config
                         .layout(
                             &mut region,
-                            &[
-                                self.l0_params[0].clone().try_into().unwrap(),
-                                self.input.clone(),
-                            ],
+                            &[&self.l0_params[0].clone().try_into().unwrap(), &self.input],
                             Box::new(PolyOp::Einsum {
                                 equation: "ab,bc->ac".to_string(),
                             }),
@@ -135,7 +132,7 @@ impl<const LEN: usize, const LOOKUP_MIN: IntegerRep, const LOOKUP_MAX: IntegerRe
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x, self.l0_params[1].clone().try_into().unwrap()],
+                            &[&x, &self.l0_params[1].clone().try_into().unwrap()],
                             Box::new(PolyOp::Add),
                         )
                         .unwrap()
@@ -147,7 +144,7 @@ impl<const LEN: usize, const LOOKUP_MIN: IntegerRep, const LOOKUP_MAX: IntegerRe
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x],
+                            &[&x],
                             Box::new(PolyOp::LeakyReLU {
                                 scale: 1,
                                 slope: 0.0.into(),
@@ -163,7 +160,7 @@ impl<const LEN: usize, const LOOKUP_MIN: IntegerRep, const LOOKUP_MAX: IntegerRe
                         .layer_config
                         .layout(
                             &mut region,
-                            &[self.l2_params[0].clone().try_into().unwrap(), x],
+                            &[&self.l2_params[0].clone().try_into().unwrap(), &x],
                             Box::new(PolyOp::Einsum {
                                 equation: "ab,bc->ac".to_string(),
                             }),
@@ -178,7 +175,7 @@ impl<const LEN: usize, const LOOKUP_MIN: IntegerRep, const LOOKUP_MAX: IntegerRe
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x, self.l2_params[1].clone().try_into().unwrap()],
+                            &[&x, &self.l2_params[1].clone().try_into().unwrap()],
                             Box::new(PolyOp::Add),
                         )
                         .unwrap()
@@ -190,7 +187,7 @@ impl<const LEN: usize, const LOOKUP_MIN: IntegerRep, const LOOKUP_MAX: IntegerRe
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x],
+                            &[&x],
                             Box::new(PolyOp::LeakyReLU {
                                 scale: 1,
                                 slope: 0.0.into(),
@@ -203,7 +200,7 @@ impl<const LEN: usize, const LOOKUP_MIN: IntegerRep, const LOOKUP_MAX: IntegerRe
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x.unwrap()],
+                            &[&x.unwrap()],
                             Box::new(LookupOp::Div {
                                 denom: ezkl::circuit::utils::F32::from(128.),
                             }),

examples/notebooks/cat_and_dog_data.sh

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

examples/notebooks/data_attest.ipynb

@@ -1,601 +0,0 @@
-{
-    "cells": [
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "# data-attest-ezkl\n",
-                "\n",
-                "Here's an example leveraging EZKL whereby the inputs to the model are read and attested to from an on-chain source.\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"
-            ]
-        },
-        {
-            "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`: \"private\"\n",
-                "- `output_visibility`: public\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 = \"private\"\n",
-                "run_args.output_visibility = \"public\"\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)"
-            ]
-        },
-        {
-            "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",
-                "\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": [
-                "import json\n",
-                "\n",
-                "addr_path_verifier = \"addr_verifier.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_evm(\n",
-                "    addr_path_verifier,\n",
-                "    sol_code_path,\n",
-                "    'http://127.0.0.1:3030'\n",
-                ")\n",
-                "\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "With the vanilla verifier deployed, we can now create the data attestation contract, which will read in the instances from the calldata to the verifier, attest to them, call the verifier and then return the result. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "input_path = 'input.json'\n",
-                "\n",
-                "res = await ezkl.create_evm_data_attestation(\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "    )"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we can deploy the data attest verifier contract. For security reasons, this binding will only deploy to a local anvil instance, using accounts generated by anvil. \n",
-                "So should only be used for testing purposes."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "addr_path_da = \"addr_da.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_da_evm(\n",
-                "        addr_path_da,\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        RPC_URL,\n",
-                "    )\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "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.12.5"
-        },
-        "orig_nbformat": 4
-    },
-    "nbformat": 4,
-    "nbformat_minor": 2
-}

examples/notebooks/data_attest_hashed.ipynb

@@ -1,657 +0,0 @@
-{
-    "cells": [
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "# data-attest-ezkl hashed\n",
-                "\n",
-                "Here's an example leveraging EZKL whereby the hashes of the outputs to the model are read and attested to from an on-chain source.\n",
-                "\n",
-                "In this setup:\n",
-                "- the hashes of outputs are publicly known to the prover and verifier\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\n",
-                "\n",
-                "\n"
-            ]
-        },
-        {
-            "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`: \"private\"\n",
-                "- `param_visibility`: \"private\"\n",
-                "- `output_visibility`: hashed\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 = \"private\"\n",
-                "run_args.param_visibility = \"private\"\n",
-                "run_args.output_visibility = \"hashed\"\n",
-                "run_args.variables = [(\"batch_size\", 1)]\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"
-            ]
-        },
-        {
-            "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)\n",
-                "\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "print(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]))"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now post the hashes of the outputs to the chain. This is the data that will be read from and attested to."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "from web3 import Web3, HTTPProvider\n",
-                "from solcx import compile_standard\n",
-                "from decimal import Decimal\n",
-                "import json\n",
-                "import os\n",
-                "import torch\n",
-                "\n",
-                "\n",
-                "# setup web3 instance\n",
-                "w3 = Web3(HTTPProvider(RPC_URL))\n",
-                "\n",
-                "def test_on_chain_data(res):\n",
-                "    # Step 0: Convert the tensor to a flat list\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",
-                "    # We are using a test contract here but in production you would\n",
-                "    # use whatever contract you are fetching data from.\n",
-                "    contract_source_code = '''\n",
-                "    // SPDX-License-Identifier: UNLICENSED\n",
-                "    pragma solidity ^0.8.17;\n",
-                "\n",
-                "    contract TestReads {\n",
-                "\n",
-                "        uint[] public arr;\n",
-                "        constructor(uint256[] memory _numbers) {\n",
-                "            for(uint256 i = 0; i < _numbers.length; i++) {\n",
-                "                arr.push(_numbers[i]);\n",
-                "            }\n",
-                "        }\n",
-                "    }\n",
-                "    '''\n",
-                "\n",
-                "    compiled_sol = compile_standard({\n",
-                "        \"language\": \"Solidity\",\n",
-                "        \"sources\": {\"testreads.sol\": {\"content\": contract_source_code}},\n",
-                "        \"settings\": {\"outputSelection\": {\"*\": {\"*\": [\"metadata\", \"evm.bytecode\", \"abi\"]}}}\n",
-                "    })\n",
-                "\n",
-                "    # Get bytecode\n",
-                "    bytecode = compiled_sol['contracts']['testreads.sol']['TestReads']['evm']['bytecode']['object']\n",
-                "\n",
-                "    # Get ABI\n",
-                "    # In production if you are reading from really large contracts you can just use\n",
-                "    # a stripped down version of the ABI of the contract you are calling, containing only the view functions you will fetch data from.\n",
-                "    abi = json.loads(compiled_sol['contracts']['testreads.sol']['TestReads']['metadata'])['output']['abi']\n",
-                "\n",
-                "    # Step 3: Deploy the contract\n",
-                "    TestReads = w3.eth.contract(abi=abi, bytecode=bytecode)\n",
-                "    tx_hash = TestReads.constructor(data).transact()\n",
-                "    tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)\n",
-                "    # If you are deploying to production you can skip the 3 lines of code above and just instantiate the contract like this,\n",
-                "    # passing the address and abi of the contract you are fetching data from.\n",
-                "    contract = w3.eth.contract(address=tx_receipt['contractAddress'], abi=abi)\n",
-                "\n",
-                "    # Step 4: Interact with the contract\n",
-                "    calldata = []\n",
-                "    for i, _ in enumerate(data):\n",
-                "        call = contract.functions.arr(i).build_transaction()\n",
-                "        calldata.append((call['data'][2:], 0))\n",
-                "\n",
-                "    # Prepare the calls_to_account object\n",
-                "    # If you were calling view functions across multiple contracts,\n",
-                "    # you would have multiple entries in the calls_to_account array,\n",
-                "    # one for each contract.\n",
-                "    calls_to_account = [{\n",
-                "        'call_data': calldata,\n",
-                "        'address': contract.address[2:], # remove the '0x' prefix\n",
-                "    }]\n",
-                "\n",
-                "    print(f'calls_to_account: {calls_to_account}')\n",
-                "\n",
-                "    return calls_to_account\n",
-                "\n",
-                "# Now let's start the Anvil process. You don't need to do this if you are deploying to a non-local chain.\n",
-                "start_anvil()\n",
-                "\n",
-                "# Now let's call our function, passing in the same input tensor we used to export the model 2 cells above.\n",
-                "calls_to_account = test_on_chain_data(res)\n",
-                "\n",
-                "data = dict(input_data = [data_array], output_data =  {'rpc': RPC_URL, 'calls': calls_to_account })\n",
-                "\n",
-                "# Serialize on-chain data into file:\n",
-                "json.dump(data, open(\"input.json\", 'w'))\n",
-                "\n"
-            ]
-        },
-        {
-            "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",
-                "\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": [
-                "import json\n",
-                "\n",
-                "addr_path_verifier = \"addr_verifier.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_evm(\n",
-                "    addr_path_verifier,\n",
-                "    sol_code_path,\n",
-                "    'http://127.0.0.1:3030'\n",
-                ")\n",
-                "\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "With the vanilla verifier deployed, we can now create the data attestation contract, which will read in the instances from the calldata to the verifier, attest to them, call the verifier and then return the result. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "input_path = 'input.json'\n",
-                "\n",
-                "res = await ezkl.create_evm_data_attestation(\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "    )"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we can deploy the data attest verifier contract. For security reasons, this binding will only deploy to a local anvil instance, using accounts generated by anvil. \n",
-                "So should only be used for testing purposes."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "addr_path_da = \"addr_da.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_da_evm(\n",
-                "        addr_path_da,\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        RPC_URL,\n",
-                "    )\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "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.12.7"
-        },
-        "orig_nbformat": 4
-    },
-    "nbformat": 4,
-    "nbformat_minor": 2
-}

examples/notebooks/data_attest_kzg_vis.ipynb

@@ -1,604 +0,0 @@
-{
-    "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
-}

examples/notebooks/decision_tree.ipynb

@@ -150,7 +150,7 @@
                 "res = ezkl.gen_settings(model_path, settings_path)\n",
                 "assert res == True\n",
                 "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = 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 = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -204,7 +204,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -253,8 +253,6 @@
                 "        compiled_model_path,\n",
                 "        pk_path,\n",
                 "        proof_path,\n",
-                "        \n",
-                "        \"single\",\n",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -303,4 +301,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 5
-}
+}

examples/notebooks/ezkl_demo.ipynb

@@ -437,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 = await ezkl.calibrate_settings(target = \"resources\", max_logrows = 12, scales = [2])"
+        "res = ezkl.calibrate_settings(target = \"resources\", max_logrows = 12, scales = [2])"
       ]
     },
     {
@@ -526,7 +526,7 @@
         "# now generate the witness file\n",
         "witness_path = os.path.join('witness.json')\n",
         "\n",
-        "res = await ezkl.gen_witness()\n",
+        "res = ezkl.gen_witness()\n",
         "assert os.path.isfile(witness_path)"
       ]
     },
@@ -546,7 +546,7 @@
         "\n",
         "proof_path = os.path.join('proof.json')\n",
         "\n",
-        "proof = ezkl.prove(proof_type=\"single\", proof_path=proof_path)\n",
+        "proof = ezkl.prove(proof_path=proof_path)\n",
         "\n",
         "print(proof)\n",
         "assert os.path.isfile(proof_path)"

examples/notebooks/gcn.ipynb

@@ -105,7 +105,7 @@
         "\n",
         "class GCNConv(Module):\n",
         "    def __init__(self, in_channels, out_channels):\n",
-        "        super(GCNConv, self).__init__()  # \"Add\" aggregation.\n",
+        "        super(GCNConv, self).__init__() \n",
         "        self.lin = torch.nn.Linear(in_channels, out_channels)\n",
         "\n",
         "        self.reset_parameters()\n",
@@ -467,7 +467,7 @@
       "outputs": [],
       "source": [
         "\n",
-        "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+        "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
         "assert res == True"
       ]
     },
@@ -508,7 +508,7 @@
       "source": [
         "# now generate the witness file\n",
         "\n",
-        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
         "assert os.path.isfile(witness_path)"
       ]
     },
@@ -563,7 +563,6 @@
         "        compiled_model_path,\n",
         "        pk_path,\n",
         "        proof_path,\n",
-        "        \"single\",\n",
         "    )\n",
         "\n",
         "print(res)\n",
@@ -625,4 +624,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 5
-}
+}

examples/notebooks/generalized_inverse.ipynb

@@ -77,6 +77,7 @@
       "outputs": [],
       "source": [
         "gip_run_args = ezkl.PyRunArgs()\n",
+        "gip_run_args.ignore_range_check_inputs_outputs = True\n",
         "gip_run_args.input_visibility = \"polycommit\"  # matrix and generalized inverse commitments\n",
         "gip_run_args.output_visibility = \"fixed\"   # no parameters used\n",
         "gip_run_args.param_visibility = \"fixed\" # should be Tensor(True)"
@@ -195,7 +196,7 @@
         "json.dump(data, open(cal_path, 'w'))\n",
         "\n",
         "\n",
-        "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+        "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
         "assert res == True\n"
       ]
     },
@@ -236,7 +237,7 @@
       "source": [
         "# now generate the witness file\n",
         "\n",
-        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
         "assert os.path.isfile(witness_path)"
       ]
     },
@@ -285,8 +286,6 @@
         "        compiled_model_path,\n",
         "        pk_path,\n",
         "        proof_path,\n",
-        "        \n",
-        "        \"single\",\n",
         "    )\n",
         "\n",
         "print(res)\n",
@@ -335,9 +334,9 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.9.15"
+      "version": "3.9.13"
     }
   },
   "nbformat": 4,
   "nbformat_minor": 5
-}
+}

examples/notebooks/gradient_boosted_trees.ipynb

@@ -179,7 +179,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                 "assert res == True\n"
             ]
         },
@@ -214,7 +214,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -248,7 +248,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 10,
+            "execution_count": null,
             "id": "c384cbc8",
             "metadata": {},
             "outputs": [],
@@ -263,8 +263,6 @@
                 "        compiled_model_path,\n",
                 "        pk_path,\n",
                 "        proof_path,\n",
-                "        \n",
-                "        \"single\",\n",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -313,4 +311,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 5
-}
+}

examples/notebooks/hashed_vis.ipynb

@@ -241,7 +241,7 @@
                 "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\")"
+                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -291,7 +291,7 @@
                 "\n",
                 "witness_path = \"witness.json\"\n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
             ]
         },
         {
@@ -368,7 +368,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -453,8 +453,8 @@
                 "\n",
                 "res = await ezkl.deploy_evm(\n",
                 "    address_path,\n",
+                "    'http://127.0.0.1:3030',\n",
                 "    sol_code_path,\n",
-                "    'http://127.0.0.1:3030'\n",
                 ")\n",
                 "\n",
                 "assert res == True\n",
@@ -474,8 +474,8 @@
                 "\n",
                 "res = await ezkl.verify_evm(\n",
                 "    addr,\n",
+                "    \"http://127.0.0.1:3030\",\n",
                 "    proof_path,\n",
-                "    \"http://127.0.0.1:3030\"\n",
                 ")\n",
                 "assert res == True"
             ]

examples/notebooks/keras_simple_demo.ipynb

@@ -152,7 +152,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                 "assert res == True\n"
             ]
         },
@@ -188,7 +188,7 @@
                 "# now generate the witness file \n",
                 "witness_path = \"witness.json\"\n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -236,7 +236,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",

examples/notebooks/kmeans.ipynb

@@ -155,7 +155,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                 "assert res == True\n"
             ]
         },
@@ -190,7 +190,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -240,7 +240,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",

examples/notebooks/kzg_vis.ipynb

@@ -233,7 +233,7 @@
                 "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\")"
+                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -315,7 +315,7 @@
                 "\n",
                 "witness_path = \"witness.json\"\n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n"
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n"
             ]
         },
         {
@@ -358,7 +358,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -462,8 +462,8 @@
                 "\n",
                 "res = await ezkl.deploy_evm(\n",
                 "    address_path,\n",
+                "    'http://127.0.0.1:3030',\n",
                 "    sol_code_path,\n",
-                "    'http://127.0.0.1:3030'\n",
                 ")\n",
                 "\n",
                 "assert res == True\n",
@@ -483,8 +483,8 @@
                 "\n",
                 "res = await ezkl.verify_evm(\n",
                 "    addr,\n",
+                "    \"http://127.0.0.1:3030\",\n",
                 "    proof_path,\n",
-                "    \"http://127.0.0.1:3030\"\n",
                 ")\n",
                 "assert res == True"
             ]

examples/notebooks/lightgbm.ipynb

@@ -193,7 +193,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                 "assert res == True\n"
             ]
         },
@@ -228,7 +228,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -278,7 +278,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",

examples/notebooks/linear_regression.ipynb

@@ -111,7 +111,12 @@
                 "            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"
+                "json.dump(data, open(\"input.json\", 'w'))\n",
+                "\n",
+                "\n",
+                "# note that you can also call the following function to generate random data for the model\n",
+                "# it is functionally equivalent to the code above\n",
+                "ezkl.gen_random_data()\n"
             ]
         },
         {
@@ -142,7 +147,7 @@
                 "# 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",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                 "assert res == True\n"
             ]
         },
@@ -177,7 +182,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -227,7 +232,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",

examples/notebooks/little_transformer.ipynb

@@ -347,7 +347,7 @@
                 "# 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",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                 "assert res == True\n"
             ]
         },
@@ -383,7 +383,7 @@
                 "# now generate the witness file \n",
                 "witness_path = \"gan_witness.json\"\n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -442,7 +442,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",

examples/notebooks/logistic_regression.ipynb

@@ -142,7 +142,7 @@
                 "# 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",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                 "assert res == True\n"
             ]
         },
@@ -177,7 +177,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -227,7 +227,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -276,4 +276,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 5
-}
+}

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 = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                 "assert res == True\n"
             ]
         },
@@ -193,7 +193,7 @@
                 "# now generate the witness file \n",
                 "witness_path = \"lstmwitness.json\"\n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -252,7 +252,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",

examples/notebooks/mean_postgres.ipynb

@@ -1,456 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 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 [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://indexsupply.com/shovel/docs/#getting-started. \n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "import os\n",
-        "import getpass\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/1.0/linux/amd64/shovel\")\n",
-        "os.system(\"chmod +x shovel\")\n",
-        "\n",
-        "\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",
-        "\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"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "2wIAHwqH2_mo"
-      },
-      "source": [
-        "**Import Dependencies**"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "9Byiv2Nc2MsK"
-      },
-      "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",
-        "import ezkl\n",
-        "import torch\n",
-        "import datetime\n",
-        "import pandas as pd\n",
-        "import requests\n",
-        "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)\n",
-        "\n",
-        "print(\"ezkl version: \", ezkl.__version__)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "osjj-0Ta3E8O"
-      },
-      "source": [
-        "**Create Computational Graph**"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "x1vl9ZXF3EEW",
-        "outputId": "bda21d02-fe5f-4fb2-8106-f51a8e2e67aa"
-      },
-      "outputs": [],
-      "source": [
-        "from torch import nn\n",
-        "import torch\n",
-        "\n",
-        "\n",
-        "class Model(nn.Module):\n",
-        "    def __init__(self):\n",
-        "        super(Model, self).__init__()\n",
-        "\n",
-        "    # x is a time series \n",
-        "    def forward(self, x):\n",
-        "        return [torch.mean(x)]\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "circuit = Model()\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "x = 0.1*torch.rand(1,*[1,5], requires_grad=True)\n",
-        "\n",
-        "# # print(torch.__version__)\n",
-        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
-        "\n",
-        "print(device)\n",
-        "\n",
-        "circuit.to(device)\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",
-        "                      \"lol.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=11,          # 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",
-        "# export(circuit, input_shape=[1, 20])\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "E3qCeX-X5xqd"
-      },
-      "source": [
-        "**Set Data Source and Get Data**"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "6RAMplxk5xPk",
-        "outputId": "bd2158fe-0c00-44fd-e632-6a3f70cdb7c9"
-      },
-      "outputs": [],
-      "source": [
-        "import getpass\n",
-        "# make an input.json file from the df above\n",
-        "input_filename = os.path.join('input.json')\n",
-        "\n",
-        "pg_input_file = dict(input_data = {\n",
-        "  \"host\": \"localhost\",\n",
-        "  # make sure you replace this with your own username\n",
-        "  \"user\": getpass.getuser(),\n",
-        "  \"dbname\": \"shovel\",\n",
-        "  \"password\": \"\",\n",
-        "  \"query\": \"SELECT v FROM usdc ORDER BY block_num DESC LIMIT 5\",\n",
-        "  \"port\": \"5432\",\n",
-        "})\n",
-        "\n",
-        "json_formatted_str = json.dumps(pg_input_file, indent=2)\n",
-        "print(json_formatted_str)\n",
-        "\n",
-        "\n",
-        "    # Serialize data into file:\n",
-        "json.dump(pg_input_file, open(input_filename, 'w' ))\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# this corresponds to 4 batches\n",
-        "calibration_filename = os.path.join('calibration.json')\n",
-        "\n",
-        "pg_cal_file = dict(input_data = {\n",
-        "  \"host\": \"localhost\",\n",
-        "  # make sure you replace this with your own username\n",
-        "  \"user\": getpass.getuser(),\n",
-        "  \"dbname\": \"shovel\",\n",
-        "  \"password\": \"\",\n",
-        "  \"query\": \"SELECT v FROM usdc ORDER BY block_num DESC LIMIT 20\",\n",
-        "  \"port\": \"5432\",\n",
-        "})\n",
-        "\n",
-        "    # Serialize data into file:\n",
-        "json.dump( pg_cal_file, open(calibration_filename, 'w' ))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "eLJ7oirQ_HQR"
-      },
-      "source": [
-        "**EZKL Workflow**"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "rNw0C9QL6W88"
-      },
-      "outputs": [],
-      "source": [
-        "import subprocess\n",
-        "import os\n",
-        "\n",
-        "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"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "\n",
-        "ezkl.compile_circuit(onnx_filename, compiled_filename, settings_filename)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "4MmE9SX66_Il",
-        "outputId": "16403639-66a4-4280-ac7f-6966b75de5a3"
-      },
-      "outputs": [],
-      "source": [
-        "# generate settings\n",
-        "\n",
-        "\n",
-        "# show the settings.json\n",
-        "with open(\"settings.json\") as f:\n",
-        "  data = json.load(f)\n",
-        "  json_formatted_str = json.dumps(data, indent=2)\n",
-        "\n",
-        "  print(json_formatted_str)\n",
-        "\n",
-        "assert os.path.exists(\"settings.json\")\n",
-        "assert os.path.exists(\"input.json\")\n",
-        "assert os.path.exists(\"lol.onnx\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "fULvvnK7_CMb"
-      },
-      "outputs": [],
-      "source": [
-        "pk_path = os.path.join('test.pk')\n",
-        "vk_path = os.path.join('test.vk')\n",
-        "\n",
-        "\n",
-        "# setup the proof\n",
-        "res = ezkl.setup(\n",
-        "        compiled_filename,\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_filename)\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "witness_path = \"witness.json\"\n",
-        "\n",
-        "# generate the witness\n",
-        "res = await ezkl.gen_witness(\n",
-        "        input_filename,\n",
-        "        compiled_filename,\n",
-        "        witness_path\n",
-        "    )\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "Oog3j6Kd-Wed",
-        "outputId": "5839d0c1-5b43-476e-c2f8-6707de562260"
-      },
-      "outputs": [],
-      "source": [
-        "# prove the zk circuit\n",
-        "# GENERATE A PROOF\n",
-        "proof_path = os.path.join('test.pf')\n",
-        "\n",
-        "\n",
-        "proof = ezkl.prove(\n",
-        "        witness_path,\n",
-        "        compiled_filename,\n",
-        "        pk_path,\n",
-        "        proof_path,\n",
-        "        \"single\"\n",
-        "    )\n",
-        "\n",
-        "\n",
-        "print(\"proved\")\n",
-        "\n",
-        "assert os.path.isfile(proof_path)\n",
-        "\n"
-      ]
-    }
-  ],
-  "metadata": {
-    "colab": {
-      "provenance": []
-    },
-    "kernelspec": {
-      "display_name": "Python 3",
-      "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": 0
-}

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 = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[2,7])\n",
+        "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[2,7])\n",
         "assert res == True"
       ]
     },
@@ -362,7 +362,7 @@
         "# now generate the witness file\n",
         "witness_path = \"witness.json\"\n",
         "\n",
-        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
         "assert os.path.isfile(witness_path)"
       ]
     },
@@ -422,7 +422,7 @@
         "        compiled_model_path,\n",
         "        pk_path,\n",
         "        proof_path,\n",
-        "        \"single\",\n",
+        "        ",
         "    )\n",
         "\n",
         "print(res)\n",
@@ -504,8 +504,8 @@
         "\n",
         "res = await ezkl.deploy_evm(\n",
         "    address_path,\n",
+        "    'http://127.0.0.1:3030',\n",
         "    sol_code_path,\n",
-        "    'http://127.0.0.1:3030'\n",
         ")\n",
         "\n",
         "assert res == True\n",
@@ -527,8 +527,8 @@
         "\n",
         "res = await ezkl.verify_evm(\n",
         "    addr,\n",
-        "    proof_path,\n",
-        "    \"http://127.0.0.1:3030\"\n",
+        "    \"http://127.0.0.1:3030\",\n",
+        "    proof_path\n",
         ")\n",
         "assert res == True"
       ]

examples/notebooks/mnist_gan.ipynb

@@ -289,7 +289,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[0,6])"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales=[0,6])"
             ]
         },
         {
@@ -321,7 +321,7 @@
                 "# now generate the witness file \n",
                 "witness_path = \"gan_witness.json\"\n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -378,7 +378,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -425,4 +425,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 2
-}
+}

examples/notebooks/mnist_gan_proof_splitting.ipynb

@@ -301,7 +301,7 @@
                 "run_args.param_scale = 0\n",
                 "run_args.logrows = 18\n",
                 "\n",
-                "ezkl.get_srs(logrows=run_args.logrows, commitment=ezkl.PyCommitments.KZG)\n"
+                "ezkl.get_srs(logrows=run_args.logrows, )\n"
             ]
         },
         {
@@ -341,7 +341,7 @@
                 "\n",
                 "    # generate settings for the current model\n",
                 "    res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
-                "    res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", scales=[run_args.input_scale], max_logrows=run_args.logrows)\n",
+                "    res = 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",
@@ -361,7 +361,7 @@
                 "    assert res == True\n",
                 "    assert os.path.isfile(vk_path)\n",
                 "    assert os.path.isfile(pk_path)\n",
-                "    res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
+                "    res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
                 "    run_args.input_scale = settings[\"model_output_scales\"][0]\n",
                 "\n",
                 "for i in range(3):\n",
@@ -399,7 +399,6 @@
                 "            compiled_model_path,\n",
                 "            pk_path,\n",
                 "            proof_path,\n",
-                "            \"for-aggr\",\n",
                 "        )\n",
                 "\n",
                 "    print(res)\n",
@@ -438,33 +437,11 @@
                 "    print(\"----- proving split \"+str(i))\n",
                 "    prove_model(i)"
             ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "You can also mock aggregate the split proofs into a single proof. This is useful if you want to verify the proof on chain at a lower cost. Here we mock aggregate the proofs to save time. You can use other notebooks to see how to aggregate in full ! "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# now mock aggregate the proofs\n",
-                "proofs = []\n",
-                "for i in range(3):\n",
-                "    proof_path = os.path.join('proof_split_'+str(i)+'.json')\n",
-                "    proofs.append(proof_path)\n",
-                "\n",
-                "ezkl.mock_aggregate(proofs, logrows=23, split_proofs = True)"
-            ]
         }
     ],
     "metadata": {
         "kernelspec": {
-            "display_name": "ezkl",
+            "display_name": ".env",
             "language": "python",
             "name": "python3"
         },
@@ -478,7 +455,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.12.5"
+            "version": "3.12.7"
         },
         "orig_nbformat": 4
     },

examples/notebooks/mnist_vae.ipynb

@@ -215,7 +215,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -247,7 +247,7 @@
                 "# now generate the witness file\n",
                 "witness_path = \"ae_witness.json\"\n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -303,7 +303,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -451,7 +451,7 @@
                 "res = ezkl.gen_settings(model_path, settings_path)\n",
                 "assert res == True\n",
                 "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                 "assert res == True\n",
                 "print(\"verified\")"
             ]
@@ -485,7 +485,7 @@
                 "# now generate the witness file \n",
                 "witness_path = \"vae_witness.json\"\n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -543,7 +543,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -590,4 +590,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 2
-}
+}

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 = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", max_logrows = 20, scales = [3])\n",
+        "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", max_logrows = 20, scales = [3])\n",
         "assert res == True"
       ]
     },
@@ -881,7 +881,7 @@
       },
       "outputs": [],
       "source": [
-        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
         "assert os.path.isfile(witness_path)"
       ]
     },
@@ -939,7 +939,7 @@
         "        pk_path,\n",
         "        proof_path,\n",
         "        \n",
-        "        \"single\",\n",
+        "        ",
         "    )\n",
         "\n",
         "print(res)\n",

examples/notebooks/proof_splitting.ipynb

@@ -234,7 +234,7 @@
                 "run_args.input_scale = 2\n",
                 "run_args.logrows = 15\n",
                 "\n",
-                "ezkl.get_srs(logrows=run_args.logrows, commitment=ezkl.PyCommitments.KZG)"
+                "ezkl.get_srs(logrows=run_args.logrows, )"
             ]
         },
         {
@@ -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 = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\", scales=[run_args.input_scale], max_logrows=run_args.logrows)\n",
+                "    res = 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,7 +303,7 @@
                 "    assert os.path.isfile(vk_path)\n",
                 "    assert os.path.isfile(pk_path)\n",
                 "\n",
-                "    res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
+                "    res = ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
                 "    run_args.input_scale = settings[\"model_output_scales\"][0]\n",
                 "\n",
                 "for i in range(2):\n",
@@ -330,7 +330,6 @@
                 "            compiled_model_path,\n",
                 "            pk_path,\n",
                 "            proof_path,\n",
-                "            \"for-aggr\",\n",
                 "        )\n",
                 "\n",
                 "    print(res)\n",
@@ -426,28 +425,6 @@
                 "for i in range(2):\n",
                 "    prove_model(i)"
             ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "You can also mock aggregate the split proofs into a single proof. This is useful if you want to verify the proof on chain at a lower cost. Here we mock aggregate the proofs to save time. You can use other notebooks to see how to aggregate in full ! "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# now mock aggregate the proofs\n",
-                "proofs = []\n",
-                "for i in range(2):\n",
-                "    proof_path = os.path.join('proof_split_'+str(i)+'.json')\n",
-                "    proofs.append(proof_path)\n",
-                "\n",
-                "ezkl.mock_aggregate(proofs, logrows=22, split_proofs = True)"
-            ]
         }
     ],
     "metadata": {

examples/notebooks/random_forest.ipynb

@@ -152,9 +152,11 @@
             "metadata": {},
             "outputs": [],
             "source": [
-                "!RUST_LOG=trace\n",
-                "# TODO: Dictionary outputs\n",
-                "res = ezkl.gen_settings(model_path, settings_path)\n",
+                "run_args = ezkl.PyRunArgs()\n",
+                "# logrows\n",
+                "run_args.logrows = 20\n",
+                "\n",
+                "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
                 "assert res == True\n"
             ]
         },
@@ -174,7 +176,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -208,7 +210,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -258,7 +260,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -302,9 +304,9 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.12.2"
+            "version": "3.9.13"
         }
     },
     "nbformat": 4,
     "nbformat_minor": 5
-}
+}

examples/notebooks/reusable_verifier.ipynb

@@ -1,339 +1,336 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Reusable Verifiers \n",
-    "\n",
-    "This notebook demonstrates how to create and reuse the same set of separated verifiers for different models. Specifically, we will use the same verifier for the following four models:\n",
-    "\n",
-    "- `1l_mlp sigmoid`\n",
-    "- `1l_mlp relu`\n",
-    "- `1l_conv sigmoid`\n",
-    "- `1l_conv relu`\n",
-    "\n",
-    "When deploying EZKL verifiers on the blockchain, each associated model typically requires its own unique verifier, leading to increased on-chain state usage. \n",
-    "However, with the reusable verifier, we can deploy a single verifier that can be used to verify proofs for any valid H2 circuit. This notebook shows how to do so. \n",
-    "\n",
-    "By reusing the same verifier across multiple models, we significantly reduce the amount of state bloat on the blockchain. Instead of deploying a unique verifier for each model, we deploy a unique and much smaller verifying key artifact (VKA) contract for each model while sharing a common separated verifier. The VKA contains the VK for the model as well circuit specific metadata that was otherwise hardcoded into the stack of the original non-reusable verifier."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "import torch.nn as nn\n",
-    "import torch.onnx\n",
-    "\n",
-    "# Define the models\n",
-    "class MLP_Sigmoid(nn.Module):\n",
-    "    def __init__(self):\n",
-    "        super(MLP_Sigmoid, self).__init__()\n",
-    "        self.fc = nn.Linear(3, 3)\n",
-    "        self.sigmoid = nn.Sigmoid()\n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        x = self.fc(x)\n",
-    "        x = self.sigmoid(x)\n",
-    "        return x\n",
-    "\n",
-    "class MLP_Relu(nn.Module):\n",
-    "    def __init__(self):\n",
-    "        super(MLP_Relu, self).__init__()\n",
-    "        self.fc = nn.Linear(3, 3)\n",
-    "        self.relu = nn.ReLU()\n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        x = self.fc(x)\n",
-    "        x = self.relu(x)\n",
-    "        return x\n",
-    "\n",
-    "class Conv_Sigmoid(nn.Module):\n",
-    "    def __init__(self):\n",
-    "        super(Conv_Sigmoid, self).__init__()\n",
-    "        self.conv = nn.Conv1d(1, 1, kernel_size=3, stride=1)\n",
-    "        self.sigmoid = nn.Sigmoid()\n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        x = self.conv(x)\n",
-    "        x = self.sigmoid(x)\n",
-    "        return x\n",
-    "\n",
-    "class Conv_Relu(nn.Module):\n",
-    "    def __init__(self):\n",
-    "        super(Conv_Relu, self).__init__()\n",
-    "        self.conv = nn.Conv1d(1, 1, kernel_size=3, stride=1)\n",
-    "        self.relu = nn.ReLU()\n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        x = self.conv(x)\n",
-    "        x = self.relu(x)\n",
-    "        return x\n",
-    "\n",
-    "# Instantiate the models\n",
-    "mlp_sigmoid = MLP_Sigmoid()\n",
-    "mlp_relu = MLP_Relu()\n",
-    "conv_sigmoid = Conv_Sigmoid()\n",
-    "conv_relu = Conv_Relu()\n",
-    "\n",
-    "# Dummy input tensor for mlp\n",
-    "dummy_input_mlp = torch.tensor([[-1.5737053155899048, -1.708398461341858, 0.19544155895709991]])\n",
-    "input_mlp_path = 'mlp_input.json'\n",
-    "\n",
-    "# Dummy input tensor for conv\n",
-    "dummy_input_conv = torch.tensor([[[1.4124163389205933, 0.6938204169273376, 1.0664031505584717]]])\n",
-    "input_conv_path = 'conv_input.json'"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "names = ['mlp_sigmoid', 'mlp_relu', 'conv_sigmoid', 'conv_relu']\n",
-    "models = [mlp_sigmoid, mlp_relu, conv_sigmoid, conv_relu]\n",
-    "inputs = [dummy_input_mlp, dummy_input_mlp, dummy_input_conv, dummy_input_conv]\n",
-    "input_paths = [input_mlp_path, input_mlp_path, input_conv_path, input_conv_path]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import json\n",
-    "import torch\n",
-    "import ezkl\n",
-    "\n",
-    "for name, model, x, input_path in zip(names, models, inputs, input_paths):\n",
-    "    # Create a new directory for the model if it doesn't exist\n",
-    "    if not os.path.exists(name):\n",
-    "        os.mkdir(name)\n",
-    "    # Store the paths in each of their respective directories\n",
-    "    model_path = os.path.join(name, \"network.onnx\")\n",
-    "    compiled_model_path = os.path.join(name, \"network.compiled\")\n",
-    "    pk_path = os.path.join(name, \"test.pk\")\n",
-    "    vk_path = os.path.join(name, \"test.vk\")\n",
-    "    settings_path = os.path.join(name, \"settings.json\")\n",
-    "\n",
-    "    witness_path = os.path.join(name, \"witness.json\")\n",
-    "    sol_code_path = os.path.join(name, 'test.sol')\n",
-    "    sol_key_code_path = os.path.join(name, 'test_key.sol')\n",
-    "    abi_path = os.path.join(name, 'test.abi')\n",
-    "    proof_path = os.path.join(name, \"proof.json\")\n",
-    "\n",
-    "    # Flips the neural net into inference mode\n",
-    "    model.eval()\n",
-    "\n",
-    "    # Export the model\n",
-    "    torch.onnx.export(model, x, model_path, export_params=True, opset_version=10,\n",
-    "                      do_constant_folding=True, input_names=['input'],\n",
-    "                      output_names=['output'], dynamic_axes={'input': {0: 'batch_size'},\n",
-    "                                                              'output': {0: 'batch_size'}})\n",
-    "\n",
-    "    data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
-    "    data = dict(input_data=[data_array])\n",
-    "    json.dump(data, open(input_path, 'w'))\n",
-    "\n",
-    "    py_run_args = ezkl.PyRunArgs()\n",
-    "    py_run_args.input_visibility = \"private\"\n",
-    "    py_run_args.output_visibility = \"public\"\n",
-    "    py_run_args.param_visibility = \"fixed\"  # private by default\n",
-    "\n",
-    "    res = ezkl.gen_settings(model_path, settings_path, py_run_args=py_run_args)\n",
-    "    assert res == True\n",
-    "\n",
-    "    await ezkl.calibrate_settings(input_path, model_path, settings_path, \"resources\")\n",
-    "\n",
-    "    res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
-    "    assert res == True\n",
-    "\n",
-    "    res = await ezkl.get_srs(settings_path)\n",
-    "    assert res == True\n",
-    "\n",
-    "    # now generate the witness file\n",
-    "    res = await ezkl.gen_witness(input_path, compiled_model_path, witness_path)\n",
-    "    assert os.path.isfile(witness_path) == True\n",
-    "\n",
-    "    # SETUP \n",
-    "    # We recommend disabling selector compression for the setup as it decreases the size of the VK artifact\n",
-    "    res = ezkl.setup(compiled_model_path, vk_path, pk_path, disable_selector_compression=True)\n",
-    "    assert res == True\n",
-    "    assert os.path.isfile(vk_path)\n",
-    "    assert os.path.isfile(pk_path)\n",
-    "    assert os.path.isfile(settings_path)\n",
-    "\n",
-    "    # GENERATE A PROOF\n",
-    "    res = ezkl.prove(witness_path, compiled_model_path, pk_path, proof_path, \"single\")\n",
-    "    assert os.path.isfile(proof_path)\n",
-    "\n",
-    "    res = await ezkl.create_evm_verifier(vk_path, settings_path, sol_code_path, abi_path, reusable=True)\n",
-    "    assert res == True\n",
-    "\n",
-    "    res = await ezkl.create_evm_vka(vk_path, settings_path, sol_key_code_path, abi_path)\n",
-    "    assert res == True\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import subprocess\n",
-    "import time\n",
-    "\n",
-    "# make sure anvil is running locally\n",
-    "# $ anvil -p 3030\n",
-    "\n",
-    "RPC_URL = \"http://localhost:3030\"\n",
-    "\n",
-    "# Save process globally\n",
-    "anvil_process = None\n",
-    "\n",
-    "def start_anvil():\n",
-    "    global anvil_process\n",
-    "    if anvil_process is None:\n",
-    "        anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--code-size-limit=41943040\"])\n",
-    "        if anvil_process.returncode is not None:\n",
-    "            raise Exception(\"failed to start anvil process\")\n",
-    "        time.sleep(3)\n",
-    "\n",
-    "def stop_anvil():\n",
-    "    global anvil_process\n",
-    "    if anvil_process is not None:\n",
-    "        anvil_process.terminate()\n",
-    "        anvil_process = None\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Check that the generated verifiers are identical for all models."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "start_anvil()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import filecmp\n",
-    "\n",
-    "def compare_files(file1, file2):\n",
-    "    return filecmp.cmp(file1, file2, shallow=False)\n",
-    "\n",
-    "sol_code_path_0 = os.path.join(\"mlp_sigmoid\", 'test.sol')\n",
-    "sol_code_path_1 = os.path.join(\"mlp_relu\", 'test.sol')\n",
-    "\n",
-    "sol_code_path_2 = os.path.join(\"conv_sigmoid\", 'test.sol')\n",
-    "sol_code_path_3 = os.path.join(\"conv_relu\", 'test.sol')\n",
-    "\n",
-    "\n",
-    "assert compare_files(sol_code_path_0, sol_code_path_1) == True\n",
-    "assert compare_files(sol_code_path_2, sol_code_path_3) == True"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Here we deploy separate verifier that will be shared by the four models. We picked the `1l_mlp sigmoid` model as an example but you could have used any of the generated verifiers since they are all identical. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os \n",
-    "addr_path_verifier = \"addr_verifier.txt\"\n",
-    "sol_code_path = os.path.join(\"mlp_sigmoid\", 'test.sol')\n",
-    "\n",
-    "res = await ezkl.deploy_evm(\n",
-    "    addr_path_verifier,\n",
-    "    sol_code_path,\n",
-    "    'http://127.0.0.1:3030',\n",
-    "    \"verifier/reusable\"\n",
-    ")\n",
-    "\n",
-    "assert res == True\n",
-    "\n",
-    "with open(addr_path_verifier, 'r') as file:\n",
-    "    addr = file.read().rstrip()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Finally we deploy each of the unique VK-artifacts and verify them using the shared verifier deployed in the previous step."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for name in names:\n",
-    "    addr_path_vk = \"addr_vk.txt\"\n",
-    "    sol_key_code_path = os.path.join(name, 'test_key.sol')\n",
-    "    res = await ezkl.deploy_evm(addr_path_vk, sol_key_code_path, 'http://127.0.0.1:3030', \"vka\")\n",
-    "    assert res == True\n",
-    "\n",
-    "    with open(addr_path_vk, 'r') as file:\n",
-    "        addr_vk = file.read().rstrip()\n",
-    "        \n",
-    "    proof_path = os.path.join(name, \"proof.json\")\n",
-    "    sol_code_path = os.path.join(name, 'vk.sol')\n",
-    "    res = await ezkl.verify_evm(\n",
-    "        addr,\n",
-    "        proof_path,\n",
-    "        \"http://127.0.0.1:3030\",\n",
-    "        addr_vk = addr_vk\n",
-    "    )\n",
-    "    assert res == True"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".env",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "# Reusable Verifiers \n",
+                "\n",
+                "TODO: Update the reusable verifier solidity contract name.. Make it less generic to H2 and more bespoke to us.\n",
+                "\n",
+                "This notebook demonstrates how to create and reuse the same set of separated verifiers for different models. Specifically, we will use the same verifier for the following four models:\n",
+                "\n",
+                "- `1l_mlp sigmoid`\n",
+                "- `1l_mlp relu`\n",
+                "- `1l_conv sigmoid`\n",
+                "- `1l_conv relu`\n",
+                "\n",
+                "When deploying EZKL verifiers on the blockchain, each associated model typically requires its own unique verifier, leading to increased on-chain state usage. \n",
+                "However, with the reusable verifier, we can deploy a single verifier that can be used to verify proofs for any valid H2 circuit. This notebook shows how to do so. \n",
+                "\n",
+                "By reusing the same verifier across multiple models, we significantly reduce the amount of state bloat on the blockchain. Instead of deploying a unique verifier for each model, we register a unique and much smaller verifying key artifact (VKA) on the reusable verifier contract for each model while sharing a common separated verifier. The VKA contains the VK for the model as well circuit specific metadata that was otherwise hardcoded into the stack of the original non-reusable verifier. The VKA is passed as a parameter to the verifyProof method. This VKA calldata needs to be d with the reusable verifier before it can start verifying proofs by calling the registerVKA method. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import torch\n",
+                "import torch.nn as nn\n",
+                "import torch.onnx\n",
+                "\n",
+                "# Define the models\n",
+                "class MLP_Sigmoid(nn.Module):\n",
+                "    def __init__(self):\n",
+                "        super(MLP_Sigmoid, self).__init__()\n",
+                "        self.fc = nn.Linear(3, 3)\n",
+                "        self.sigmoid = nn.Sigmoid()\n",
+                "\n",
+                "    def forward(self, x):\n",
+                "        x = self.fc(x)\n",
+                "        x = self.sigmoid(x)\n",
+                "        return x\n",
+                "\n",
+                "class MLP_Relu(nn.Module):\n",
+                "    def __init__(self):\n",
+                "        super(MLP_Relu, self).__init__()\n",
+                "        self.fc = nn.Linear(3, 3)\n",
+                "        self.relu = nn.ReLU()\n",
+                "\n",
+                "    def forward(self, x):\n",
+                "        x = self.fc(x)\n",
+                "        x = self.relu(x)\n",
+                "        return x\n",
+                "\n",
+                "class Conv_Sigmoid(nn.Module):\n",
+                "    def __init__(self):\n",
+                "        super(Conv_Sigmoid, self).__init__()\n",
+                "        self.conv = nn.Conv1d(1, 1, kernel_size=3, stride=1)\n",
+                "        self.sigmoid = nn.Sigmoid()\n",
+                "\n",
+                "    def forward(self, x):\n",
+                "        x = self.conv(x)\n",
+                "        x = self.sigmoid(x)\n",
+                "        return x\n",
+                "\n",
+                "class Conv_Relu(nn.Module):\n",
+                "    def __init__(self):\n",
+                "        super(Conv_Relu, self).__init__()\n",
+                "        self.conv = nn.Conv1d(1, 1, kernel_size=3, stride=1)\n",
+                "        self.relu = nn.ReLU()\n",
+                "\n",
+                "    def forward(self, x):\n",
+                "        x = self.conv(x)\n",
+                "        x = self.relu(x)\n",
+                "        return x\n",
+                "\n",
+                "# Instantiate the models\n",
+                "mlp_sigmoid = MLP_Sigmoid()\n",
+                "mlp_relu = MLP_Relu()\n",
+                "conv_sigmoid = Conv_Sigmoid()\n",
+                "conv_relu = Conv_Relu()\n",
+                "\n",
+                "# Dummy input tensor for mlp\n",
+                "dummy_input_mlp = torch.tensor([[-1.5737053155899048, -1.708398461341858, 0.19544155895709991]])\n",
+                "input_mlp_path = 'mlp_input.json'\n",
+                "\n",
+                "# Dummy input tensor for conv\n",
+                "dummy_input_conv = torch.tensor([[[1.4124163389205933, 0.6938204169273376, 1.0664031505584717]]])\n",
+                "input_conv_path = 'conv_input.json'"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "names = ['mlp_sigmoid', 'mlp_relu', 'conv_sigmoid', 'conv_relu']\n",
+                "models = [mlp_sigmoid, mlp_relu, conv_sigmoid, conv_relu]\n",
+                "inputs = [dummy_input_mlp, dummy_input_mlp, dummy_input_conv, dummy_input_conv]\n",
+                "input_paths = [input_mlp_path, input_mlp_path, input_conv_path, input_conv_path]"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import os\n",
+                "import json\n",
+                "import torch\n",
+                "import ezkl\n",
+                "\n",
+                "for name, model, x, input_path in zip(names, models, inputs, input_paths):\n",
+                "    # Create a new directory for the model if it doesn't exist\n",
+                "    if not os.path.exists(name):\n",
+                "        os.mkdir(name)\n",
+                "    # Store the paths in each of their respective directories\n",
+                "    model_path = os.path.join(name, \"network.onnx\")\n",
+                "    compiled_model_path = os.path.join(name, \"network.compiled\")\n",
+                "    pk_path = os.path.join(name, \"test.pk\")\n",
+                "    vk_path = os.path.join(name, \"test.vk\")\n",
+                "    settings_path = os.path.join(name, \"settings.json\")\n",
+                "\n",
+                "    witness_path = os.path.join(name, \"witness.json\")\n",
+                "    sol_code_path = os.path.join(name, 'test.sol')\n",
+                "    vka_path = os.path.join(name, 'vka.bytes')\n",
+                "    abi_path = os.path.join(name, 'test.abi')\n",
+                "    proof_path = os.path.join(name, \"proof.json\")\n",
+                "\n",
+                "    # Flips the neural net into inference mode\n",
+                "    model.eval()\n",
+                "\n",
+                "    # Export the model\n",
+                "    torch.onnx.export(model, x, model_path, export_params=True, opset_version=10,\n",
+                "                      do_constant_folding=True, input_names=['input'],\n",
+                "                      output_names=['output'], dynamic_axes={'input': {0: 'batch_size'},\n",
+                "                                                              'output': {0: 'batch_size'}})\n",
+                "\n",
+                "    data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
+                "    data = dict(input_data=[data_array])\n",
+                "    json.dump(data, open(input_path, 'w'))\n",
+                "\n",
+                "    py_run_args = ezkl.PyRunArgs()\n",
+                "    py_run_args.input_visibility = \"private\"\n",
+                "    py_run_args.output_visibility = \"public\"\n",
+                "    py_run_args.param_visibility = \"fixed\"  # private by default\n",
+                "\n",
+                "    res = ezkl.gen_settings(model_path, settings_path, py_run_args=py_run_args)\n",
+                "    assert res == True\n",
+                "\n",
+                "    ezkl.calibrate_settings(input_path, model_path, settings_path, \"resources\")\n",
+                "\n",
+                "    res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
+                "    assert res == True\n",
+                "\n",
+                "    res = await ezkl.get_srs(settings_path)\n",
+                "    assert res == True\n",
+                "\n",
+                "    # now generate the witness file\n",
+                "    res = ezkl.gen_witness(input_path, compiled_model_path, witness_path)\n",
+                "    assert os.path.isfile(witness_path) == True\n",
+                "\n",
+                "    # SETUP \n",
+                "    # We recommend disabling selector compression for the setup as it decreases the size of the VK artifact\n",
+                "    res = ezkl.setup(compiled_model_path, vk_path, pk_path, disable_selector_compression=True)\n",
+                "    assert res == True\n",
+                "    assert os.path.isfile(vk_path)\n",
+                "    assert os.path.isfile(pk_path)\n",
+                "    assert os.path.isfile(settings_path)\n",
+                "\n",
+                "    # GENERATE A PROOF\n",
+                "    res = ezkl.prove(witness_path, compiled_model_path, pk_path, proof_path)\n",
+                "    assert os.path.isfile(proof_path)\n",
+                "\n",
+                "    res = await ezkl.create_evm_verifier(vk_path, settings_path, sol_code_path, abi_path, reusable=True)\n",
+                "    # TODO: Add a flag force equals true to in the deprication process to preserve OG single purpose verifier?\n",
+                "    assert res == True\n",
+                "\n",
+                "    # TODO: \n",
+                "    res = await ezkl.create_evm_vka(vk_path, settings_path, vka_path, decimals=18)\n",
+                "    assert res == True\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 7,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import subprocess\n",
+                "import time\n",
+                "\n",
+                "# make sure anvil is running locally\n",
+                "# $ anvil -p 3030\n",
+                "\n",
+                "RPC_URL = \"http://localhost:3030\"\n",
+                "\n",
+                "# Save process globally\n",
+                "anvil_process = None\n",
+                "\n",
+                "def start_anvil():\n",
+                "    global anvil_process\n",
+                "    if anvil_process is None:\n",
+                "        anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--code-size-limit=41943040\"])\n",
+                "        if anvil_process.returncode is not None:\n",
+                "            raise Exception(\"failed to start anvil process\")\n",
+                "        time.sleep(3)\n",
+                "\n",
+                "def stop_anvil():\n",
+                "    global anvil_process\n",
+                "    if anvil_process is not None:\n",
+                "        anvil_process.terminate()\n",
+                "        anvil_process = None\n"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Check that the generated verifiers are identical for all models."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 9,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import filecmp\n",
+                "\n",
+                "def compare_files(file1, file2):\n",
+                "    return filecmp.cmp(file1, file2, shallow=False)\n",
+                "\n",
+                "sol_code_path_0 = os.path.join(\"mlp_sigmoid\", 'test.sol')\n",
+                "sol_code_path_1 = os.path.join(\"mlp_relu\", 'test.sol')\n",
+                "\n",
+                "sol_code_path_2 = os.path.join(\"conv_sigmoid\", 'test.sol')\n",
+                "sol_code_path_3 = os.path.join(\"conv_relu\", 'test.sol')\n",
+                "\n",
+                "\n",
+                "assert compare_files(sol_code_path_0, sol_code_path_1) == True\n",
+                "assert compare_files(sol_code_path_2, sol_code_path_3) == True"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Here we deploy reusable verifier that will be shared by the four models. We picked the `1l_mlp sigmoid` model as an example but you could have used any of the generated verifiers since they are all identical. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 10,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import os \n",
+                "addr_path_verifier = \"addr_verifier.txt\"\n",
+                "sol_code_path = os.path.join(\"mlp_sigmoid\", 'test.sol')\n",
+                "\n",
+                "res = await ezkl.deploy_evm(\n",
+                "    addr_path_verifier,\n",
+                "    'http://127.0.0.1:3030',\n",
+                "    sol_code_path,\n",
+                "    \"verifier/reusable\" # TODO deprecate this option for selecting the type of verifier you want to deploy. \n",
+                "    # verifier, verifier/reusable, vka\n",
+                ")\n",
+                "\n",
+                "assert res == True\n",
+                "\n",
+                "with open(addr_path_verifier, 'r') as file:\n",
+                "    addr = file.read().rstrip()"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Finally we deploy each of the unique VK-artifacts and verify them using the shared verifier deployed in the previous step."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "for name in names:\n",
+                "    addr_path_vk = \"addr_vk.txt\"\n",
+                "    vka_path = os.path.join(name, 'vka.bytes')\n",
+                "    res = await ezkl.register_vka(\n",
+                "        addr, # address of the reusable verifier. TODO: If we deploy the RV across all chains to a single canoncial address, we can hardcode that address and remove this param.\n",
+                "        'http://127.0.0.1:3030',\n",
+                "        vka_path=vka_path, # TODO: Pass in private key and potentially create new command that both creates and registers the vka. Simplify testing pipeline for us and other folks. \n",
+                "    )\n",
+                "    assert res == True\n",
+                "        \n",
+                "    proof_path = os.path.join(name, \"proof.json\")\n",
+                "    res = await ezkl.verify_evm(\n",
+                "        addr,\n",
+                "        \"http://127.0.0.1:3030\",\n",
+                "        proof_path,\n",
+                "        vka_path = vka_path # TODO: Turn this from optional to required if we deprecate the orignal verifier. \n",
+                "        # TODO: Make it where the use only needs to deply a vka.  \n",
+                "    )\n",
+                "    assert res == True"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": ".env",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.11.5"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 2
 }

examples/notebooks/set_membership.ipynb

@@ -167,6 +167,8 @@
         "run_args = ezkl.PyRunArgs()\n",
         "# \"hashed/private\" means that the output of the hashing is not visible to the verifier and is instead fed into the computational graph\n",
         "run_args.input_visibility = \"hashed/private/0\"\n",
+        "# as the inputs are felts we turn off input range checks\n",
+        "run_args.ignore_range_check_inputs_outputs = True\n",
         "# we set it to fix the set we want to check membership for\n",
         "run_args.param_visibility = \"fixed\"\n",
         "# the output is public -- set membership fails if it is not = 0\n",
@@ -229,7 +231,7 @@
       "source": [
         "# now generate the witness file\n",
         "\n",
-        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+        "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
         "assert os.path.isfile(witness_path)"
       ]
     },
@@ -265,7 +267,7 @@
         "    # Serialize data into file:\n",
         "json.dump( data, open(data_path_faulty, 'w' ))\n",
         "\n",
-        "res = await ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path_faulty)\n",
+        "res = ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path_faulty)\n",
         "assert os.path.isfile(witness_path_faulty)"
       ]
     },
@@ -310,7 +312,7 @@
         "# Serialize data into file:\n",
         "json.dump( data, open(data_path_truthy, 'w' ))\n",
         "\n",
-        "res = await ezkl.gen_witness(data_path_truthy, compiled_model_path, witness_path_truthy)\n",
+        "res = ezkl.gen_witness(data_path_truthy, compiled_model_path, witness_path_truthy)\n",
         "assert os.path.isfile(witness_path_truthy)"
       ]
     },
@@ -382,7 +384,7 @@
         "        pk_path,\n",
         "        proof_path,\n",
         "        \n",
-        "        \"single\",\n",
+        "        ",
         "    )\n",
         "\n",
         "print(res)\n",
@@ -409,7 +411,7 @@
         "        pk_path,\n",
         "        proof_path_faulty,\n",
         "        \n",
-        "        \"single\",\n",
+        "        ",
         "    )\n",
         "\n",
         "print(res)\n",
@@ -436,7 +438,7 @@
         "        pk_path,\n",
         "        proof_path_truthy,\n",
         "        \n",
-        "        \"single\",\n",
+        "        ",
         "    )\n",
         "\n",
         "print(res)\n",
@@ -519,4 +521,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 5
-}
+}

examples/notebooks/simple_demo_aggregated_proofs.ipynb

@@ -1,407 +0,0 @@
-{
-    "cells": [
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
-            "metadata": {},
-            "source": [
-                "## EZKL Jupyter Notebook Demo (Aggregated Proofs) \n",
-                "\n",
-                "Demonstrates how to use EZKL with aggregated proofs"
-            ]
-        },
-        {
-            "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",
-                "\n",
-                "# rely on local installation of ezkl if the notebook is not in colab\n",
-                "except:\n",
-                "    pass\n",
-                "\n",
-                "\n",
-                "# here we create and (potentially train a model)\n",
-                "\n",
-                "# make sure you have the dependencies required here already installed\n",
-                "from torch import nn\n",
-                "import ezkl\n",
-                "import os\n",
-                "import json\n",
-                "import torch\n",
-                "\n",
-                "\n",
-                "# Defines the model\n",
-                "# we got convs, we got relu, we got linear layers\n",
-                "# What else could one want ????\n",
-                "\n",
-                "class MyModel(nn.Module):\n",
-                "    def __init__(self):\n",
-                "        super(MyModel, self).__init__()\n",
-                "\n",
-                "        self.conv1 = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=5, stride=2)\n",
-                "        self.conv2 = nn.Conv2d(in_channels=2, out_channels=3, kernel_size=5, stride=2)\n",
-                "\n",
-                "        self.relu = nn.ReLU()\n",
-                "\n",
-                "        self.d1 = nn.Linear(48, 48)\n",
-                "        self.d2 = nn.Linear(48, 10)\n",
-                "\n",
-                "    def forward(self, x):\n",
-                "        # 32x1x28x28 => 32x32x26x26\n",
-                "        x = self.conv1(x)\n",
-                "        x = self.relu(x)\n",
-                "        x = self.conv2(x)\n",
-                "        x = self.relu(x)\n",
-                "\n",
-                "        # flatten => 32 x (32*26*26)\n",
-                "        x = x.flatten(start_dim = 1)\n",
-                "\n",
-                "        # 32 x (32*26*26) => 32x128\n",
-                "        x = self.d1(x)\n",
-                "        x = self.relu(x)\n",
-                "\n",
-                "        # logits => 32x10\n",
-                "        logits = self.d2(x)\n",
-                "\n",
-                "        return logits\n",
-                "\n",
-                "\n",
-                "circuit = MyModel()\n",
-                "\n",
-                "# Train the model as you like here (skipped for brevity)\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",
-                "proof_path = os.path.join('test.pf')\n",
-                "settings_path = os.path.join('settings.json')\n",
-                "srs_path = os.path.join('kzg.srs')\n",
-                "witness_path = os.path.join('witness.json')\n",
-                "data_path = os.path.join('input.json')\n",
-                "aggregate_proof_path = os.path.join('aggr.pf')\n",
-                "aggregate_vk_path = os.path.join('aggr.vk')\n",
-                "aggregate_pk_path = os.path.join('aggr.pk')"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "82db373a",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "shape = [1, 28, 28]\n",
-                "# After training, export to onnx (network.onnx) and create a data file (input.json)\n",
-                "x = 0.1*torch.rand(1,*shape, 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",
-                "                      model_path,            # where to save the model (can be a file or file-like object)\n",
-                "                      export_params=True,        # store the trained parameter weights inside the model file\n",
-                "                      opset_version=10,          # the ONNX version to export the model to\n",
-                "                      do_constant_folding=True,  # whether to execute constant folding for optimization\n",
-                "                      input_names = ['input'],   # the model's input names\n",
-                "                      output_names = ['output'], # the model's output names\n",
-                "                      dynamic_axes={'input' : {0 : 'batch_size'},    # variable length axes\n",
-                "                                    'output' : {0 : 'batch_size'}})\n",
-                "\n",
-                "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(data_path, '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",
-                "\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "cal_path = os.path.join(\"calibration.json\")\n",
-                "\n",
-                "data_array = (torch.rand(20, *shape, requires_grad=True).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",
-                "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
-            ]
-        },
-        {
-            "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",
-                "        \"for-aggr\",  # IMPORTANT NOTE: To produce an aggregated EVM proof you will want to use poseidon for the smaller proofs\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",
-                "assert res == True\n",
-                "print(\"verified\")"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "0832b909",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# Generate a larger SRS. This is needed for the aggregated proof\n",
-                "\n",
-                "res = await ezkl.get_srs(settings_path=None, logrows=21, commitment=ezkl.PyCommitments.KZG)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "c5a64be6",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# Run mock aggregate to check whether the proof works\n",
-                "# Use mock to check for validity as it takes a shorter time to check compared to a full aggregated proof\n",
-                "\n",
-                "res = ezkl.mock_aggregate([proof_path], 21)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "fee8acc6",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# Setup the vk and pk for aggregate\n",
-                "res = ezkl.setup_aggregate(\n",
-                "    [proof_path],\n",
-                "    aggregate_vk_path,\n",
-                "    aggregate_pk_path,\n",
-                "    21\n",
-                ")\n",
-                "\n",
-                "assert os.path.isfile(aggregate_vk_path)\n",
-                "assert os.path.isfile(aggregate_pk_path)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 26,
-            "id": "171702d3",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# Run aggregate proof\n",
-                "res = ezkl.aggregate(\n",
-                "    [proof_path],\n",
-                "    aggregate_proof_path,\n",
-                "    aggregate_pk_path,\n",
-                "    \"evm\",\n",
-                "    21,\n",
-                "    \"safe\"\n",
-                ")\n",
-                "\n",
-                "assert os.path.isfile(aggregate_proof_path)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 27,
-            "id": "671dfdd5",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# Check if the proof is valid\n",
-                "res = ezkl.verify_aggr(\n",
-                "    aggregate_proof_path,\n",
-                "    aggregate_vk_path,\n",
-                "    21,\n",
-                ")\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 28,
-            "id": "50eba2f4",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# Create a smart contract verifier for the aggregated proof\n",
-                "\n",
-                "sol_code_path = os.path.join(\"Verifier.sol\")\n",
-                "abi_path = os.path.join(\"Verifier_ABI.json\")\n",
-                "\n",
-                "res = await ezkl.create_evm_verifier_aggr(\n",
-                "    [settings_path],\n",
-                "    aggregate_vk_path,\n",
-                "    sol_code_path,\n",
-                "    abi_path,\n",
-                "    logrows=21)"
-            ]
-        }
-    ],
-    "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.7"
-        }
-    },
-    "nbformat": 4,
-    "nbformat_minor": 5
-}

examples/notebooks/simple_demo_all_public.ipynb

@@ -171,7 +171,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -205,7 +205,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -255,7 +255,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -304,4 +304,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 5
-}
+}

examples/notebooks/simple_demo_public_input_output.ipynb

@@ -169,7 +169,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -203,7 +203,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -253,7 +253,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -302,4 +302,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 5
-}
+}

examples/notebooks/simple_demo_public_network_output.ipynb

@@ -170,7 +170,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -204,7 +204,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -254,7 +254,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -303,4 +303,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 5
-}
+}

examples/notebooks/sklearn_mlp.ipynb

@@ -149,7 +149,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -183,7 +183,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -233,7 +233,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",

examples/notebooks/solvency.ipynb

@@ -204,6 +204,7 @@
         "run_args = ezkl.PyRunArgs()\n",
         "# \"polycommit\" means that the output of the hashing is not visible to the verifier and is instead fed into the computational graph\n",
         "run_args.input_visibility = \"polycommit\"\n",
+        "run_args.ignore_range_check_inputs_outputs = True\n",
         "# the parameters are public\n",
         "run_args.param_visibility = \"fixed\"\n",
         "# the output is public (this is the inequality test)\n",
@@ -297,7 +298,7 @@
         "\n",
         "witness_path = \"witness.json\"\n",
         "\n",
-        "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)\n",
+        "res = 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",
@@ -322,7 +323,7 @@
         "        pk_path,\n",
         "        proof_path,\n",
         "        \n",
-        "        \"single\",\n",
+        "        ",
         "    )\n",
         "\n",
         "assert os.path.isfile(proof_path)\n",
@@ -411,7 +412,7 @@
       "source": [
         "# now generate the witness file\n",
         "\n",
-        "res = await ezkl.gen_witness(data_path_faulty, compiled_model_path, witness_path, vk_path)\n",
+        "res = 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",
@@ -441,7 +442,7 @@
         "        pk_path,\n",
         "        proof_path,\n",
         "        \n",
-        "        \"single\",\n",
+        "        ",
         "    )\n",
         "\n",
         "print(res)\n",
@@ -514,4 +515,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 5
-}
+}

examples/notebooks/stacked_regression.ipynb

@@ -167,7 +167,7 @@
                 "res = ezkl.gen_settings(model_path, settings_path)\n",
                 "assert res == True\n",
                 "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = 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",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -221,7 +221,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -271,7 +271,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",

examples/notebooks/svm.ipynb

@@ -152,7 +152,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -186,7 +186,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -236,7 +236,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -392,7 +392,7 @@
                 "res = ezkl.gen_settings(model_path, settings_path)\n",
                 "assert res == True\n",
                 "\n",
-                "res = await ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
                 "assert res == True"
             ]
         }
@@ -418,4 +418,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 5
-}
+}

examples/notebooks/tictactoe_autoencoder.ipynb

@@ -637,7 +637,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [11])"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [11])"
             ]
         },
         {
@@ -683,7 +683,7 @@
                 "    data = json.load(f)\n",
                 "    print(len(data['input_data'][0]))\n",
                 "\n",
-                "await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
+                "ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
             ]
         },
         {
@@ -707,7 +707,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -758,4 +758,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 4
-}
+}

examples/notebooks/tictactoe_binary_classification.ipynb

@@ -525,7 +525,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [4])"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [4])"
             ]
         },
         {
@@ -572,7 +572,7 @@
                 "    data = json.load(f)\n",
                 "    print(len(data['input_data'][0]))\n",
                 "\n",
-                "await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
+                "ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
             ]
         },
         {
@@ -596,7 +596,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -647,4 +647,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 4
-}
+}

examples/notebooks/univ3-da.ipynb

@@ -1,763 +0,0 @@
-{
-    "cells": [
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "# univ3-da-ezkl\n",
-                "\n",
-                "Here's an example leveraging EZKL whereby the inputs to the model are read and attested to from an on-chain source. For this setup we make a single call to a view function that returns an array of UniV3 historical TWAP price data that we will attest to on-chain. \n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "First we import the necessary dependencies and set up logging to be as informative as possible. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 2,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# check if notebook is in colab\n",
-                "try:\n",
-                "    # install ezkl\n",
-                "    import google.colab\n",
-                "    import subprocess\n",
-                "    import sys\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
-                "\n",
-                "# rely on local installation of ezkl if the notebook is not in colab\n",
-                "except:\n",
-                "    pass\n",
-                "\n",
-                "\n",
-                "from torch import nn\n",
-                "import ezkl\n",
-                "import os\n",
-                "import json\n",
-                "import logging\n",
-                "\n",
-                "# uncomment for more descriptive logging \n",
-                "FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
-                "logging.basicConfig(format=FORMAT)\n",
-                "logging.getLogger().setLevel(logging.DEBUG)\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we define our model. It is a very simple PyTorch model that has just one layer, an average pooling 2D layer. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 3,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import torch\n",
-                "# Defines the model\n",
-                "\n",
-                "class MyModel(nn.Module):\n",
-                "    def __init__(self):\n",
-                "        super(MyModel, self).__init__()\n",
-                "        self.layer = nn.AvgPool2d(2, 1, (1, 1))\n",
-                "\n",
-                "    def forward(self, x):\n",
-                "        return self.layer(x)[0]\n",
-                "\n",
-                "\n",
-                "circuit = MyModel()\n",
-                "\n",
-                "# this is where you'd train your model"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We omit training for purposes of this demonstration. We've marked where training would happen in the cell above. \n",
-                "Now we export the model to onnx and create a corresponding (randomly generated) input. This input data will eventually be stored on chain and read from according to the call_data field in the graph input.\n",
-                "\n",
-                "You can replace the random `x` with real data if you so wish. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 4,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "x = 0.1*torch.rand(1,*[3, 2, 2], requires_grad=True)\n",
-                "\n",
-                "# Flips the neural net into inference mode\n",
-                "circuit.eval()\n",
-                "\n",
-                "    # Export the model\n",
-                "torch.onnx.export(circuit,               # model being run\n",
-                "                      x,                   # model input (or a tuple for multiple inputs)\n",
-                "                      \"network.onnx\",            # where to save the model (can be a file or file-like object)\n",
-                "                      export_params=True,        # store the trained parameter weights inside the model file\n",
-                "                      opset_version=10,          # the ONNX version to export the model to\n",
-                "                      do_constant_folding=True,  # whether to execute constant folding for optimization\n",
-                "                      input_names = ['input'],   # the model's input names\n",
-                "                      output_names = ['output'], # the model's output names\n",
-                "                      dynamic_axes={'input' : {0 : 'batch_size'},    # variable length axes\n",
-                "                                    'output' : {0 : 'batch_size'}})\n",
-                "\n",
-                "data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
-                "\n",
-                "data = dict(input_data = [data_array])\n",
-                "\n",
-                "    # Serialize data into file:\n",
-                "json.dump(data, open(\"input.json\", 'w' ))\n",
-                "\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now define a function that will create a new anvil instance which we will deploy our test contract too. This contract will contain in its storage the data that we will read from and attest to. In production you would not need to set up a local anvil instance. Instead you would replace RPC_URL with the actual RPC endpoint of the chain you are deploying your verifiers too, reading from the data on said chain."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 44,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import subprocess\n",
-                "import time\n",
-                "import threading\n",
-                "\n",
-                "# make sure anvil is running locally\n",
-                "# $ anvil -p 3030\n",
-                "\n",
-                "RPC_URL = \"http://localhost:3030\"\n",
-                "\n",
-                "# Save process globally\n",
-                "anvil_process = None\n",
-                "\n",
-                "def start_anvil():\n",
-                "    global anvil_process\n",
-                "    if anvil_process is None:\n",
-                "        anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--fork-url\", \"https://arb1.arbitrum.io/rpc\", \"--code-size-limit=41943040\"])\n",
-                "        if anvil_process.returncode is not None:\n",
-                "            raise Exception(\"failed to start anvil process\")\n",
-                "        time.sleep(3)\n",
-                "\n",
-                "def stop_anvil():\n",
-                "    global anvil_process\n",
-                "    if anvil_process is not None:\n",
-                "        anvil_process.terminate()\n",
-                "        anvil_process = None\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
-                "- `input_visibility` defines the visibility of the model inputs\n",
-                "- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
-                "- `output_visibility` defines the visibility of the model outputs\n",
-                "\n",
-                "Here we create the following setup:\n",
-                "- `input_visibility`: \"public\"\n",
-                "- `param_visibility`: \"private\"\n",
-                "- `output_visibility`: public\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 6,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import ezkl\n",
-                "\n",
-                "model_path = os.path.join('network.onnx')\n",
-                "compiled_model_path = os.path.join('network.compiled')\n",
-                "pk_path = os.path.join('test.pk')\n",
-                "vk_path = os.path.join('test.vk')\n",
-                "settings_path = os.path.join('settings.json')\n",
-                "srs_path = os.path.join('kzg.srs')\n",
-                "data_path = os.path.join('input.json')\n",
-                "\n",
-                "run_args = ezkl.PyRunArgs()\n",
-                "run_args.input_visibility = \"public\"\n",
-                "run_args.param_visibility = \"private\"\n",
-                "run_args.output_visibility = \"public\"\n",
-                "run_args.num_inner_cols = 1\n",
-                "run_args.variables = [(\"batch_size\", 1)]"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
-                "\n",
-                "You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# TODO: Dictionary outputs\n",
-                "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# generate a bunch of dummy calibration data\n",
-                "cal_data = {\n",
-                "    \"input_data\": [(0.1*torch.rand(2, *[3, 2, 2])).flatten().tolist()],\n",
-                "}\n",
-                "\n",
-                "cal_path = os.path.join('val_data.json')\n",
-                "# save as json file\n",
-                "with open(cal_path, \"w\") as f:\n",
-                "    json.dump(cal_data, f)\n",
-                "\n",
-                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "The graph input for on chain data sources is formatted completely differently compared to file based data sources.\n",
-                "\n",
-                "- For file data sources, the raw floating point values that eventually get quantized, converted into field elements and stored in `witness.json` to be consumed by the circuit are stored. The output data contains the expected floating point values returned as outputs from running your vanilla pytorch model on the given inputs.\n",
-                "- For on chain data sources, the input_data field contains all the data necessary to read and format the on chain data into something digestable by EZKL (aka field elements :-D). \n",
-                "Here is what the schema for an on-chain data source graph input file should look like for a single call data source:\n",
-                "    \n",
-                "```json\n",
-                "{\n",
-                "    \"input_data\": {\n",
-                "        \"rpc\": \"http://localhost:3030\", // The rpc endpoint of the chain you are deploying your verifier to\n",
-                "        \"calls\": {\n",
-                "            \"call_data\": \"1f3be514000000000000000000000000c6962004f452be9203591991d15f6b388e09e8d00000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000\", // The abi encoded call data to a view function that returns an array of on-chain data points we are attesting to. \n",
-                "            \"decimals\": 0, // The number of decimal places of the large uint256 value. This is our way of representing large wei values as floating points on chain, since the evm only natively supports integer values.\n",
-                "            \"address\": \"9A213F53334279C128C37DA962E5472eCD90554f\", // The address of the contract that we are calling to get the data. \n",
-                "            \"len\": 12 // The number of data points returned by the view function (the length of the array)\n",
-                "        }\n",
-                "    }\n",
-                "}\n",
-                "```"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "from web3 import Web3, HTTPProvider\n",
-                "from solcx import compile_standard\n",
-                "from decimal import Decimal\n",
-                "import json\n",
-                "import os\n",
-                "import torch\n",
-                "import requests\n",
-                "\n",
-                "# This function counts the decimal places of a floating point number\n",
-                "def count_decimal_places(num):\n",
-                "    num_str = str(num)\n",
-                "    if '.' in num_str:\n",
-                "        return len(num_str) - 1 - num_str.index('.')\n",
-                "    else:\n",
-                "        return 0\n",
-                "\n",
-                "# setup web3 instance\n",
-                "w3 = Web3(HTTPProvider(RPC_URL)) \n",
-                "\n",
-                "def set_next_block_timestamp(anvil_url, timestamp):\n",
-                "    # Send the JSON-RPC request to Anvil\n",
-                "    payload = {\n",
-                "        \"jsonrpc\": \"2.0\",\n",
-                "        \"id\": 1,\n",
-                "        \"method\": \"evm_setNextBlockTimestamp\",\n",
-                "        \"params\": [timestamp]\n",
-                "    }\n",
-                "    response = requests.post(anvil_url, json=payload)\n",
-                "    if response.status_code == 200:\n",
-                "        print(f\"Next block timestamp set to: {timestamp}\")\n",
-                "    else:\n",
-                "        print(f\"Failed to set next block timestamp: {response.text}\")\n",
-                "\n",
-                "def on_chain_data(tensor):\n",
-                "    # Step 0: Convert the tensor to a flat list\n",
-                "    data = tensor.view(-1).tolist()\n",
-                "\n",
-                "    # Step 1: Prepare the calldata\n",
-                "    secondsAgo = [len(data) - 1 - i for i in range(len(data))]\n",
-                "\n",
-                "    # Step 2: Prepare and compile the contract UniTickAttestor contract\n",
-                "    contract_source_code = '''\n",
-                "    // SPDX-License-Identifier: MIT\n",
-                "    pragma solidity ^0.8.20;\n",
-                "\n",
-                "    /// @title Pool state that is not stored\n",
-                "    /// @notice Contains view functions to provide information about the pool that is computed rather than stored on the\n",
-                "    /// blockchain. The functions here may have variable gas costs.\n",
-                "    interface IUniswapV3PoolDerivedState {\n",
-                "        /// @notice Returns the cumulative tick and liquidity as of each timestamp `secondsAgo` from the current block timestamp\n",
-                "        /// @dev To get a time weighted average tick or liquidity-in-range, you must call this with two values, one representing\n",
-                "        /// the beginning of the period and another for the end of the period. E.g., to get the last hour time-weighted average tick,\n",
-                "        /// you must call it with secondsAgos = [3600, 0].\n",
-                "        /// log base sqrt(1.0001) of token1 / token0. The TickMath library can be used to go from a tick value to a ratio.\n",
-                "        /// @dev The time weighted average tick represents the geometric time weighted average price of the pool, in\n",
-                "        /// @param secondsAgos From how long ago each cumulative tick and liquidity value should be returned\n",
-                "        /// @return tickCumulatives Cumulative tick values as of each `secondsAgos` from the current block timestamp\n",
-                "        /// @return secondsPerLiquidityCumulativeX128s Cumulative seconds per liquidity-in-range value as of each `secondsAgos` from the current block\n",
-                "        /// timestamp\n",
-                "        function observe(\n",
-                "            uint32[] calldata secondsAgos\n",
-                "        )\n",
-                "            external\n",
-                "            view\n",
-                "            returns (\n",
-                "                int56[] memory tickCumulatives,\n",
-                "                uint160[] memory secondsPerLiquidityCumulativeX128s\n",
-                "            );\n",
-                "    }\n",
-                "\n",
-                "    /// @title Uniswap Wrapper around `pool.observe` that stores the parameters for fetching and then attesting to historical data\n",
-                "    /// @notice Provides functions to integrate with V3 pool oracle\n",
-                "    contract UniTickAttestor {\n",
-                "        /**\n",
-                "        * @notice Calculates time-weighted means of tick and liquidity for a given Uniswap V3 pool\n",
-                "        * @param pool Address of the pool that we want to observe\n",
-                "        * @param secondsAgo Number of seconds in the past from which to calculate the time-weighted means\n",
-                "        * @return tickCumulatives The cumulative tick values as of each `secondsAgo` from the current block timestamp\n",
-                "        */\n",
-                "        function consult(\n",
-                "            IUniswapV3PoolDerivedState pool,\n",
-                "            uint32[] memory secondsAgo\n",
-                "        ) public view returns (int256[] memory tickCumulatives) {\n",
-                "            tickCumulatives = new int256[](secondsAgo.length);\n",
-                "            (int56[] memory _ticks,) = pool.observe(secondsAgo);\n",
-                "            for (uint256 i = 0; i < secondsAgo.length; i++) {\n",
-                "                tickCumulatives[i] = int256(_ticks[i]);\n",
-                "            }\n",
-                "        }\n",
-                "    }\n",
-                "    '''\n",
-                "\n",
-                "    compiled_sol = compile_standard({\n",
-                "        \"language\": \"Solidity\",\n",
-                "        \"sources\": {\"UniTickAttestor.sol\": {\"content\": contract_source_code}},\n",
-                "        \"settings\": {\"outputSelection\": {\"*\": {\"*\": [\"metadata\", \"evm.bytecode\", \"abi\"]}}}\n",
-                "    })\n",
-                "\n",
-                "    # Get bytecode\n",
-                "    bytecode = compiled_sol['contracts']['UniTickAttestor.sol']['UniTickAttestor']['evm']['bytecode']['object']\n",
-                "\n",
-                "    # Get ABI\n",
-                "    # In production if you are reading from really large contracts you can just use\n",
-                "    # a stripped down version of the ABI of the contract you are calling, containing only the view functions you will fetch data from.\n",
-                "    abi = json.loads(compiled_sol['contracts']['UniTickAttestor.sol']['UniTickAttestor']['metadata'])['output']['abi']\n",
-                "\n",
-                "    # Step 3: Deploy the contract\n",
-                "    UniTickAttestor = w3.eth.contract(abi=abi, bytecode=bytecode)\n",
-                "    tx_hash = UniTickAttestor.constructor().transact()\n",
-                "    tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)\n",
-                "    # If you are deploying to production you can skip the 3 lines of code above and just instantiate the contract like this,\n",
-                "    # passing the address and abi of the contract you are fetching data from.\n",
-                "    contract = w3.eth.contract(address=tx_receipt['contractAddress'], abi=abi)\n",
-                "\n",
-                "    # Step 4: Interact with the contract\n",
-                "    call = contract.functions.consult(\n",
-                "        # Address of the UniV3 usdc-weth pool 0.005 fee\n",
-                "        \"0xC6962004f452bE9203591991D15f6b388e09E8D0\",\n",
-                "        secondsAgo\n",
-                "    ).build_transaction()\n",
-                "    result = contract.functions.consult(\n",
-                "        # Address of the UniV3 usdc-weth pool 0.005 fee\n",
-                "        \"0xC6962004f452bE9203591991D15f6b388e09E8D0\",\n",
-                "        secondsAgo\n",
-                "    ).call()\n",
-                "    \n",
-                "    print(f'result: {result}')\n",
-                "    calldata = call['data'][2:]\n",
-                "\n",
-                "    time_stamp = w3.eth.get_block('latest')['timestamp']\n",
-                "\n",
-                "    print(f'time_stamp: {time_stamp}')\n",
-                "\n",
-                "    # Set the next block timestamp using the fetched time_stamp\n",
-                "    set_next_block_timestamp(RPC_URL, time_stamp)\n",
-                "\n",
-                "\n",
-                "    # Prepare the calls_to_account object\n",
-                "    # If you were calling view functions across multiple contracts,\n",
-                "    # you would have multiple entries in the calls_to_account array,\n",
-                "    # one for each contract.\n",
-                "    call_to_account = {\n",
-                "        'call_data': calldata,\n",
-                "        'decimals': 0,\n",
-                "        'address': contract.address[2:], # remove the '0x' prefix\n",
-                "        'len': len(data),\n",
-                "    }\n",
-                "\n",
-                "    print(f'call_to_account: {call_to_account}')\n",
-                "\n",
-                "    return call_to_account\n",
-                "\n",
-                "# Now let's start the Anvil process. You don't need to do this if you are deploying to a non-local chain.\n",
-                "start_anvil()\n",
-                "\n",
-                "# Now let's call our function, passing in the same input tensor we used to export the model 2 cells above.\n",
-                "calls_to_account = on_chain_data(x)\n",
-                "\n",
-                "data = dict(input_data =  {'rpc': RPC_URL, 'calls': calls_to_account })\n",
-                "\n",
-                "# Serialize on-chain data into file:\n",
-                "json.dump(data, open(\"input.json\", 'w'))"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
-                "\n",
-                "These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = await ezkl.get_srs( settings_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now need to generate the circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# !export RUST_BACKTRACE=1\n",
-                "\n",
-                "witness_path = \"witness.json\"\n",
-                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# HERE WE SETUP THE CIRCUIT PARAMS\n",
-                "# WE GOT KEYS\n",
-                "# WE GOT CIRCUIT PARAMETERS\n",
-                "# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
-                "res = ezkl.setup(\n",
-                "        compiled_model_path,\n",
-                "        vk_path,\n",
-                "        pk_path,\n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "assert os.path.isfile(vk_path)\n",
-                "assert os.path.isfile(pk_path)\n",
-                "assert os.path.isfile(settings_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we generate a full proof. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# GENERATE A PROOF\n",
-                "\n",
-                "proof_path = os.path.join('test.pf')\n",
-                "\n",
-                "res = ezkl.prove(\n",
-                "        witness_path,\n",
-                "        compiled_model_path,\n",
-                "        pk_path,\n",
-                "        proof_path,\n",
-                "        \"single\",\n",
-                "    )\n",
-                "\n",
-                "print(res)\n",
-                "assert os.path.isfile(proof_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "And verify it as a sanity check. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# VERIFY IT\n",
-                "\n",
-                "res = ezkl.verify(\n",
-                "        proof_path,\n",
-                "        settings_path,\n",
-                "        vk_path,\n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "print(\"verified\")"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We can now create and then deploy a vanilla evm verifier."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "\n",
-                "res = await ezkl.create_evm_verifier(\n",
-                "        vk_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "    )\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import json\n",
-                "\n",
-                "addr_path_verifier = \"addr_verifier.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_evm(\n",
-                "    addr_path_verifier,\n",
-                "    sol_code_path,\n",
-                "    'http://127.0.0.1:3030'\n",
-                ")\n",
-                "\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "With the vanilla verifier deployed, we can now create the data attestation contract, which will read in the instances from the calldata to the verifier, attest to them, call the verifier and then return the result. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "input_path = 'input.json'\n",
-                "\n",
-                "res = await ezkl.create_evm_data_attestation(\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "    )"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we can deploy the data attest verifier contract. For security reasons, this binding will only deploy to a local anvil instance, using accounts generated by anvil. \n",
-                "So should only be used for testing purposes."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "addr_path_da = \"addr_da.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_da_evm(\n",
-                "        addr_path_da,\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        RPC_URL,\n",
-                "    )\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Here we need to regenerate the witness, prove and then verify all within the same cell. This is because we want to reduce the amount of latency between reading on-chain state and verifying it on-chain. This is because the attest input values read from the oracle are time sensitive (their values are derived from computing on block.timestamp) and can change between the time of reading and the time of verifying.\n",
-                "\n",
-                "Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# !export RUST_BACKTRACE=1\n",
-                "\n",
-                "calls_to_account = on_chain_data(x)\n",
-                "\n",
-                "data = dict(input_data =  {'rpc': RPC_URL, 'calls': calls_to_account })\n",
-                "\n",
-                "# Serialize on-chain data into file:\n",
-                "json.dump(data, open(\"input.json\", 'w'))\n",
-                "\n",
-                "# setup web3 instance\n",
-                "w3 = Web3(HTTPProvider(RPC_URL)) \n",
-                "\n",
-                "time_stamp = w3.eth.get_block('latest')['timestamp']\n",
-                "\n",
-                "print(f'time_stamp: {time_stamp}')\n",
-                "\n",
-                "\n",
-                "witness_path = \"witness.json\"\n",
-                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
-                "\n",
-                "res = ezkl.prove(\n",
-                "        witness_path,\n",
-                "        compiled_model_path,\n",
-                "        pk_path,\n",
-                "        proof_path,\n",
-                "        \"single\",\n",
-                "    )\n",
-                "\n",
-                "print(res)\n",
-                "assert os.path.isfile(proof_path)\n",
-                "# read the verifier address\n",
-                "addr_verifier = None\n",
-                "with open(addr_path_verifier, 'r') as f:\n",
-                "    addr = f.read()\n",
-                "#read the data attestation address\n",
-                "addr_da = None\n",
-                "with open(addr_path_da, 'r') as f:\n",
-                "    addr_da = f.read()\n",
-                "\n",
-                "res = await ezkl.verify_evm(\n",
-                "    addr,\n",
-                "    proof_path,\n",
-                "    RPC_URL,\n",
-                "    addr_da,\n",
-                ")"
-            ]
-        }
-    ],
-    "metadata": {
-        "kernelspec": {
-            "display_name": ".env",
-            "language": "python",
-            "name": "python3"
-        },
-        "language_info": {
-            "codemirror_mode": {
-                "name": "ipython",
-                "version": 3
-            },
-            "file_extension": ".py",
-            "mimetype": "text/x-python",
-            "name": "python",
-            "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3",
-            "version": "3.11.5"
-        },
-        "orig_nbformat": 4
-    },
-    "nbformat": 4,
-    "nbformat_minor": 2
-}

examples/notebooks/variance.ipynb

@@ -458,7 +458,7 @@
         "\n",
         "\n",
         "ezkl.gen_settings(onnx_filename, settings_filename)\n",
-        "await ezkl.calibrate_settings(\n",
+        "ezkl.calibrate_settings(\n",
         "    input_filename, onnx_filename, settings_filename, \"resources\", scales = [4])\n",
         "res = await ezkl.get_srs(settings_filename)\n",
         "ezkl.compile_circuit(onnx_filename, compiled_filename, settings_filename)\n",
@@ -527,7 +527,7 @@
         "\n",
         "witness_path = \"witness.json\"\n",
         "\n",
-        "res = await ezkl.gen_witness(input_filename, compiled_filename, witness_path)\n",
+        "res = ezkl.gen_witness(input_filename, compiled_filename, witness_path)\n",
         "assert os.path.isfile(witness_path)"
       ]
     },
@@ -580,7 +580,7 @@
         "        compiled_filename,\n",
         "        pk_path,\n",
         "        proof_path,\n",
-        "        \"single\",\n",
+        "        ",
         "    )\n",
         "\n",
         "\n",
@@ -666,7 +666,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 11,
+      "execution_count": null,
       "metadata": {},
       "outputs": [
         {
@@ -689,8 +689,8 @@
         "# await\n",
         "res = await ezkl.deploy_evm(\n",
         "    address_path,\n",
+        "    'http://127.0.0.1:3030',\n",
         "    sol_code_path,\n",
-        "    'http://127.0.0.1:3030'\n",
         ")\n",
         "\n",
         "assert res == True\n",
@@ -701,7 +701,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 12,
+      "execution_count": null,
       "metadata": {},
       "outputs": [
         {
@@ -722,8 +722,8 @@
         "\n",
         "res = await ezkl.verify_evm(\n",
         "    addr,\n",
+        "    \"http://127.0.0.1:3030\",\n",
         "    proof_path,\n",
-        "    \"http://127.0.0.1:3030\"\n",
         ")\n",
         "assert res == True"
       ]
@@ -743,7 +743,8 @@
       "provenance": []
     },
     "kernelspec": {
-      "display_name": "Python 3",
+      "display_name": ".env",
+      "language": "python",
       "name": "python3"
     },
     "language_info": {
@@ -756,9 +757,9 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.12.2"
+      "version": "3.12.9"
     }
   },
   "nbformat": 4,
   "nbformat_minor": 0
-}
+}

examples/notebooks/voice_judge.ipynb

@@ -629,7 +629,7 @@
             "source": [
                 "\n",
                 "\n",
-                "res = await ezkl.calibrate_settings(val_data, model_path, settings_path, \"resources\", scales = [4])\n",
+                "res = ezkl.calibrate_settings(val_data, model_path, settings_path, \"resources\", scales = [4])\n",
                 "assert res == True\n",
                 "print(\"verified\")\n"
             ]
@@ -680,7 +680,7 @@
                 "\n",
                 "witness_path = \"witness.json\"\n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -759,7 +759,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",
@@ -849,8 +849,8 @@
                 "\n",
                 "res = await ezkl.deploy_evm(\n",
                 "    address_path,\n",
+                "    'http://127.0.0.1:3030',\n",
                 "    sol_code_path,\n",
-                "    'http://127.0.0.1:3030'\n",
                 ")\n",
                 "\n",
                 "assert res == True\n",
@@ -870,8 +870,8 @@
                 "\n",
                 "res = await ezkl.verify_evm(\n",
                 "    addr,\n",
-                "    proof_path,\n",
-                "    \"http://127.0.0.1:3030\"\n",
+                "    \"http://127.0.0.1:3030\",\n",
+                "    proof_path\n",
                 ")\n",
                 "assert res == True"
             ]

examples/notebooks/world_rotation.ipynb

@@ -1,547 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
-   "metadata": {},
-   "source": [
-    "## World rotation\n",
-    "\n",
-    "Here we demonstrate how to use the EZKL package to rotate an on-chain world. \n",
-    "\n",
-    "![zk-gaming-diagram-transformed](https://hackmd.io/_uploads/HkApuQGV6.png)\n",
-    "> **A typical ZK application flow**. For the shape rotators out there — this is an easily digestible example. A user computes a ZK-proof that they have calculated a valid rotation of a world. They submit this proof to a verifier contract which governs an on-chain world, along with a new set of coordinates, and the world rotation updates. Observe that it’s possible for one player to initiate a *global* change.\n"
-   ]
-  },
-  {
-   "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",
-    "\n",
-    "# rely on local installation of ezkl if the notebook is not in colab\n",
-    "except:\n",
-    "    pass\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from torch import nn\n",
-    "import ezkl\n",
-    "import os\n",
-    "import json\n",
-    "import torch\n",
-    "import math\n",
-    "\n",
-    "# these are constants for the rotation\n",
-    "phi = torch.tensor(5 * math.pi / 180)\n",
-    "s = torch.sin(phi)\n",
-    "c = torch.cos(phi)\n",
-    "\n",
-    "\n",
-    "class RotateStuff(nn.Module):\n",
-    "    def __init__(self):\n",
-    "        super(RotateStuff, self).__init__()\n",
-    "\n",
-    "        # create a rotation matrix -- the matrix is constant and is transposed for convenience\n",
-    "        self.rot = torch.stack([torch.stack([c, -s]),\n",
-    "                   torch.stack([s, c])]).t()\n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        x_rot = x @ self.rot   # same as x_rot = (rot @ x.t()).t() due to rot in O(n) (SO(n) even)\n",
-    "        return x_rot\n",
-    "\n",
-    "\n",
-    "circuit = RotateStuff()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This will showcase the principle directions of rotation by plotting the rotation of a single unit vector."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from matplotlib import pyplot\n",
-    "pyplot.figure(figsize=(3, 3))\n",
-    "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",
-    "pyplot.arrow(0, 0, circuit.rot[0, 0].item(), circuit.rot[0, 1].item(), width=0.02)\n",
-    "pyplot.arrow(0, 0, circuit.rot[1, 0].item(), circuit.rot[1, 1].item(), width=0.02)\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",
-    "srs_path = os.path.join('kzg.srs')\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",
-    "# initial principle vectors for the rotation are as in the plot above\n",
-    "x = torch.tensor([[1, 0], [0, 1]], dtype=torch.float32)\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",
-    "                      model_path,            # where to save the model (can be a file or file-like object)\n",
-    "                      export_params=True,        # store the trained parameter weights inside the model file\n",
-    "                      opset_version=10,          # the ONNX version to export the model to\n",
-    "                      do_constant_folding=True,  # whether to execute constant folding for optimization\n",
-    "                      input_names = ['input'],   # the model's input names\n",
-    "                      output_names = ['output'], # the model's output names\n",
-    "                      )\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(data_path, 'w' ))\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### World rotation in 2D on-chain"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For demo purposes we deploy these coordinates to a contract running locally using Anvil. This creates our on-chain world. We then rotate the world using the EZKL package and submit the proof to the contract. The contract then updates the world rotation. For demo purposes we do this repeatedly, rotating the world by 1 transform each time."
-   ]
-  },
-  {
-   "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"
-   ]
-  },
-  {
-   "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`: \"fixed\"\n",
-    "- `output_visibility`: public"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d5e374a2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "py_run_args = ezkl.PyRunArgs()\n",
-    "py_run_args.input_visibility = \"public\"\n",
-    "py_run_args.output_visibility = \"public\"\n",
-    "py_run_args.param_visibility = \"private\" # private by default\n",
-    "py_run_args.scale_rebase_multiplier = 10\n",
-    "\n",
-    "res = ezkl.gen_settings(model_path, settings_path, py_run_args=py_run_args)"
-   ]
-  },
-  {
-   "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": "markdown",
-   "metadata": {},
-   "source": [
-    "We also define a contract that holds out test data. 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,
-   "id": "2007dc77",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "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)"
-   ]
-  },
-  {
-   "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",
-    "\n",
-    "These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
-   ]
-  },
-  {
-   "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",
-    "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. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b1c561a8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "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": "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."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d1920c0f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "abi_path = 'test.abi'\n",
-    "sol_code_path = 'test.sol'\n",
-    "\n",
-    "res = await ezkl.create_evm_verifier(\n",
-    "        vk_path,\n",
-    "        settings_path,\n",
-    "        sol_code_path,\n",
-    "        abi_path,\n",
-    "    )\n",
-    "assert res == True"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0fd7f22b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import json\n",
-    "\n",
-    "addr_path_verifier = \"addr_verifier.txt\"\n",
-    "\n",
-    "res = await ezkl.deploy_evm(\n",
-    "    addr_path_verifier,\n",
-    "    sol_code_path,\n",
-    "    'http://127.0.0.1:3030'\n",
-    ")\n",
-    "\n",
-    "assert res == True"
-   ]
-  },
-  {
-   "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",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cc888848",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c2db14d7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "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",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5a018ba6",
-   "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",
-    "    )"
-   ]
-  },
-  {
-   "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. "
-   ]
-  },
-  {
-   "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": "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."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "76f00d41",
-   "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 = ezkl.verify_evm(\n",
-    "    addr,\n",
-    "    proof_path,\n",
-    "    RPC_URL,\n",
-    "    addr_da,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As a sanity check lets plot the rotations of the unit vectors. We can see that the unit vectors rotate as expected by the output of the circuit. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "witness['outputs'][0][0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "settings = json.load(open(settings_path, 'r'))\n",
-    "out_scale = settings[\"model_output_scales\"][0]\n",
-    "\n",
-    "from matplotlib import pyplot\n",
-    "pyplot.figure(figsize=(3, 3))\n",
-    "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.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.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)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

examples/notebooks/xgboost.ipynb

@@ -193,7 +193,7 @@
                 "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\")"
+                "res = ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
             ]
         },
         {
@@ -227,7 +227,7 @@
             "source": [
                 "# now generate the witness file \n",
                 "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
                 "assert os.path.isfile(witness_path)"
             ]
         },
@@ -277,7 +277,7 @@
                 "        pk_path,\n",
                 "        proof_path,\n",
                 "        \n",
-                "        \"single\",\n",
+                "        ",
                 "    )\n",
                 "\n",
                 "print(res)\n",

examples/onnx/1d_conv/input.json

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

examples/onnx/1l_div/settings.json

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

examples/onnx/integer_div/gen.py

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

examples/onnx/integer_div/input.json

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

examples/onnx/large_mlp/gen.py

@@ -0,0 +1,79 @@
+from torch import nn
+import torch.nn.init as init
+import torch
+import json
+
+N = 100
+
+class Model(nn.Module):
+    def __init__(self, inplace=False):
+        super(Model, self).__init__()
+
+        self.aff1 = nn.Linear(N,N)
+        self.aff2 = nn.Linear(N,N)
+        self.aff3 = nn.Linear(N,N)
+        self.aff4 = nn.Linear(N,N)
+        self.aff5 = nn.Linear(N,N)
+        self.aff6 = nn.Linear(N,N)
+        self.aff7 = nn.Linear(N,N)
+        self.aff8 = nn.Linear(N,N)
+        self.aff9 = nn.Linear(N,N)
+        self.relu = nn.ReLU()
+        self._initialize_weights()
+
+    def forward(self, x):
+        # concat 10 x along dim 0
+        x = x.repeat(10, 1)
+        x = self.aff1(x)
+        x = self.relu(x)
+        x = self.aff2(x)
+        x = self.relu(x)
+        x = self.aff3(x)
+        x = self.relu(x)
+        x = self.aff4(x)
+        x = self.relu(x)
+        x = self.aff5(x)
+        x = self.relu(x)
+        x = self.aff6(x)
+        x = self.relu(x)
+        x = self.aff7(x)
+        x = self.relu(x)
+        x = self.aff8(x)
+        x = self.relu(x)
+        x = self.aff9(x)
+        return x
+
+
+    def _initialize_weights(self):
+        init.orthogonal_(self.aff1.weight)
+
+model = Model()
+
+# Flips the neural net into inference mode
+model.eval()
+model.to('cpu')
+
+
+x = torch.randn(1, N)
+# 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=12,          # 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'))

examples/onnx/large_mlp/input.json

@@ -0,0 +1 @@
+{"input_data": [[0.33088353276252747, -0.8819183707237244, 1.245591163635254, -1.807046890258789, 1.9922369718551636, -0.3360576629638672, 0.4529011845588684, -0.3590165674686432, 0.08356846123933792, 0.5126393437385559, 0.44627535343170166, 1.4916497468948364, 0.49731069803237915, -0.9748706817626953, -0.4923185408115387, 1.3548223972320557, 0.2306872010231018, 1.125955581665039, -1.7063908576965332, 0.3777385354042053, -2.7988760471343994, -1.1846797466278076, 0.7473157048225403, 1.490412950515747, 0.017497723922133446, 2.113945245742798, -1.2141249179840088, -0.16120357811450958, 0.021127669140696526, 0.7207374572753906, -1.369688868522644, -0.7369781732559204, -0.630584180355072, -0.4520200788974762, 0.29123976826667786, 0.6334688067436218, -0.869332492351532, -1.258501648902893, 0.3012596666812897, -0.5507447123527527, 0.669975757598877, 0.15088629722595215, -0.1050339788198471, 0.5505334138870239, -0.1287376880645752, -1.4297826290130615, -0.01703289896249771, -1.2296998500823975, 0.5122153162956238, -0.16924428939819336, -0.415036678314209, -1.1979341506958008, 0.05831022188067436, -0.4411357045173645, 2.0713791847229004, 1.4611141681671143, -0.9357407093048096, -0.333297461271286, -0.676478385925293, 1.390028476715088, -0.05827632546424866, 1.535687804222107, 0.3060210347175598, -0.03171076253056526, -0.614985466003418, 1.2040390968322754, 0.31318482756614685, -1.2134959697723389, 0.13110508024692535, -1.4880926609039307, 1.7007993459701538, 1.5412729978561401, 0.09260450303554535, 0.7649128437042236, -0.5009126663208008, -0.5356241464614868, -0.069572813808918, -0.011717632412910461, 0.21314217150211334, -0.1985170543193817, -0.0223808903247118, 1.2128918170928955, 0.8334696888923645, 1.9029873609542847, -0.11491120606660843, -0.10303237289190292, -0.2467050403356552, 1.557223916053772, -1.1108328104019165, -0.9065343141555786, -0.2271333783864975, 0.6959827542304993, -0.48698121309280396, 0.5689510703086853, 1.115319013595581, -0.8907430768013, -0.24722427129745483, -0.7437837719917297, 0.6742106676101685, -1.7830933332443237]]}