ci: update version string in docs

BREAKING CHANGE: in python the order of arguments for evm related functions has changed

.github/workflows/engine.yml

@@ -87,7 +87,7 @@ jobs:
 
       - 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
+          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:21,maximum:65536,shared:true})}|" pkg/nodejs/ezkl.js
 
       - name: Replace `import.meta.url` with `import.meta.resolve` definition in workerHelpers.js
         run: |
@@ -188,63 +188,3 @@ jobs:
           npm publish
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-
-  in-browser-evm-ver-publish:
-    permissions:
-      contents: read
-      packages: write
-    name: publish-in-browser-evm-verifier-package
-    needs: [publish-wasm-bindings]
-    runs-on: ubuntu-latest
-    env:
-        RELEASE_TAG: ${{ github.ref_name }}
-    if: startsWith(github.ref, 'refs/tags/')
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
-        with:
-          persist-credentials: false
-      - name: Update version in package.json
-        shell: bash
-        run: |
-          sed -i "s|\"version\": \".*\"|\"version\": \"$RELEASE_TAG\"|" in-browser-evm-verifier/package.json
-      - name: Prepare tag and fetch package integrity
-        run: |
-          CLEANED_TAG=${RELEASE_TAG} # 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@eae0cfeb286e66ffb5155f1a79b90583a127a68b  #v2.4.1
-        with:
-          version: 8
-      - name: Set up Node.js
-        uses: actions/setup-node@1a4442cacd436585916779262731d5b162bc6ec7  #v3.8.2
-        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/pypi.yml

@@ -258,7 +258,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
@@ -380,7 +380,7 @@ jobs:
         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 }}

.github/workflows/release.yml

@@ -198,15 +198,15 @@ jobs:
 
       - 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
+        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 asm,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
+        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'

.github/workflows/rust.yml

@@ -24,16 +24,37 @@ jobs:
     permissions:
       contents: read
     runs-on: large-self-hosted
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
           override: true
           components: rustfmt, clippy
-      - uses: baptiste0928/cargo-install@v1
+      - uses: baptiste0928/cargo-install@91c5da15570085bcde6f4d7aed98cb82d6769fd3
         with:
           crate: cargo-nextest
           locked: true
@@ -44,10 +65,31 @@ jobs:
     permissions:
       contents: read
     runs-on: ubuntu-latest
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -60,10 +102,31 @@ jobs:
     permissions:
       contents: read
     runs-on: ubuntu-latest
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -76,10 +139,31 @@ jobs:
     permissions:
       contents: read
     runs-on: ubuntu-latest-32-cores
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -95,7 +179,7 @@ jobs:
       - name: Library tests
         run: cargo nextest run --lib --verbose
       - name: Library tests (original lookup)
-        run: cargo nextest run --lib --verbose --no-default-features --features ezkl
+        run: cargo nextest run --lib --verbose --no-default-features --features ezkl,eth-original-lookup
 
   # ultra-overflow-tests-gpu:
   #   runs-on: GPU
@@ -134,10 +218,31 @@ jobs:
     permissions:
       contents: read
     runs-on: non-gpu
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -155,22 +260,43 @@ jobs:
       # - name: Conv overflow (wasi)
       #   run: cargo wasi test conv_col_ultra_overflow -- --include-ignored --nocapture
       - name: lookup overflow
-        run: cargo nextest run --release lookup_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
+        run: cargo nextest run --release lookup_ultra_overflow --no-capture --no-default-features --features ezkl,eth-original-lookup -- --include-ignored
       - name: Matmul overflow
-        run: RUST_LOG=debug cargo nextest run --release matmul_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
+        run: RUST_LOG=debug cargo nextest run --release matmul_col_ultra_overflow --no-capture --no-default-features --features ezkl,eth-original-lookup -- --include-ignored
       - name: Conv overflow
-        run: RUST_LOG=debug cargo nextest run --release conv_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
+        run: RUST_LOG=debug cargo nextest run --release conv_col_ultra_overflow --no-capture --no-default-features --features ezkl,eth-original-lookup -- --include-ignored
       - name: Conv + relu overflow
-        run: cargo nextest run --release conv_relu_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
+        run: cargo nextest run --release conv_relu_col_ultra_overflow --no-capture --no-default-features --features ezkl,eth-original-lookup -- --include-ignored
 
   ultra-overflow-tests:
     permissions:
       contents: read
     runs-on: non-gpu
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -200,10 +326,31 @@ jobs:
     permissions:
       contents: read
     runs-on: ubuntu-latest-16-cores
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -219,11 +366,32 @@ jobs:
   wasm32-tests:
     permissions:
       contents: read
-    runs-on: non-gpu
+    runs-on: ubuntu-latest-64-cores
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -233,45 +401,53 @@ jobs:
         with:
           # Pin to version 0.12.1
           version: "v0.12.1"
-      - uses: nanasess/setup-chromedriver@e93e57b843c0c92788f22483f1a31af8ee48db25  #v2.3.0
+      - uses: nanasess/setup-chromedriver@affb1ea8848cbb080be372c1e8d7a5c173e9298f  #v2.3.0
         # with:
         #   chromedriver-version: "115.0.5790.102"
       - name: Install wasm32-unknown-unknown
         run: rustup target add wasm32-unknown-unknown
       - name: Add rust-src
         run: rustup component add rust-src --toolchain nightly-2025-02-17-x86_64-unknown-linux-gnu
+      - name: Create webdriver.json to disable timeouts
+        run: |
+          echo '{"args": ["--headless", "--disable-gpu", "--disable-dev-shm-usage", "--no-sandbox"]}' > webdriver.json
       - name: Run wasm verifier tests
-        # on mac:
-        #   AR=/opt/homebrew/opt/llvm/bin/llvm-ar CC=/opt/homebrew/opt/llvm/bin/clang wasm-pack test --firefox --headless -- -Z build-std="panic_abort,std" --features web
-        run: wasm-pack test --chrome --headless -- -Z build-std="panic_abort,std" --features web
-
-  foudry-solidity-tests:
-    permissions:
-      contents: read
-    runs-on: non-gpu
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-        with:
-          persist-credentials: false
-          submodules: recursive
-
-      - name: Install Foundry
-        uses: foundry-rs/foundry-toolchain@v1
-
-      - name: Run tests
-        run: | 
-          cd tests/foundry
-          forge install https://github.com/foundry-rs/forge-std --no-git --no-commit
-          forge test -vvvv --fuzz-runs 64
+        run: |
+          ulimit -n 65536
+          WASM_BINDGEN_TEST_THREADS=1 \
+          WASM_BINDGEN_TEST_TIMEOUT=1800 \
+          CHROMEDRIVER_ARGS="--log-level=INFO" \
+          wasm-pack test --chrome --headless -- -Z build-std="panic_abort,std" --features web -- --nocapture
 
   mock-proving-tests:
     permissions:
       contents: read
     runs-on: non-gpu
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -334,11 +510,32 @@ jobs:
     permissions:
       contents: read
     runs-on: non-gpu
-    needs: [build, library-tests, docs, python-tests, python-integration-tests]
+    # needs: [build, library-tests, docs, python-tests, python-integration-tests]
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -362,52 +559,26 @@ jobs:
           cache: "pnpm"
       - name: "Add rust-src"
         run: rustup component add rust-src --toolchain nightly-2025-02-17-x86_64-unknown-linux-gnu
-      - name: Install dependencies for js tests and in-browser-evm-verifier package
+      - name: Install dependencies for js tests and package
         run: |
           pnpm install --frozen-lockfile
-          pnpm install --dir ./in-browser-evm-verifier --frozen-lockfile
-        env:
-          CI: false
-          NODE_ENV: development
-      - name: Build wasm package for nodejs target.
-        run: |
-          wasm-pack build --target nodejs --out-dir ./in-browser-evm-verifier/nodejs . -- -Z build-std="panic_abort,std"
-      - name: Replace memory definition in nodejs
-        run: |
-          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" in-browser-evm-verifier/nodejs/ezkl.js
-      - name: Build @ezkljs/verify package
-        run: |
-          cd in-browser-evm-verifier
-          pnpm build:commonjs
-          cd ..
       # - name: Install solc
       #   run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
       - name: Install Anvil
         run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
+      - name: Build wasm package for nodejs target.
+        run: |
+          wasm-pack build --target nodejs --out-dir ./tests/wasm/nodejs . -- -Z build-std="panic_abort,std"
+      - name: KZG prove and verify tests (EVM)
+        run: cargo nextest run --verbose "tests_evm::kzg_evm_prove_and_verify_::" --test-threads 1
       - name: KZG prove and verify tests (EVM + reusable verifier + col-overflow)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_prove_and_verify_reusable_verifier --test-threads 1
+        run: cargo nextest run --verbose tests_evm::kzg_evm_prove_and_verify_reusable_verifier --features reusable-verifier --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg all)
         run: cargo nextest run --verbose tests_evm::kzg_evm_kzg_all_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg inputs)
         run: cargo nextest run --verbose tests_evm::kzg_evm_kzg_input_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg params)
         run: cargo nextest run --verbose tests_evm::kzg_evm_kzg_params_prove_and_verify --test-threads 1
-      - name: KZG prove and verify tests (EVM + on chain inputs)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_input_prove_and_verify --test-threads 1
-      - name: KZG prove and verify tests (EVM + on chain outputs)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_output_prove_and_verify --test-threads 1
-      - name: KZG prove and verify tests (EVM + on chain inputs & outputs)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_input_output_prove_and_verify --test-threads 1
-      - name: KZG prove and verify tests (EVM + on chain inputs & kzg outputs + params)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_input_kzg_output_kzg_params_prove_and_verify --test-threads 1
-      - name: KZG prove and verify tests (EVM + on chain outputs & kzg inputs + params)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_output_kzg_input_kzg_params_prove_and_verify --test-threads 1
-      - name: KZG prove and verify tests (EVM + on chain all kzg)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_all_kzg_params_prove_and_verify --test-threads 1
-      - name: KZG prove and verify tests (EVM + on chain inputs & outputs hashes)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_on_chain_input_output_hashed_prove_and_verify --test-threads 1
-      - name: KZG prove and verify tests (EVM)
-        run: cargo nextest run --verbose tests_evm::kzg_evm_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + hashed inputs)
         run: cargo nextest run --verbose tests_evm::kzg_evm_hashed_input_prove_and_verify --test-threads 1
       - name: KZG prove and verify tests (EVM + hashed params)
@@ -454,10 +625,31 @@ jobs:
       contents: read
     runs-on: non-gpu
     needs: [build, library-tests, docs]
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -497,9 +689,6 @@ jobs:
       - name: Build wasm package for nodejs target.
         run: |
           wasm-pack build --target nodejs --out-dir ./tests/wasm/nodejs . -- -Z build-std="panic_abort,std"
-      - name: Replace memory definition in nodejs
-        run: |
-          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" tests/wasm/nodejs/ezkl.js
       - name: KZG prove and verify tests (public outputs + column overflow)
         run: cargo nextest run --verbose tests::kzg_prove_and_verify_with_overflow_::w
       - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
@@ -573,10 +762,31 @@ jobs:
       contents: read
     runs-on: self-hosted
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: dtolnay/rust-toolchain@4f94fbe7e03939b0e674bcc9ca609a16088f63ff  #nightly branch, TODO: update when required
         with:
           toolchain: nightly-2025-02-17
@@ -614,10 +824,31 @@ jobs:
       contents: read
     runs-on: large-self-hosted
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -635,10 +866,31 @@ jobs:
       contents: read
     runs-on: large-self-hosted
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -660,10 +912,31 @@ jobs:
       contents: read
     runs-on: ubuntu-latest-32-cores
     needs: [build, library-tests, docs]
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -681,10 +954,31 @@ jobs:
       contents: read
     runs-on: non-gpu
     needs: [build, library-tests, docs]
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
         with:
           python-version: "3.12"
@@ -702,7 +996,7 @@ jobs:
       - name: Install Anvil
         run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
       - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --profile=test-runs
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings,reusable-verifier --profile=test-runs
       - name: Run pytest
         run: source .env/bin/activate; pip install pytest-asyncio; pytest -vv
 
@@ -711,10 +1005,31 @@ jobs:
       contents: read
     runs-on: non-gpu
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
         with:
           python-version: "3.12"
@@ -730,7 +1045,7 @@ jobs:
       - name: Setup Virtual Env and Install python dependencies
         run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt;
       - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --profile=test-runs
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings,reusable-verifier --profile=test-runs
       - name: Public inputs
         run: source .env/bin/activate; cargo nextest run --verbose tests::accuracy_measurement_public_inputs_
       - name: fixed params
@@ -744,28 +1059,31 @@ jobs:
     permissions:
       contents: read
     runs-on: large-self-hosted
-    services:
-      # Label used to access the service container
-      postgres:
-        # Docker Hub image
-        image: postgres
-        env:
-          POSTGRES_USER: ubuntu
-          POSTGRES_HOST_AUTH_METHOD: trust
-        # Set health checks to wait until postgres has started
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-          -v /var/run/postgresql:/var/run/postgresql
-        ports:
-          # Maps tcp port 5432 on service container to the host
-          - 5432:5432
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
         with:
           python-version: "3.11"
@@ -787,7 +1105,7 @@ jobs:
       - name: Setup Virtual Env and Install python dependencies
         run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt; python -m ensurepip --upgrade
       - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --profile=test-runs
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings,reusable-verifier --profile=test-runs
       - name: Cat and Dog notebook
         run: source .env/bin/activate; cargo nextest run py_tests::tests::cat_and_dog_notebook_
       - name: All notebooks
@@ -798,8 +1116,6 @@ jobs:
         run: source .env/bin/activate; cargo nextest run py_tests::tests::neural_bag_of_words_ --no-capture
       - name: Felt conversion
         run: source .env/bin/activate; cargo nextest run py_tests::tests::felt_conversion_test_ --no-capture
-      - name: Postgres tutorials
-        run: source .env/bin/activate; cargo nextest run py_tests::tests::postgres_ --no-capture
       - name: Tictactoe tutorials
         run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_ --test-threads 1
       # - name: authenticate-kaggle-cli
@@ -814,16 +1130,39 @@ jobs:
       - name: NBEATS tutorial
         run: source .env/bin/activate; cargo nextest run py_tests::tests::nbeats_
       # - name: Reusable verifier tutorial
-      # run: source .env/bin/activate; cargo nextest run py_tests::tests::reusable_
+      # run: source .env/bin/activate; cargo nextest run py_tests::tests::reusable_verifier_ --no-capture
+      - name: Reusable verifier tutorial
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::reusable_verifier_ --no-capture --test-threads 1
 
   ios-integration-tests:
     permissions:
       contents: read
     runs-on: macos-latest
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -842,10 +1181,31 @@ jobs:
     runs-on: macos-latest
     needs: [ios-integration-tests]
 
+    env:
+      EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$EVM_VERIFIER_EZKL_TOKEN" ]; then
+            echo "❌ EVM_VERIFIER_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+          
+          # For libgit2 (what Cargo uses internally)
+          git config --global credential.helper store
+          echo "https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+          
+          # Also set URL replacement with oauth2 format
+          git config --global \
+            url."https://oauth2:${EVM_VERIFIER_EZKL_TOKEN}@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          EVM_VERIFIER_EZKL_TOKEN: ${{ secrets.EVM_VERIFIER_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17

.gitignore

@@ -52,3 +52,5 @@ docs/python/build
 !tests/assets/vk_aggr.key
 cache
 out
+!tests/assets/wasm.code
+!tests/assets/wasm.sol

Cargo.toml

@@ -3,7 +3,7 @@ cargo-features = ["profile-rustflags"]
 [package]
 name = "ezkl"
 version = "0.0.0"
-edition = "2024"
+edition = "2021"
 default-run = "ezkl"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -35,7 +35,9 @@ halo2_wrong_ecc = { git = "https://github.com/zkonduit/halo2wrong", branch = "ac
 snark-verifier = { git = "https://github.com/zkonduit/snark-verifier", branch = "ac/chunked-mv-lookup", features = [
     "derive_serde",
 ] }
-halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier", optional = true }
+halo2_solidity_verifier = { git = "https://github.com/zkonduit/ezkl-verifier", branch = "main", optional = true, features = [
+    "evm",
+] }
 maybe-rayon = { version = "0.1.1", default-features = false }
 bincode = { version = "1.3.3", default-features = false }
 unzip-n = "0.1.2"
@@ -43,10 +45,12 @@ num = "0.4.1"
 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",
@@ -56,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 }
@@ -69,20 +74,18 @@ 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 }
 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 }
@@ -90,9 +93,9 @@ 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 }
 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 }
 # universal bindings
 uniffi = { version = "=0.28.0", optional = true }
 getrandom = { version = "0.2.8", optional = true }
@@ -219,52 +222,54 @@ required-features = ["python-bindings"]
 [features]
 web = ["wasm-bindgen-rayon"]
 default = [
+    "eth-mv-lookup",
     "ezkl",
-    "mv-lookup",
     "precompute-coset",
     "no-banner",
     "parallel-poly-read",
 ]
 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"]
+universal-bindings = [
+    "uniffi",
+    "mv-lookup",
+    "precompute-coset",
+    "parallel-poly-read",
+    "solidity-verifier-mv-lookup",
+]
+logging = ["dep:colored", "dep:env_logger", "dep:chrono"]
+ios-bindings = ["universal-bindings"]
 ios-bindings-test = ["ios-bindings", "uniffi/bindgen-tests"]
 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:tokio-postgres",
-    "dep:pg_bigdecimal",
     "dep:lazy_static",
     "dep:tokio",
     "dep:openssl",
-    "dep:mimalloc",
     "dep:chrono",
     "dep:sha256",
     "dep:clap_complete",
-    "dep:halo2_solidity_verifier",
     "dep:semver",
     "dep:clap",
     "dep:tosubcommand",
+    "logging",
 ]
+eth = ["dep:alloy", "dep:foundry-compilers", "dep:ethabi"]
+solidity-verifier = ["dep:halo2_solidity_verifier"]
+solidity-verifier-mv-lookup = ["halo2_solidity_verifier/mv-lookup"]
+eth-mv-lookup = ["solidity-verifier-mv-lookup", "mv-lookup", "eth"]
+eth-original-lookup = ["eth", "solidity-verifier"]
 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 = []
@@ -274,22 +279,20 @@ no-banner = []
 no-update = []
 macos-metal = ["halo2_proofs/macos"]
 ios-metal = ["halo2_proofs/ios"]
-
-[patch.'https://github.com/zkonduit/halo2']
-halo2_proofs = { git = "https://github.com/zkonduit/halo2#f441c920be45f8f05d2c06a173d82e8885a5ed4d", package = "halo2_proofs" }
-
-[patch.'https://github.com/zkonduit/halo2#0654e92bdf725fd44d849bfef3643870a8c7d50b']
-halo2_proofs = { git = "https://github.com/zkonduit/halo2#f441c920be45f8f05d2c06a173d82e8885a5ed4d", package = "halo2_proofs" }
+jemalloc = ["dep:jemallocator"]
+mimalloc = ["dep:mimalloc"]
+reusable-verifier = []
 
 
 [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"
+# panic = "abort"
 
 
 [profile.test-runs]

README.md

@@ -76,11 +76,6 @@ 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 🔨
 
 #### Rust CLI

abis/DataAttestation.json

@@ -1,312 +0,0 @@
-[
-    {
-        "inputs": [
-            {
-                "internalType": "address",
-                "name": "_contractAddresses",
-                "type": "address"
-            },
-            {
-                "internalType": "bytes",
-                "name": "_callData",
-                "type": "bytes"
-            },
-            {
-                "internalType": "uint256[]",
-                "name": "_decimals",
-                "type": "uint256[]"
-            },
-            {
-                "internalType": "uint256[]",
-                "name": "_bits",
-                "type": "uint256[]"
-            },
-            {
-                "internalType": "uint8",
-                "name": "_instanceOffset",
-                "type": "uint8"
-            }
-        ],
-        "stateMutability": "nonpayable",
-        "type": "constructor"
-    },
-    {
-        "inputs": [],
-        "name": "HALF_ORDER",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "ORDER",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "uint256[]",
-                "name": "instances",
-                "type": "uint256[]"
-            }
-        ],
-        "name": "attestData",
-        "outputs": [],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "callData",
-        "outputs": [
-            {
-                "internalType": "bytes",
-                "name": "",
-                "type": "bytes"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "contractAddress",
-        "outputs": [
-            {
-                "internalType": "address",
-                "name": "",
-                "type": "address"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "bytes",
-                "name": "encoded",
-                "type": "bytes"
-            }
-        ],
-        "name": "getInstancesCalldata",
-        "outputs": [
-            {
-                "internalType": "uint256[]",
-                "name": "instances",
-                "type": "uint256[]"
-            }
-        ],
-        "stateMutability": "pure",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "bytes",
-                "name": "encoded",
-                "type": "bytes"
-            }
-        ],
-        "name": "getInstancesMemory",
-        "outputs": [
-            {
-                "internalType": "uint256[]",
-                "name": "instances",
-                "type": "uint256[]"
-            }
-        ],
-        "stateMutability": "pure",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "uint256",
-                "name": "index",
-                "type": "uint256"
-            }
-        ],
-        "name": "getScalars",
-        "outputs": [
-            {
-                "components": [
-                    {
-                        "internalType": "uint256",
-                        "name": "decimals",
-                        "type": "uint256"
-                    },
-                    {
-                        "internalType": "uint256",
-                        "name": "bits",
-                        "type": "uint256"
-                    }
-                ],
-                "internalType": "struct DataAttestation.Scalars",
-                "name": "",
-                "type": "tuple"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [],
-        "name": "instanceOffset",
-        "outputs": [
-            {
-                "internalType": "uint8",
-                "name": "",
-                "type": "uint8"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "uint256",
-                "name": "x",
-                "type": "uint256"
-            },
-            {
-                "internalType": "uint256",
-                "name": "y",
-                "type": "uint256"
-            },
-            {
-                "internalType": "uint256",
-                "name": "denominator",
-                "type": "uint256"
-            }
-        ],
-        "name": "mulDiv",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "result",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "pure",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "int256",
-                "name": "x",
-                "type": "int256"
-            },
-            {
-                "components": [
-                    {
-                        "internalType": "uint256",
-                        "name": "decimals",
-                        "type": "uint256"
-                    },
-                    {
-                        "internalType": "uint256",
-                        "name": "bits",
-                        "type": "uint256"
-                    }
-                ],
-                "internalType": "struct DataAttestation.Scalars",
-                "name": "_scalars",
-                "type": "tuple"
-            }
-        ],
-        "name": "quantizeData",
-        "outputs": [
-            {
-                "internalType": "int256",
-                "name": "quantized_data",
-                "type": "int256"
-            }
-        ],
-        "stateMutability": "pure",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "address",
-                "name": "target",
-                "type": "address"
-            },
-            {
-                "internalType": "bytes",
-                "name": "data",
-                "type": "bytes"
-            }
-        ],
-        "name": "staticCall",
-        "outputs": [
-            {
-                "internalType": "bytes",
-                "name": "",
-                "type": "bytes"
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function"
-    },
-    {
-        "inputs": [
-            {
-                "internalType": "int256",
-                "name": "x",
-                "type": "int256"
-            }
-        ],
-        "name": "toFieldElement",
-        "outputs": [
-            {
-                "internalType": "uint256",
-                "name": "field_element",
-                "type": "uint256"
-            }
-        ],
-        "stateMutability": "pure",
-        "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

@@ -68,7 +68,7 @@ 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],

benches/accum_dot.rs

@@ -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::Einsum {
                             equation: "i,i->".to_string(),
                         }),

benches/accum_einsum_matmul.rs

@@ -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;
@@ -61,7 +62,7 @@ impl Circuit<Fr> for MyCircuit {
                 config
                     .layout(
                         &mut region,
-                        &self.inputs,
+                        &self.inputs.iter().collect_vec(),
                         Box::new(PolyOp::Einsum {
                             equation: "ab,bc->ac".to_string(),
                         }),

benches/accum_matmul_sigmoid.rs

@@ -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();

benches/accum_matmul_sigmoid_overflow.rs

@@ -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();

benches/accum_sum.rs

@@ -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();

benches/accum_sumpool.rs

@@ -63,7 +63,7 @@ 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],

benches/pairwise_add.rs

@@ -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(())
             },

benches/pairwise_pow.rs

@@ -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(())
             },

benches/relu_lookupless.rs

@@ -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,

benches/sigmoid.rs

@@ -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();

contracts/AttestData.sol

@@ -1,397 +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
-    ) public 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))
-        }
-        if (funcSig == 0xaf83a18d) {
-            instances_offset = 0x64;
-        } else if (funcSig == 0x1e8e1e13) {
-            instances_offset = 0x44;
-        } else {
-            revert("Invalid function signature");
-        }
-        assembly {
-            // 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, instances_offset))
-
-            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))
-                )
-            }
-        }
-        require(
-            funcSig == 0xaf83a18d || funcSig == 0x1e8e1e13,
-            "Invalid function signature"
-        );
-    }
-    /**
-     * @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
-    ) public 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)
-        }
-        if (funcSig == 0xaf83a18d) {
-            instances_offset = 0x44;
-        } else if (funcSig == 0x1e8e1e13) {
-            instances_offset = 0x24;
-        } else {
-            revert("Invalid function signature");
-        }
-        // We need to create a new assembly block in order for solidity
-        // to cast the funcSig to a bytes4 type. Otherwise it will load the entire first 32 bytes of the calldata
-        // within the block
-        assembly {
-            // 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, instances_offset)
-            )
-
-            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"1234";
-
-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)
-        }
-        if (funcSig == 0xaf83a18d) {
-            proof_offset = 0x24;
-        } else if (funcSig == 0x1e8e1e13) {
-            proof_offset = 0x04;
-        } else {
-            revert("Invalid function signature");
-        }
-        assembly {
-            // 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, proof_offset))
-
-            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) {
-                    break
-                }
-            }
-        }
-
-        return equal; // Return true if the commitment comparison passed
-    } /// end checkKzgCommits
-}
-
-contract DataAttestation is LoadInstances, SwapProofCommitments {
-    // the address of the account to make calls to
-    address public immutable contractAddress;
-
-    // the abi encoded function calls to make to the `contractAddress` that returns the attested to data
-    bytes public callData;
-
-    struct Scalars {
-        // The number of base 10 decimals to scale the data by.
-        // For most ERC20 tokens this is 1e18
-        uint256 decimals;
-        // The number of fractional bits of the fixed point EZKL data points.
-        uint256 bits;
-    }
-
-    Scalars[] private scalars;
-
-    function getScalars(uint256 index) public view returns (Scalars memory) {
-        return scalars[index];
-    }
-
-    /**
-     * @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 public constant ORDER =
-        uint256(
-            0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
-        );
-
-    uint256 public constant HALF_ORDER = ORDER >> 1;
-
-    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[] memory _decimals,
-        uint[] memory _bits,
-        uint8 _instanceOffset
-    ) {
-        require(
-            _bits.length == _decimals.length,
-            "Invalid scalar array lengths"
-        );
-        for (uint i; i < _bits.length; i++) {
-            scalars.push(Scalars(10 ** _decimals[i], 1 << _bits[i]));
-        }
-        contractAddress = _contractAddresses;
-        callData = _callData;
-        instanceOffset = _instanceOffset;
-    }
-
-    function mulDiv(
-        uint256 x,
-        uint256 y,
-        uint256 denominator
-    ) public 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 _scalars - The scaling factors for the data returned from the account calls.
-     *
-     */
-    function quantizeData(
-        int x,
-        Scalars memory _scalars
-    ) public pure returns (int256 quantized_data) {
-        if (_scalars.bits == 1 && _scalars.decimals == 1) {
-            return x;
-        }
-        bool neg = x < 0;
-        if (neg) x = -x;
-        uint output = mulDiv(uint256(x), _scalars.bits, _scalars.decimals);
-        if (
-            mulmod(uint256(x), _scalars.bits, _scalars.decimals) * 2 >=
-            _scalars.decimals
-        ) {
-            output += 1;
-        }
-        if (output > HALF_ORDER) {
-            revert("Overflow field modulus");
-        }
-        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
-    ) public 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
-    ) public 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) public view {
-        bytes memory returnData = staticCall(contractAddress, callData);
-        int256[] memory x = abi.decode(returnData, (int256[]));
-        int output;
-        uint fieldElement;
-        for (uint i = 0; i < x.length; i++) {
-            output = quantizeData(x[i], scalars[i]);
-            fieldElement = toFieldElement(output);
-            if (fieldElement != instances[i]) {
-                revert("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));
-        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/python/src/conf.py

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

examples/conv2d_mnist/main.rs

@@ -32,7 +32,6 @@ use mnist::*;
 use rand::rngs::OsRng;
 use std::marker::PhantomData;
 
-
 mod params;
 
 const K: usize = 20;
@@ -216,11 +215,7 @@ where
                         .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();
@@ -229,7 +224,7 @@ where
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x.unwrap()],
+                            &[&x.unwrap()],
                             Box::new(PolyOp::LeakyReLU {
                                 slope: 0.0.into(),
                                 scale: 1,
@@ -241,7 +236,7 @@ where
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x.unwrap()],
+                            &[&x.unwrap()],
                             Box::new(LookupOp::Div { denom: 32.0.into() }),
                         )
                         .unwrap()
@@ -253,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(),
                             }),
@@ -265,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.ipynb

@@ -904,7 +904,7 @@
             "outputs": [],
             "source": [
                 "\n",
-                "res = await ezkl.calibrate_settings(\"input.json\", target=\"resources\", scales = [4])\n",
+                "res = ezkl.calibrate_settings(\"input.json\", target=\"resources\", scales = [4])\n",
                 "assert res == True\n",
                 "print(\"verified\")\n"
             ]
@@ -954,7 +954,7 @@
             "source": [
                 "\n",
                 "\n",
-                "res = await ezkl.gen_witness()\n"
+                "res = ezkl.gen_witness()\n"
             ]
         },
         {
@@ -1088,7 +1088,7 @@
                 "\n",
                 "res = await ezkl.deploy_evm(\n",
                 "    address_path,\n",
-                "    rpc_url='http://127.0.0.1:3030'\n",
+                "    'http://127.0.0.1:3030'\n",
                 ")\n",
                 "\n",
                 "assert res == True\n",
@@ -1142,4 +1142,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 2
-}
+}

examples/notebooks/data_attest.ipynb

@@ -1,589 +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 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": [
-                "await ezkl.setup_test_evm_data(\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,660 +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",
-                "    print(f'poseidon_hash: {res[\"processed_outputs\"][\"poseidon_hash\"]}')\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",
-                "        function getArr() public view returns (uint[] memory) {\n",
-                "            return arr;\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 = contract.functions.getArr().build_transaction()['data'][2:]\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",
-                "    decimals = [0] * len(data)\n",
-                "    call_to_account = {\n",
-                "        'call_data': calldata,\n",
-                "        'decimals': decimals,\n",
-                "        'address': contract.address[2:], # remove the '0x' prefix\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",
-                "call_to_account = test_on_chain_data(res)\n",
-                "\n",
-                "data = dict(input_data = [data_array], output_data =  {'rpc': RPC_URL, 'call': call_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": ".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/data_attest_kzg_vis.ipynb

@@ -1,592 +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 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\": 3 // 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": [
-                "await ezkl.setup_test_evm_data(\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)"
-            ]
-        },
-        {
-            "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": [
-                "# 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)"
-            ]
-        },
-        {
-            "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. "
-            ]
-        },
-        {
-            "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": ".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/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)"
             ]
         },

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)"
       ]
     },
@@ -736,4 +736,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 0
-}
+}

examples/notebooks/gcn.ipynb

@@ -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)"
       ]
     },

examples/notebooks/generalized_inverse.ipynb

@@ -196,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"
       ]
     },
@@ -237,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)"
       ]
     },
@@ -341,4 +341,4 @@
   },
   "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)"
             ]
         },

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)"
             ]
         },
         {
@@ -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)"
             ]
         },

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)"
             ]
         },

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"
             ]
         },
         {
@@ -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)"
             ]
         },

examples/notebooks/linear_regression.ipynb

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

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)"
             ]
         },

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)"
             ]
         },
@@ -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)"
             ]
         },

examples/notebooks/mean_postgres.ipynb

@@ -1,462 +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",
-    "run_args = ezkl.PyRunArgs()\n",
-    "run_args.decomp_legs = 4\n",
-    "\n",
-    "# Generate settings using ezkl\n",
-    "res = ezkl.gen_settings(onnx_filename, settings_filename, py_run_args=run_args)\n",
-    "\n",
-    "assert res == True\n",
-    "\n",
-    "res = await ezkl.calibrate_settings(input_filename, onnx_filename, settings_filename, \"resources\")\n",
-    "\n",
-    "assert res == True\n",
-    "\n",
-    "await ezkl.get_srs(settings_filename)"
-   ]
-  },
-  {
-   "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": ".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.12.7"
-  }
- },
- "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)"
       ]
     },
@@ -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)"
             ]
         },
@@ -425,4 +425,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 2
-}
+}

examples/notebooks/mnist_gan_proof_splitting.ipynb

@@ -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",
@@ -484,4 +484,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 2
-}
+}

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)"
             ]
         },
@@ -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)"
             ]
         },
@@ -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)"
       ]
     },

examples/notebooks/proof_splitting.ipynb

@@ -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",
@@ -472,4 +472,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 2
-}
+}

examples/notebooks/random_forest.ipynb

@@ -176,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\")"
             ]
         },
         {
@@ -210,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)"
             ]
         },
@@ -309,4 +309,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 5
-}
+}

examples/notebooks/reusable_verifier.ipynb

@@ -1,330 +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": [
-    "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, \"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",
+                "    # 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

@@ -231,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)"
       ]
     },
@@ -267,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)"
       ]
     },
@@ -312,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)"
       ]
     },

examples/notebooks/simple_demo_aggregated_proofs.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)"
             ]
         },
@@ -404,4 +404,4 @@
     },
     "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)"
             ]
         },
@@ -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)"
             ]
         },
@@ -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)"
             ]
         },
@@ -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)"
             ]
         },

examples/notebooks/solvency.ipynb

@@ -298,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",
@@ -412,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",

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)"
             ]
         },

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)"
             ]
         },
@@ -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)"
             ]
         },
         {
@@ -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)"
             ]
         },
         {
@@ -647,4 +647,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 4
-}
+}

examples/notebooks/univ3-da.ipynb

@@ -1,685 +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": 1,
-            "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": 2,
-            "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": 3,
-            "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": 4,
-            "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": 5,
-            "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.decomp_legs=5\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",
-                "        \"call\": {\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",
-                "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",
-                "w3 = Web3(HTTPProvider(RPC_URL)) \n",
-                "\n",
-                "def on_chain_data(tensor):\n",
-                "    data = tensor.view(-1).tolist()\n",
-                "    secondsAgo = [len(data) - 1 - i for i in range(len(data))]\n",
-                "\n",
-                "    contract_source_code = '''\n",
-                "    // SPDX-License-Identifier: MIT\n",
-                "    pragma solidity ^0.8.20;\n",
-                "\n",
-                "    interface IUniswapV3PoolDerivedState {\n",
-                "        function observe(\n",
-                "            uint32[] calldata secondsAgos\n",
-                "        ) external view returns (\n",
-                "            int56[] memory tickCumulatives,\n",
-                "            uint160[] memory secondsPerLiquidityCumulativeX128s\n",
-                "        );\n",
-                "    }\n",
-                "\n",
-                "    contract UniTickAttestor {\n",
-                "        int256[] private cachedTicks;\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",
-                "        function cache_price(\n",
-                "            IUniswapV3PoolDerivedState pool,\n",
-                "            uint32[] memory secondsAgo\n",
-                "        ) public {\n",
-                "            (int56[] memory _ticks,) = pool.observe(secondsAgo);\n",
-                "            cachedTicks = new int256[](_ticks.length);\n",
-                "            for (uint256 i = 0; i < _ticks.length; i++) {\n",
-                "                cachedTicks[i] = int256(_ticks[i]);\n",
-                "            }\n",
-                "        }\n",
-                "\n",
-                "        function readPriceCache() public view returns (int256[] memory) {\n",
-                "            return cachedTicks;\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",
-                "    bytecode = compiled_sol['contracts']['UniTickAttestor.sol']['UniTickAttestor']['evm']['bytecode']['object']\n",
-                "    abi = json.loads(compiled_sol['contracts']['UniTickAttestor.sol']['UniTickAttestor']['metadata'])['output']['abi']\n",
-                "\n",
-                "    # Deploy 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",
-                "    contract = w3.eth.contract(address=tx_receipt['contractAddress'], abi=abi)\n",
-                "\n",
-                "    # Step 4: Store data via cache_price transaction\n",
-                "    tx_hash = contract.functions.cache_price(\n",
-                "        \"0xC6962004f452bE9203591991D15f6b388e09E8D0\",\n",
-                "        secondsAgo\n",
-                "    ).transact()\n",
-                "    tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)\n",
-                "\n",
-                "    # Step 5: Prepare calldata for readPriceCache\n",
-                "    call = contract.functions.readPriceCache().build_transaction()\n",
-                "    calldata = call['data'][2:]\n",
-                "\n",
-                "    # Get stored data\n",
-                "    result = contract.functions.readPriceCache().call()\n",
-                "    print(f'Cached ticks: {result}')\n",
-                "\n",
-                "    decimals = [0] * len(data)\n",
-                "\n",
-                "    call_to_account = {\n",
-                "        'call_data': calldata,\n",
-                "        'decimals': decimals,\n",
-                "        'address': contract.address[2:],\n",
-                "    }\n",
-                "\n",
-                "    return call_to_account\n",
-                "\n",
-                "start_anvil()\n",
-                "call_to_account = on_chain_data(x)\n",
-                "\n",
-                "data = dict(input_data =  {'rpc': RPC_URL, 'call': call_to_account })\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",
-                "# 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)"
       ]
     },
@@ -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)"
             ]
         },
@@ -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,539 +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_data(\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": "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": ".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": 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)"
             ]
         },

examples/onnx/multihead_attention/gen.py

@@ -104,5 +104,5 @@ json.dump(data, open("input.json", 'w'))
 # ezkl.gen_settings("network.onnx", "settings.json")
 
 # !RUST_LOG = full
-# res = await ezkl.calibrate_settings(
+# res = ezkl.calibrate_settings(
 #     "input.json", "network.onnx", "settings.json", "resources")

ezkl.pyi

@@ -160,30 +160,6 @@ def compile_circuit(model:str | os.PathLike | pathlib.Path,compiled_circuit:str
     """
     ...
 
-def create_evm_data_attestation(input_data:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path,sol_code_path:str | os.PathLike | pathlib.Path,abi_path:str | os.PathLike | pathlib.Path,witness_path:typing.Optional[str | os.PathLike | pathlib.Path]) -> typing.Any:
-    r"""
-    Creates an EVM compatible data attestation verifier, you will need solc installed in your environment to run this
-    
-    Arguments
-    ---------
-    input_data: str
-        The path to the .json data file, which should contain the necessary calldata and account addresses needed to read from all the on-chain view functions that return the data that the network ingests as inputs
-    
-    settings_path: str
-        The path to the settings file
-    
-    sol_code_path: str
-        The path to the create the solidity verifier
-    
-    abi_path: str
-        The path to create the ABI for the solidity verifier
-    
-    Returns
-    -------
-    bool
-    """
-    ...
-
 def create_evm_verifier(vk_path:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path,sol_code_path:str | os.PathLike | pathlib.Path,abi_path:str | os.PathLike | pathlib.Path,srs_path:typing.Optional[str | os.PathLike | pathlib.Path],reusable:bool) -> typing.Any:
     r"""
     Creates an EVM compatible verifier, you will need solc installed in your environment to run this
@@ -247,7 +223,7 @@ def create_evm_verifier_aggr(aggregation_settings:typing.Sequence[str | os.PathL
     """
     ...
 
-def create_evm_vka(vk_path:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path,sol_code_path:str | os.PathLike | pathlib.Path,abi_path:str | os.PathLike | pathlib.Path,srs_path:typing.Optional[str | os.PathLike | pathlib.Path]) -> typing.Any:
+def create_evm_vka(vk_path:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path,vka_path:str | os.PathLike | pathlib.Path,srs_path:typing.Optional[str | os.PathLike | pathlib.Path]) -> typing.Any:
     r"""
     Creates an Evm VK artifact. This command generated a VK with circuit specific meta data encoding in memory for use by the reusable H2 verifier.
     This is useful for deploying verifier that were otherwise too big to fit on chain and required aggregation.
@@ -260,8 +236,8 @@ def create_evm_vka(vk_path:str | os.PathLike | pathlib.Path,settings_path:str |
     settings_path: str
         The path to the settings file
     
-    sol_code_path: str
-        The path to the create the solidity verifying key.
+    vka_path: str
+        The path to the create the vka calldata.
     
     abi_path: str
         The path to create the ABI for the solidity verifier
@@ -275,12 +251,6 @@ def create_evm_vka(vk_path:str | os.PathLike | pathlib.Path,settings_path:str |
     """
     ...
 
-def deploy_da_evm(addr_path:str | os.PathLike | pathlib.Path,input_data:str | os.PathLike | pathlib.Path,settings_path:str | os.PathLike | pathlib.Path,sol_code_path:str | os.PathLike | pathlib.Path,rpc_url:typing.Optional[str],optimizer_runs:int,private_key:typing.Optional[str]) -> typing.Any:
-    r"""
-    deploys the solidity da verifier
-    """
-    ...
-
 def deploy_evm(addr_path:str | os.PathLike | pathlib.Path,sol_code_path:str | os.PathLike | pathlib.Path,rpc_url:typing.Optional[str],contract_type:str,optimizer_runs:int,private_key:typing.Optional[str]) -> typing.Any:
     r"""
     deploys the solidity verifier
@@ -706,35 +676,6 @@ def setup_aggregate(sample_snarks:typing.Sequence[str | os.PathLike | pathlib.Pa
     """
     ...
 
-def setup_test_evm_data(data_path:str | os.PathLike | pathlib.Path,compiled_circuit_path:str | os.PathLike | pathlib.Path,test_data:str | os.PathLike | pathlib.Path,input_source:PyTestDataSource,output_source:PyTestDataSource,rpc_url:typing.Optional[str]) -> typing.Any:
-    r"""
-    Setup test evm data
-    
-    Arguments
-    ---------
-    data_path: str
-        The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
-    
-    compiled_circuit_path: str
-        The path to the compiled model file (generated using the compile-circuit command)
-    
-    test_data: str
-        For testing purposes only. The optional path to the .json data file that will be generated that contains the OnChain data storage information derived from the file information in the data .json file. Should include both the network input (possibly private) and the network output (public input to the proof)
-    
-    input_sources: str
-        Where the input data comes from
-    
-    output_source: str
-        Where the output data comes from
-    
-    rpc_url: str
-        RPC URL for an EVM compatible node, if None, uses Anvil as a local RPC node
-    
-    Returns
-    -------
-    bool
-    """
-    ...
 
 def swap_proof_commitments(proof_path:str | os.PathLike | pathlib.Path,witness_path:str | os.PathLike | pathlib.Path) -> None:
     r"""
@@ -823,7 +764,7 @@ def verify_aggr(proof_path:str | os.PathLike | pathlib.Path,vk_path:str | os.Pat
     """
     ...
 
-def verify_evm(addr_verifier:str,proof_path:str | os.PathLike | pathlib.Path,rpc_url:typing.Optional[str],addr_da:typing.Optional[str],addr_vk:typing.Optional[str]) -> typing.Any:
+def verify_evm(addr_verifier:str,proof_path:str | os.PathLike | pathlib.Path,rpc_url:typing.Optional[str],vka_path:typing.Optional[str]) -> typing.Any:
     r"""
     verifies an evm compatible proof, you will need solc installed in your environment to run this
     
@@ -838,11 +779,8 @@ def verify_evm(addr_verifier:str,proof_path:str | os.PathLike | pathlib.Path,rpc
     rpc_url: str
         RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
     
-    addr_da: str
-        does the verifier use data attestation ?
-    
-    addr_vk: str
-        The addess of the separate VK contract (if the verifier key is rendered as a separate contract)
+    vka_path: str
+        The path to the VKA calldata bytes file (generated using the create_evm_vka command)
     Returns
     -------
     bool

in-browser-evm-verifier/README.md

@@ -1,60 +0,0 @@
-# inbrowser-evm-verify
-
-We would like the Solidity verifier to be canonical and usually all you ever need. For this, we need to be able to run that verifier in browser.
-
-## How to use (Node js)
-
-```ts 
-import localEVMVerify from '@ezkljs/verify';
-
-// Load in the proof file as a buffer
-const proofFileBuffer = fs.readFileSync(`${path}/${example}/proof.pf`)
-
-// Stringified EZKL evm verifier bytecode (this is just an example don't use in production)
-const bytecode = '0x608060405234801561001057600080fd5b5060d38061001f6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063cfae321714610046575b600080fd5b6100496100f1565b60405161005691906100f1565b60405180910390f35b'
-
-const result = await localEVMVerify(proofFileBuffer, bytecode)
-
-console.log('result', result)
-```
-
-**Note**: Run `ezkl create-evm-verifier` to get the Solidity verifier, with which you can retrieve the bytecode once compiled. We recommend compiling to the Shanghai hardfork target, else you will have to pass an additional parameter specifying the EVM version to the `localEVMVerify` function like so (for Paris hardfork):
-
-```ts
-import localEVMVerify, { hardfork } from '@ezkljs/verify';
-
-const result = await localEVMVerify(proofFileBuffer, bytecode, hardfork['Paris'])
-```
-
-**Note**: You can also verify separated vk verifiers using the `localEVMVerify` function. Just pass the vk verifier bytecode as the third parameter like so:
-```ts
-import localEVMVerify from '@ezkljs/verify';
-
-const result = await localEVMVerify(proofFileBuffer, verifierBytecode, VKBytecode)
-```
-
-
-## How to use (Browser)
-
-```ts
-import localEVMVerify from '@ezkljs/verify';
-
-// Load in the proof file as a buffer using the web apis (fetch, FileReader, etc)
-// We use fetch in this example to load the proof file as a buffer
-const proofFileBuffer = await fetch(`${path}/${example}/proof.pf`).then(res => res.arrayBuffer())
-
-// Stringified EZKL evm verifier bytecode (this is just an example don't use in production)
-const bytecode = '0x608060405234801561001057600080fd5b5060d38061001f6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063cfae321714610046575b600080fd5b6100496100f1565b60405161005691906100f1565b60405180910390f35b'
-
-const result = await browserEVMVerify(proofFileBuffer, bytecode)
-
-console.log('result', result)
-```
-
-Output:
-
-```ts  
-result: true
-```
-
-

in-browser-evm-verifier/package.json

@@ -1,42 +0,0 @@
-{
-  "name": "@ezkljs/verify",
-  "version": "v10.4.2",
-  "publishConfig": {
-    "access": "public"
-  },
-  "description": "Evm verify EZKL proofs in the browser.",
-  "main": "dist/commonjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/commonjs/index.d.ts",
-  "files": [
-    "dist",
-    "LICENSE",
-    "README.md"
-  ],
-  "scripts": {
-    "clean": "rm -r dist || true",
-    "build:commonjs": "tsc --project tsconfig.commonjs.json && resolve-tspaths -p tsconfig.commonjs.json",
-    "build:esm": "tsc --project tsconfig.esm.json && resolve-tspaths -p tsconfig.esm.json",
-    "build": "npm run clean && npm run build:commonjs && npm run build:esm"
-  },
-  "dependencies": {
-    "@ethereumjs/common": "4.0.0",
-    "@ethereumjs/evm": "2.0.0",
-    "@ethereumjs/statemanager": "2.0.0",
-    "@ethereumjs/tx": "5.0.0",
-    "@ethereumjs/util": "9.0.0",
-    "@ethereumjs/vm": "7.0.0",
-    "@ethersproject/abi": "5.7.0",
-    "@ezkljs/engine": "10.4.2",
-    "ethers": "6.7.1",
-    "json-bigint": "1.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.8.3",
-    "ts-loader": "^9.5.0",
-    "ts-node": "^10.9.1",
-    "resolve-tspaths": "^0.8.16",
-    "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.2.2"
-  }
-}

in-browser-evm-verifier/src/index.ts

@@ -1,144 +0,0 @@
-import { defaultAbiCoder as AbiCoder } from '@ethersproject/abi'
-import { Address, hexToBytes } from '@ethereumjs/util'
-import { Chain, Common, Hardfork } from '@ethereumjs/common'
-import { LegacyTransaction, LegacyTxData } from '@ethereumjs/tx'
-// import { DefaultStateManager } from '@ethereumjs/statemanager'
-// import { Blockchain } from '@ethereumjs/blockchain'
-import { VM } from '@ethereumjs/vm'
-import { EVM } from '@ethereumjs/evm'
-import { buildTransaction, encodeDeployment } from './utils/tx-builder'
-import { getAccountNonce, insertAccount } from './utils/account-utils'
-import { encodeVerifierCalldata } from '../nodejs/ezkl';
-
-async function deployContract(
-  vm: VM,
-  common: Common,
-  senderPrivateKey: Uint8Array,
-  deploymentBytecode: string
-): Promise<Address> {
-  // Contracts are deployed by sending their deployment bytecode to the address 0
-  // The contract params should be abi-encoded and appended to the deployment bytecode.
-  // const data =
-  const data = encodeDeployment(deploymentBytecode)
-  const txData = {
-    data,
-    nonce: await getAccountNonce(vm, senderPrivateKey),
-  }
-
-  const tx = LegacyTransaction.fromTxData(
-    buildTransaction(txData) as LegacyTxData,
-    { common, allowUnlimitedInitCodeSize: true },
-  ).sign(senderPrivateKey)
-
-  const deploymentResult = await vm.runTx({
-    tx,
-    skipBlockGasLimitValidation: true,
-    skipNonce: true
-  })
-
-  if (deploymentResult.execResult.exceptionError) {
-    throw deploymentResult.execResult.exceptionError
-  }
-
-  return deploymentResult.createdAddress!
-}
-
-async function verify(
-  vm: VM,
-  contractAddress: Address,
-  caller: Address,
-  proof: Uint8Array | Uint8ClampedArray,
-  vkAddress?: Address | Uint8Array,
-): Promise<boolean> {
-  if (proof instanceof Uint8Array) {
-    proof = new Uint8ClampedArray(proof.buffer)
-  }
-  if (vkAddress) {
-    const vkAddressBytes = hexToBytes(vkAddress.toString())
-    const vkAddressArray = Array.from(vkAddressBytes)
-
-    let string = JSON.stringify(vkAddressArray)
-
-    const uint8Array = new TextEncoder().encode(string);
-
-    // Step 3: Convert to Uint8ClampedArray
-    vkAddress = new Uint8Array(uint8Array.buffer);
-
-    // convert uitn8array of length
-    console.error('vkAddress', vkAddress)
-  }
-  const data = encodeVerifierCalldata(proof, vkAddress)
-
-  const verifyResult = await vm.evm.runCall({
-    to: contractAddress,
-    caller: caller,
-    origin: caller, // The tx.origin is also the caller here
-    data: data,
-  })
-
-  if (verifyResult.execResult.exceptionError) {
-    throw verifyResult.execResult.exceptionError
-  }
-
-  const results = AbiCoder.decode(['bool'], verifyResult.execResult.returnValue)
-
-  return results[0]
-}
-
-/**
- * Spins up an ephemeral EVM instance for executing the bytecode of a solidity verifier
- * @param proof Json serialized proof file
- * @param bytecode The bytecode of a compiled solidity verifier.
- * @param bytecode_vk The bytecode of a contract that stores the vk. (Optional, only required if the vk is stored in a separate contract)
- * @param evmVersion The evm version to use for the verification. (Default: London)
- * @returns The result of the evm verification.
- * @throws If the verify transaction reverts
- */
-export default async function localEVMVerify(
-  proof: Uint8Array | Uint8ClampedArray,
-  bytecode_verifier: string,
-  bytecode_vk?: string,
-  evmVersion?: Hardfork,
-): Promise<boolean> {
-  try {
-    const hardfork = evmVersion ? evmVersion : Hardfork['Shanghai']
-    const common = new Common({ chain: Chain.Mainnet, hardfork })
-    const accountPk = hexToBytes(
-      '0xe331b6d69882b4cb4ea581d88e0b604039a3de5967688d3dcffdd2270c0fd109', // anvil deterministic Pk 
-    )
-
-    const evm = new EVM({
-      allowUnlimitedContractSize: true,
-      allowUnlimitedInitCodeSize: true,
-    })
-
-    const vm = await VM.create({ common, evm })
-    const accountAddress = Address.fromPrivateKey(accountPk)
-
-    await insertAccount(vm, accountAddress)
-
-    const verifierAddress = await deployContract(
-      vm,
-      common,
-      accountPk,
-      bytecode_verifier
-    )
-
-    if (bytecode_vk) {
-      const accountPk = hexToBytes("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"); // anvil deterministic Pk
-      const accountAddress = Address.fromPrivateKey(accountPk)
-      await insertAccount(vm, accountAddress)
-      const output = await deployContract(vm, common, accountPk, bytecode_vk)
-      const result = await verify(vm, verifierAddress, accountAddress, proof, output)
-      return true
-    }
-
-    const result = await verify(vm, verifierAddress, accountAddress, proof)
-
-    return result
-  } catch (error) {
-    // log or re-throw the error, depending on your needs
-    console.error('An error occurred:', error)
-    throw error
-  }
-}

in-browser-evm-verifier/src/utils/account-utils.ts

@@ -1,32 +0,0 @@
-import { VM } from '@ethereumjs/vm'
-import { Account, Address } from '@ethereumjs/util'
-
-export const keyPair = {
-  secretKey:
-    '0x3cd7232cd6f3fc66a57a6bedc1a8ed6c228fff0a327e169c2bcc5e869ed49511',
-  publicKey:
-    '0x0406cc661590d48ee972944b35ad13ff03c7876eae3fd191e8a2f77311b0a3c6613407b5005e63d7d8d76b89d5f900cde691497688bb281e07a5052ff61edebdc0',
-}
-
-export const insertAccount = async (vm: VM, address: Address) => {
-  const acctData = {
-    nonce: 0,
-    balance: BigInt('1000000000000000000'), // 1 eth
-  }
-  const account = Account.fromAccountData(acctData)
-
-  await vm.stateManager.putAccount(address, account)
-}
-
-export const getAccountNonce = async (
-  vm: VM,
-  accountPrivateKey: Uint8Array,
-) => {
-  const address = Address.fromPrivateKey(accountPrivateKey)
-  const account = await vm.stateManager.getAccount(address)
-  if (account) {
-    return account.nonce
-  } else {
-    return BigInt(0)
-  }
-}

in-browser-evm-verifier/src/utils/tx-builder.ts

@@ -1,59 +0,0 @@
-import { Interface, defaultAbiCoder as AbiCoder } from '@ethersproject/abi'
-import {
-  AccessListEIP2930TxData,
-  FeeMarketEIP1559TxData,
-  TxData,
-} from '@ethereumjs/tx'
-
-type TransactionsData =
-  | TxData
-  | AccessListEIP2930TxData
-  | FeeMarketEIP1559TxData
-
-export const encodeFunction = (
-  method: string,
-  params?: {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    types: any[]
-    values: unknown[]
-  },
-): string => {
-  const parameters = params?.types ?? []
-  const methodWithParameters = `function ${method}(${parameters.join(',')})`
-  const signatureHash = new Interface([methodWithParameters]).getSighash(method)
-  const encodedArgs = AbiCoder.encode(parameters, params?.values ?? [])
-
-  return signatureHash + encodedArgs.slice(2)
-}
-
-export const encodeDeployment = (
-  bytecode: string,
-  params?: {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    types: any[]
-    values: unknown[]
-  },
-) => {
-  const deploymentData = '0x' + bytecode
-  if (params) {
-    const argumentsEncoded = AbiCoder.encode(params.types, params.values)
-    return deploymentData + argumentsEncoded.slice(2)
-  }
-  return deploymentData
-}
-
-export const buildTransaction = (
-  data: Partial<TransactionsData>,
-): TransactionsData => {
-  const defaultData: Partial<TransactionsData> = {
-    gasLimit: 3_000_000_000_000_000,
-    gasPrice: 7,
-    value: 0,
-    data: '0x',
-  }
-
-  return {
-    ...defaultData,
-    ...data,
-  }
-}

in-browser-evm-verifier/tsconfig.commonjs.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "CommonJS",
-    "outDir": "./dist/commonjs"
-  }
-}

in-browser-evm-verifier/tsconfig.esm.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "ES2020",
-    "outDir": "./dist/esm"
-  }
-}

in-browser-evm-verifier/tsconfig.json

@@ -1,62 +0,0 @@
-{
-  "compilerOptions": {
-    "rootDir": "src",
-    "target": "es2017",
-    "outDir": "dist",
-    "declaration": true,
-    "lib": [
-      "dom",
-      "dom.iterable",
-      "esnext"
-    ],
-    "allowJs": true,
-    "checkJs": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "noEmit": false,
-    "esModuleInterop": true,
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "jsx": "preserve",
-    // "incremental": true,
-    "noUncheckedIndexedAccess": true,
-    "baseUrl": ".",
-    "paths": {
-      "@/*": [
-        "./src/*"
-      ]
-    }
-  },
-  "include": [
-    "src/**/*.ts",
-    "src/**/*.tsx",
-    "src/**/*.cjs",
-    "src/**/*.mjs"
-  ],
-  "exclude": [
-    "node_modules"
-  ],
-  // NEW: Options for file/directory watching
-  "watchOptions": {
-    // Use native file system events for files and directories
-    "watchFile": "useFsEvents",
-    "watchDirectory": "useFsEvents",
-    // Poll files for updates more frequently
-    // when they're updated a lot.
-    "fallbackPolling": "dynamicPriority",
-    // Don't coalesce watch notification
-    "synchronousWatchDirectory": true,
-    // Finally, two additional settings for reducing the amount of possible
-    // files to track  work from these directories
-    "excludeDirectories": [
-      "**/node_modules",
-      "_build"
-    ],
-    "excludeFiles": [
-      "build/fileWhichChangesOften.ts"
-    ]
-  }
-}

requirements.txt

@@ -9,6 +9,6 @@ pytest==8.1.1
 tomli==2.0.1
 typing-extensions==4.10.0
 zipp==3.18.1
-onnx==1.15.0
+onnx==1.17.0
 onnxruntime==1.17.1
 numpy==1.26.4

src/bin/ezkl.rs

@@ -1,12 +1,5 @@
 // ignore file if compiling for wasm
 
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-use mimalloc::MiMalloc;
-
-#[global_allocator]
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-static GLOBAL: MiMalloc = MiMalloc;
-
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use clap::{CommandFactory, Parser};
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]

src/bindings/mod.rs

@@ -3,7 +3,7 @@
 pub mod python;
 /// Universal bindings for all platforms
 #[cfg(any(
-    feature = "ios-bindings",
+    feature = "universal-bindings",
     all(target_arch = "wasm32", target_os = "unknown")
 ))]
 pub mod universal;

src/bindings/python.rs

@@ -206,6 +206,9 @@ struct PyRunArgs {
     /// bool: Should the circuit use range checks for inputs and outputs (set to false if the input is a felt)
     #[pyo3(get, set)]
     pub ignore_range_check_inputs_outputs: bool,
+    /// float: epsilon used for arguments that use division
+    #[pyo3(get, set)]
+    pub epsilon: f64,
 }
 
 /// default instantiation of PyRunArgs
@@ -238,12 +241,14 @@ impl From<PyRunArgs> for RunArgs {
             decomp_base: py_run_args.decomp_base,
             decomp_legs: py_run_args.decomp_legs,
             ignore_range_check_inputs_outputs: py_run_args.ignore_range_check_inputs_outputs,
+            epsilon: Some(py_run_args.epsilon),
         }
     }
 }
 
 impl Into<PyRunArgs> for RunArgs {
     fn into(self) -> PyRunArgs {
+        let eps = self.get_epsilon();
         PyRunArgs {
             bounded_log_lookup: self.bounded_log_lookup,
             input_scale: self.input_scale,
@@ -262,6 +267,7 @@ impl Into<PyRunArgs> for RunArgs {
             decomp_base: self.decomp_base,
             decomp_legs: self.decomp_legs,
             ignore_range_check_inputs_outputs: self.ignore_range_check_inputs_outputs,
+            epsilon: eps,
         }
     }
 }
@@ -962,6 +968,8 @@ fn gen_settings(
     output=PathBuf::from(DEFAULT_SETTINGS),
     variables=Vec::from([("batch_size".to_string(), 1)]),
     seed=DEFAULT_SEED.parse().unwrap(),
+    min=None,
+    max=None
 ))]
 #[gen_stub_pyfunction]
 fn gen_random_data(
@@ -969,8 +977,10 @@ fn gen_random_data(
     output: PathBuf,
     variables: Vec<(String, usize)>,
     seed: u64,
+    min: Option<f32>,
+    max: Option<f32>,
 ) -> Result<bool, PyErr> {
-    crate::execute::gen_random_data(model, output, variables, seed).map_err(|e| {
+    crate::execute::gen_random_data(model, output, variables, seed, min, max).map_err(|e| {
         let err_str = format!("Failed to generate settings: {}", e);
         PyRuntimeError::new_err(err_str)
     })?;
@@ -1020,7 +1030,6 @@ fn gen_random_data(
 ))]
 #[gen_stub_pyfunction]
 fn calibrate_settings(
-    py: Python,
     data: String,
     model: PathBuf,
     settings: PathBuf,
@@ -1029,26 +1038,23 @@ fn calibrate_settings(
     scales: Option<Vec<crate::Scale>>,
     scale_rebase_multiplier: Vec<u32>,
     max_logrows: Option<u32>,
-) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_async_runtimes::tokio::future_into_py(py, async move {
-        crate::execute::calibrate(
-            model,
-            data,
-            settings,
-            target,
-            lookup_safety_margin,
-            scales,
-            scale_rebase_multiplier,
-            max_logrows,
-        )
-        .await
-        .map_err(|e| {
-            let err_str = format!("Failed to calibrate settings: {}", e);
-            PyRuntimeError::new_err(err_str)
-        })?;
+) -> PyResult<bool> {
+    crate::execute::calibrate(
+        model,
+        data,
+        settings,
+        target,
+        lookup_safety_margin,
+        scales,
+        scale_rebase_multiplier,
+        max_logrows,
+    )
+    .map_err(|e| {
+        let err_str = format!("Failed to calibrate settings: {}", e);
+        PyRuntimeError::new_err(err_str)
+    })?;
 
-        Ok(true)
-    })
+    Ok(true)
 }
 
 /// Runs the forward pass operation to generate a witness
@@ -1084,22 +1090,18 @@ fn calibrate_settings(
 ))]
 #[gen_stub_pyfunction]
 fn gen_witness(
-    py: Python,
     data: String,
     model: PathBuf,
     output: Option<PathBuf>,
     vk_path: Option<PathBuf>,
     srs_path: Option<PathBuf>,
-) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_async_runtimes::tokio::future_into_py(py, async move {
-        let output = crate::execute::gen_witness(model, data, output, vk_path, srs_path)
-            .await
-            .map_err(|e| {
-                let err_str = format!("Failed to generate witness: {}", e);
-                PyRuntimeError::new_err(err_str)
-            })?;
-        Python::with_gil(|py| Ok(output.to_object(py)))
-    })
+) -> PyResult<PyObject> {
+    let output =
+        crate::execute::gen_witness(model, data, output, vk_path, srs_path).map_err(|e| {
+            let err_str = format!("Failed to generate witness: {}", e);
+            PyRuntimeError::new_err(err_str)
+        })?;
+    Python::with_gil(|py| Ok(output.to_object(py)))
 }
 
 /// Mocks the prover
@@ -1597,22 +1599,15 @@ fn verify_aggr(
 #[pyfunction(signature = (
     proof=PathBuf::from(DEFAULT_PROOF),
     calldata=PathBuf::from(DEFAULT_CALLDATA),
-    addr_vk=None,
+    vka_path=None,
 ))]
 #[gen_stub_pyfunction]
 fn encode_evm_calldata<'a>(
     proof: PathBuf,
     calldata: PathBuf,
-    addr_vk: Option<&'a str>,
+    vka_path: Option<PathBuf>,
 ) -> Result<Vec<u8>, PyErr> {
-    let addr_vk = if let Some(addr_vk) = addr_vk {
-        let addr_vk = H160Flag::from(addr_vk);
-        Some(addr_vk)
-    } else {
-        None
-    };
-
-    crate::execute::encode_evm_calldata(proof, calldata, addr_vk).map_err(|e| {
+    crate::execute::encode_evm_calldata(proof, calldata, vka_path).map_err(|e| {
         let err_str = format!("Failed to generate calldata: {}", e);
         PyRuntimeError::new_err(err_str)
     })
@@ -1681,6 +1676,7 @@ fn create_evm_verifier(
     })
 }
 
+#[cfg(feature = "reusable-verifier")]
 /// Creates an Evm VK artifact. This command generated a VK with circuit specific meta data encoding in memory for use by the reusable H2 verifier.
 /// This is useful for deploying verifier that were otherwise too big to fit on chain and required aggregation.
 ///
@@ -1692,15 +1688,15 @@ fn create_evm_verifier(
 /// settings_path: str
 ///     The path to the settings file
 ///
-/// sol_code_path: str
-///     The path to the create the solidity verifying key.
-///
-/// abi_path: str
-///     The path to create the ABI for the solidity verifier
+/// vka_path: str
+///     The path to the verification artifact calldata bytes file.
 ///
 /// srs_path: str
 ///     The path to the SRS file
 ///
+/// decimals: int
+///    The number of decimals used for the rescaling of fixed point felt instances into on-chain floats.
+///
 /// Returns
 /// -------
 /// bool
@@ -1708,21 +1704,21 @@ fn create_evm_verifier(
 #[pyfunction(signature = (
     vk_path=PathBuf::from(DEFAULT_VK),
     settings_path=PathBuf::from(DEFAULT_SETTINGS),
-    sol_code_path=PathBuf::from(DEFAULT_VK_SOL),
-    abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
-    srs_path=None
+    vka_path=PathBuf::from(DEFAULT_VKA),
+    srs_path=None,
+    decimals=DEFAULT_DECIMALS.parse().unwrap(),
 ))]
 #[gen_stub_pyfunction]
 fn create_evm_vka(
     py: Python,
     vk_path: PathBuf,
     settings_path: PathBuf,
-    sol_code_path: PathBuf,
-    abi_path: PathBuf,
+    vka_path: PathBuf,
     srs_path: Option<PathBuf>,
+    decimals: usize,
 ) -> PyResult<Bound<'_, PyAny>> {
     pyo3_async_runtimes::tokio::future_into_py(py, async move {
-        crate::execute::create_evm_vka(vk_path, srs_path, settings_path, sol_code_path, abi_path)
+        crate::execute::create_evm_vka(vk_path, srs_path, settings_path, vka_path, decimals)
             .await
             .map_err(|e| {
                 let err_str = format!("Failed to run create_evm_verifier: {}", e);
@@ -1733,128 +1729,11 @@ fn create_evm_vka(
     })
 }
 
-/// Creates an EVM compatible data attestation verifier, you will need solc installed in your environment to run this
-///
-/// Arguments
-/// ---------
-/// input_data: str
-///     The path to the .json data file, which should contain the necessary calldata and account addresses needed to read from all the on-chain view functions that return the data that the network ingests as inputs
-///
-/// settings_path: str
-///     The path to the settings file
-///
-/// sol_code_path: str
-///     The path to the create the solidity verifier
-///
-/// abi_path: str
-///     The path to create the ABI for the solidity verifier
-///
-/// Returns
-/// -------
-/// bool
-///
-#[pyfunction(signature = (
-    input_data=String::from(DEFAULT_DATA),
-    settings_path=PathBuf::from(DEFAULT_SETTINGS),
-    sol_code_path=PathBuf::from(DEFAULT_SOL_CODE_DA),
-    abi_path=PathBuf::from(DEFAULT_VERIFIER_DA_ABI),
-    witness_path=None,
-))]
-#[gen_stub_pyfunction]
-fn create_evm_data_attestation(
-    py: Python,
-    input_data: String,
-    settings_path: PathBuf,
-    sol_code_path: PathBuf,
-    abi_path: PathBuf,
-    witness_path: Option<PathBuf>,
-) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_async_runtimes::tokio::future_into_py(py, async move {
-        crate::execute::create_evm_data_attestation(
-            settings_path,
-            sol_code_path,
-            abi_path,
-            input_data,
-            witness_path,
-        )
-        .await
-        .map_err(|e| {
-            let err_str = format!("Failed to run create_evm_data_attestation: {}", e);
-            PyRuntimeError::new_err(err_str)
-        })?;
-
-        Ok(true)
-    })
-}
-
-/// Setup test evm witness
-///
-/// Arguments
-/// ---------
-/// data_path: str
-///     The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
-///
-/// compiled_circuit_path: str
-///     The path to the compiled model file (generated using the compile-circuit command)
-///
-/// test_data: str
-///     For testing purposes only. The optional path to the .json data file that will be generated that contains the OnChain data storage information derived from the file information in the data .json file. Should include both the network input (possibly private) and the network output (public input to the proof)
-///
-/// input_sources: str
-///     Where the input data comes from
-///
-/// output_source: str
-///     Where the output data comes from
-///
-/// rpc_url: str
-///     RPC URL for an EVM compatible node, if None, uses Anvil as a local RPC node
-///
-/// Returns
-/// -------
-/// bool
-///
-#[pyfunction(signature = (
-    data_path,
-    compiled_circuit_path,
-    test_data,
-    input_source,
-    output_source,
-    rpc_url=None
-))]
-#[gen_stub_pyfunction]
-fn setup_test_evm_data(
-    py: Python,
-    data_path: String,
-    compiled_circuit_path: PathBuf,
-    test_data: PathBuf,
-    input_source: PyTestDataSource,
-    output_source: PyTestDataSource,
-    rpc_url: Option<String>,
-) -> PyResult<Bound<'_, PyAny>> {
-    pyo3_async_runtimes::tokio::future_into_py(py, async move {
-        crate::execute::setup_test_evm_data(
-            data_path,
-            compiled_circuit_path,
-            test_data,
-            rpc_url,
-            input_source.into(),
-            output_source.into(),
-        )
-        .await
-        .map_err(|e| {
-            let err_str = format!("Failed to run setup_test_evm_data: {}", e);
-            PyRuntimeError::new_err(err_str)
-        })?;
-
-        Ok(true)
-    })
-}
-
-/// deploys the solidity verifier
+/// Deploys the solidity verifier
 #[pyfunction(signature = (
     addr_path,
+    rpc_url,
     sol_code_path=PathBuf::from(DEFAULT_SOL_CODE),
-    rpc_url=None,
     contract_type=ContractType::default(),
     optimizer_runs=DEFAULT_OPTIMIZER_RUNS.parse().unwrap(),
     private_key=None,
@@ -1863,8 +1742,8 @@ fn setup_test_evm_data(
 fn deploy_evm(
     py: Python,
     addr_path: PathBuf,
+    rpc_url: String,
     sol_code_path: PathBuf,
-    rpc_url: Option<String>,
     contract_type: ContractType,
     optimizer_runs: usize,
     private_key: Option<String>,
@@ -1888,46 +1767,65 @@ fn deploy_evm(
     })
 }
 
-/// deploys the solidity da verifier
+#[cfg(feature = "reusable-verifier")]
+/// Registers a VKA on the EZKL reusable verifier contract
+///
+/// Arguments
+/// ---------
+/// addr_verifier: str
+///     The reusable verifier contract's address as a hex string
+///
+/// rpc_url: str
+///     RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
+///
+/// vka_path: str
+///     The path to the VKA calldata bytes file (generated using the create_evm_vka command)
+///
+/// vka_digest_path: str
+///     The path to the VKA digest file, aka hash of the VKA calldata bytes file
+///
+/// private_key: str
+///     The private key to use for signing the transaction. If None, will use the default private key
+///
+/// Returns
+/// -------
+/// bool
+///
 #[pyfunction(signature = (
-    addr_path,
-    input_data,
-    settings_path=PathBuf::from(DEFAULT_SETTINGS),
-    sol_code_path=PathBuf::from(DEFAULT_SOL_CODE_DA),
-    rpc_url=None,
-    optimizer_runs=DEFAULT_OPTIMIZER_RUNS.parse().unwrap(),
-    private_key=None
+    addr_verifier,
+    rpc_url,
+    vka_path=PathBuf::from(DEFAULT_VKA),
+    vka_digest_path=PathBuf::from(DEFAULT_VKA_DIGEST),
+    private_key=None,
 ))]
 #[gen_stub_pyfunction]
-fn deploy_da_evm(
-    py: Python,
-    addr_path: PathBuf,
-    input_data: String,
-    settings_path: PathBuf,
-    sol_code_path: PathBuf,
-    rpc_url: Option<String>,
-    optimizer_runs: usize,
+fn register_vka<'a>(
+    py: Python<'a>,
+    addr_verifier: &'a str,
+    rpc_url: String,
+    vka_path: PathBuf,
+    vka_digest_path: PathBuf,
     private_key: Option<String>,
-) -> PyResult<Bound<'_, PyAny>> {
+) -> PyResult<Bound<'a, PyAny>> {
+    let addr_verifier = H160Flag::from(addr_verifier);
     pyo3_async_runtimes::tokio::future_into_py(py, async move {
-        crate::execute::deploy_da_evm(
-            input_data,
-            settings_path,
-            sol_code_path,
+        crate::execute::register_vka(
             rpc_url,
-            addr_path,
-            optimizer_runs,
+            addr_verifier,
+            vka_path,
+            vka_digest_path,
             private_key,
         )
         .await
         .map_err(|e| {
-            let err_str = format!("Failed to run deploy_da_evm: {}", e);
+            let err_str = format!("Failed to run register_vka: {}", e);
             PyRuntimeError::new_err(err_str)
         })?;
 
         Ok(true)
     })
 }
+
 /// verifies an evm compatible proof, you will need solc installed in your environment to run this
 ///
 /// Arguments
@@ -1941,52 +1839,46 @@ fn deploy_da_evm(
 /// rpc_url: str
 ///     RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
 ///
-/// addr_da: str
-///     does the verifier use data attestation ?
+/// vka_path: str
+///     The path to the VKA calldata bytes file (generated using the create_evm_vka command)
 ///
-/// addr_vk: str
-///     The address of the separate VK contract (if the verifier key is rendered as a separate contract)
+/// encoded_calldata: str
+///     The path to the encoded calldata bytes file (generated using the encode calldata command)
 /// Returns
 /// -------
 /// bool
 ///
 #[pyfunction(signature = (
     addr_verifier,
+    rpc_url,
     proof_path=PathBuf::from(DEFAULT_PROOF),
-    rpc_url=None,
-    addr_da = None,
-    addr_vk = None,
+    vka_path = None,
+    encoded_calldata = None,
 ))]
 #[gen_stub_pyfunction]
 fn verify_evm<'a>(
     py: Python<'a>,
     addr_verifier: &'a str,
+    rpc_url: String,
     proof_path: PathBuf,
-    rpc_url: Option<String>,
-    addr_da: Option<&'a str>,
-    addr_vk: Option<&'a str>,
+    vka_path: Option<PathBuf>,
+    encoded_calldata: Option<PathBuf>,
 ) -> PyResult<Bound<'a, PyAny>> {
     let addr_verifier = H160Flag::from(addr_verifier);
-    let addr_da = if let Some(addr_da) = addr_da {
-        let addr_da = H160Flag::from(addr_da);
-        Some(addr_da)
-    } else {
-        None
-    };
-    let addr_vk = if let Some(addr_vk) = addr_vk {
-        let addr_vk = H160Flag::from(addr_vk);
-        Some(addr_vk)
-    } else {
-        None
-    };
 
     pyo3_async_runtimes::tokio::future_into_py(py, async move {
-        crate::execute::verify_evm(proof_path, addr_verifier, rpc_url, addr_da, addr_vk)
-            .await
-            .map_err(|e| {
-                let err_str = format!("Failed to run verify_evm: {}", e);
-                PyRuntimeError::new_err(err_str)
-            })?;
+        crate::execute::verify_evm(
+            proof_path,
+            addr_verifier,
+            rpc_url,
+            vka_path,
+            encoded_calldata,
+        )
+        .await
+        .map_err(|e| {
+            let err_str = format!("Failed to run verify_evm: {}", e);
+            PyRuntimeError::new_err(err_str)
+        })?;
 
         Ok(true)
     })
@@ -2103,14 +1995,14 @@ fn ezkl(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(compile_circuit, m)?)?;
     m.add_function(wrap_pyfunction!(verify_aggr, m)?)?;
     m.add_function(wrap_pyfunction!(create_evm_verifier, m)?)?;
+    #[cfg(feature = "reusable-verifier")]
     m.add_function(wrap_pyfunction!(create_evm_vka, m)?)?;
     m.add_function(wrap_pyfunction!(deploy_evm, m)?)?;
-    m.add_function(wrap_pyfunction!(deploy_da_evm, m)?)?;
     m.add_function(wrap_pyfunction!(verify_evm, m)?)?;
-    m.add_function(wrap_pyfunction!(setup_test_evm_data, m)?)?;
     m.add_function(wrap_pyfunction!(create_evm_verifier_aggr, m)?)?;
-    m.add_function(wrap_pyfunction!(create_evm_data_attestation, m)?)?;
     m.add_function(wrap_pyfunction!(encode_evm_calldata, m)?)?;
+    #[cfg(feature = "reusable-verifier")]
+    m.add_function(wrap_pyfunction!(register_vka, m)?)?;
     Ok(())
 }
 

src/bindings/universal.rs

@@ -23,7 +23,7 @@ use crate::{
     circuit::region::RegionSettings,
     graph::GraphSettings,
     pfsys::{
-        create_proof_circuit,
+        create_proof_circuit, encode_calldata,
         evm::aggregation_kzg::{AggregationCircuit, PoseidonTranscript},
         verify_proof_circuit, TranscriptType,
     },
@@ -31,8 +31,12 @@ use crate::{
     CheckMode, Commitments, EZKLError as InnerEZKLError,
 };
 
+use crate::circuit::modules::poseidon::{
+    spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH},
+    PoseidonChip,
+};
+use crate::circuit::modules::Module;
 use crate::graph::{GraphCircuit, GraphWitness};
-use halo2_solidity_verifier::encode_calldata;
 use halo2curves::{
     bn256::{Bn256, Fr, G1Affine},
     ff::{FromUniformBytes, PrimeField},
@@ -61,49 +65,74 @@ impl From<InnerEZKLError> for EZKLError {
     }
 }
 
+/// Hash the input message with poseidon
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub fn poseidon_hash(message: Vec<u8>) -> Result<Vec<u8>, EZKLError> {
+    let message: Vec<Fr> = serde_json::from_slice(&message[..]).map_err(InnerEZKLError::from)?;
+
+    let output = PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>::run(message.clone())
+        .map_err(InnerEZKLError::from)?;
+
+    Ok(serde_json::to_vec(&output).map_err(InnerEZKLError::from)?)
+}
+
+/// Hash the input message with poseidon without converting to Fr
+#[cfg_attr(feature = "ios-bindings", uniffi::export)]
+pub fn poseidon_hash_no_felt(message: Vec<u8>) -> Result<Vec<u8>, EZKLError> {
+    let message: Vec<Fr> = message.iter().map(|x| Fr::from(*x as u64)).collect();
+
+    let output = PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>::run(message.clone())
+        .map_err(InnerEZKLError::from)?;
+
+    Ok(serde_json::to_vec(&output).map_err(InnerEZKLError::from)?)
+}
+
 /// Encode verifier calldata from proof and ethereum vk_address
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn encode_verifier_calldata(
-    // TODO - shuold it be pub(crate) or pub or pub(super)?
+pub fn encode_verifier_calldata(
+    // TODO - shuold it be pub or pub or pub(super)?
     proof: Vec<u8>,
-    vk_address: Option<Vec<u8>>,
+    vka: Option<Vec<u8>>,
 ) -> Result<Vec<u8>, EZKLError> {
     let snark: crate::pfsys::Snark<Fr, G1Affine> =
         serde_json::from_slice(&proof[..]).map_err(InnerEZKLError::from)?;
 
-    let vk_address: Option<[u8; 20]> = if let Some(vk_address) = vk_address {
-        let array: [u8; 20] =
-            serde_json::from_slice(&vk_address[..]).map_err(InnerEZKLError::from)?;
+    let vka_buf: Option<Vec<[u8; 32]>> = if let Some(vka) = vka {
+        let array: Vec<[u8; 32]> =
+            serde_json::from_slice(&vka[..]).map_err(InnerEZKLError::from)?;
         Some(array)
     } else {
         None
     };
 
+    let vka: Option<&[[u8; 32]]> = vka_buf.as_deref();
+
     let flattened_instances = snark.instances.into_iter().flatten();
 
-    let encoded = encode_calldata(
-        vk_address,
-        &snark.proof,
-        &flattened_instances.collect::<Vec<_>>(),
-    );
+    let encoded = encode_calldata(vka, &snark.proof, &flattened_instances.collect::<Vec<_>>());
 
     Ok(encoded)
 }
 
 /// Generate witness from compiled circuit and input json
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn gen_witness(compiled_circuit: Vec<u8>, input: Vec<u8>) -> Result<Vec<u8>, EZKLError> {
+pub fn gen_witness(compiled_circuit: Vec<u8>, input: Vec<u8>) -> Result<Vec<u8>, EZKLError> {
+    println!("[circuit]");
     let mut circuit: crate::graph::GraphCircuit = bincode::deserialize(&compiled_circuit[..])
         .map_err(|e| {
             EZKLError::InternalError(format!("Failed to deserialize compiled model: {}", e))
         })?;
+
+    println!("[input]");
     let input: crate::graph::input::GraphData = serde_json::from_slice(&input[..])
         .map_err(|e| EZKLError::InternalError(format!("Failed to deserialize input: {}", e)))?;
 
+    println!("[load graph input]");
     let mut input = circuit
         .load_graph_input(&input)
         .map_err(|e| EZKLError::InternalError(format!("{}", e)))?;
 
+    println!("[load graph witness]");
     let witness = circuit
         .forward::<KZGCommitmentScheme<Bn256>>(
             &mut input,
@@ -116,13 +145,14 @@ pub(crate) fn gen_witness(compiled_circuit: Vec<u8>, input: Vec<u8>) -> Result<V
         )
         .map_err(|e| EZKLError::InternalError(format!("{}", e)))?;
 
+    println!("[serialize witness]");
     serde_json::to_vec(&witness)
         .map_err(|e| EZKLError::InternalError(format!("Failed to serialize witness: {}", e)))
 }
 
 /// Generate verifying key from compiled circuit, and parameters srs
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn gen_vk(
+pub fn gen_vk(
     compiled_circuit: Vec<u8>,
     srs: Vec<u8>,
     compress_selectors: bool,
@@ -152,11 +182,7 @@ pub(crate) fn gen_vk(
 
 /// Generate proving key from vk, compiled circuit and parameters srs
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn gen_pk(
-    vk: Vec<u8>,
-    compiled_circuit: Vec<u8>,
-    srs: Vec<u8>,
-) -> Result<Vec<u8>, EZKLError> {
+pub fn gen_pk(vk: Vec<u8>, compiled_circuit: Vec<u8>, srs: Vec<u8>) -> Result<Vec<u8>, EZKLError> {
     let mut reader = BufReader::new(&srs[..]);
     let params: ParamsKZG<Bn256> = get_params(&mut reader)?;
 
@@ -183,7 +209,7 @@ pub(crate) fn gen_pk(
 
 /// Verify proof with vk, proof json, circuit settings json and srs
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn verify(
+pub fn verify(
     proof: Vec<u8>,
     vk: Vec<u8>,
     settings: Vec<u8>,
@@ -265,7 +291,7 @@ pub(crate) fn verify(
 
 /// Verify aggregate proof with vk, proof, circuit settings and srs
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn verify_aggr(
+pub fn verify_aggr(
     proof: Vec<u8>,
     vk: Vec<u8>,
     logrows: u64,
@@ -347,7 +373,7 @@ pub(crate) fn verify_aggr(
 
 /// Prove in browser with compiled circuit, witness json, proving key, and srs
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn prove(
+pub fn prove(
     witness: Vec<u8>,
     pk: Vec<u8>,
     compiled_circuit: Vec<u8>,
@@ -445,7 +471,7 @@ pub(crate) fn prove(
 
 /// Validate the witness json
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn witness_validation(witness: Vec<u8>) -> Result<bool, EZKLError> {
+pub fn witness_validation(witness: Vec<u8>) -> Result<bool, EZKLError> {
     let _: GraphWitness = serde_json::from_slice(&witness[..]).map_err(InnerEZKLError::from)?;
 
     Ok(true)
@@ -453,7 +479,7 @@ pub(crate) fn witness_validation(witness: Vec<u8>) -> Result<bool, EZKLError> {
 
 /// Validate the compiled circuit
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn compiled_circuit_validation(compiled_circuit: Vec<u8>) -> Result<bool, EZKLError> {
+pub fn compiled_circuit_validation(compiled_circuit: Vec<u8>) -> Result<bool, EZKLError> {
     let _: GraphCircuit = bincode::deserialize(&compiled_circuit[..]).map_err(|e| {
         EZKLError::InternalError(format!("Failed to deserialize compiled circuit: {}", e))
     })?;
@@ -463,7 +489,7 @@ pub(crate) fn compiled_circuit_validation(compiled_circuit: Vec<u8>) -> Result<b
 
 /// Validate the input json
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn input_validation(input: Vec<u8>) -> Result<bool, EZKLError> {
+pub fn input_validation(input: Vec<u8>) -> Result<bool, EZKLError> {
     let _: crate::graph::input::GraphData =
         serde_json::from_slice(&input[..]).map_err(InnerEZKLError::from)?;
 
@@ -472,7 +498,7 @@ pub(crate) fn input_validation(input: Vec<u8>) -> Result<bool, EZKLError> {
 
 /// Validate the proof json
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn proof_validation(proof: Vec<u8>) -> Result<bool, EZKLError> {
+pub fn proof_validation(proof: Vec<u8>) -> Result<bool, EZKLError> {
     let _: crate::pfsys::Snark<Fr, G1Affine> =
         serde_json::from_slice(&proof[..]).map_err(InnerEZKLError::from)?;
 
@@ -481,7 +507,7 @@ pub(crate) fn proof_validation(proof: Vec<u8>) -> Result<bool, EZKLError> {
 
 /// Validate the verifying key given the settings json
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn vk_validation(vk: Vec<u8>, settings: Vec<u8>) -> Result<bool, EZKLError> {
+pub fn vk_validation(vk: Vec<u8>, settings: Vec<u8>) -> Result<bool, EZKLError> {
     let circuit_settings: GraphSettings =
         serde_json::from_slice(&settings[..]).map_err(InnerEZKLError::from)?;
 
@@ -498,7 +524,7 @@ pub(crate) fn vk_validation(vk: Vec<u8>, settings: Vec<u8>) -> Result<bool, EZKL
 
 /// Validate the proving key given the settings json
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn pk_validation(pk: Vec<u8>, settings: Vec<u8>) -> Result<bool, EZKLError> {
+pub fn pk_validation(pk: Vec<u8>, settings: Vec<u8>) -> Result<bool, EZKLError> {
     let circuit_settings: GraphSettings =
         serde_json::from_slice(&settings[..]).map_err(InnerEZKLError::from)?;
 
@@ -515,7 +541,7 @@ pub(crate) fn pk_validation(pk: Vec<u8>, settings: Vec<u8>) -> Result<bool, EZKL
 
 /// Validate the settings json
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn settings_validation(settings: Vec<u8>) -> Result<bool, EZKLError> {
+pub fn settings_validation(settings: Vec<u8>) -> Result<bool, EZKLError> {
     let _: GraphSettings = serde_json::from_slice(&settings[..]).map_err(InnerEZKLError::from)?;
 
     Ok(true)
@@ -523,7 +549,7 @@ pub(crate) fn settings_validation(settings: Vec<u8>) -> Result<bool, EZKLError>
 
 /// Validate the srs
 #[cfg_attr(feature = "ios-bindings", uniffi::export)]
-pub(crate) fn srs_validation(srs: Vec<u8>) -> Result<bool, EZKLError> {
+pub fn srs_validation(srs: Vec<u8>) -> Result<bool, EZKLError> {
     let mut reader = BufReader::new(&srs[..]);
     let _: ParamsKZG<Bn256> =
         halo2_proofs::poly::commitment::Params::<'_, G1Affine>::read(&mut reader).map_err(|e| {

src/bindings/wasm.rs

@@ -1,12 +1,5 @@
 use crate::{
-    circuit::modules::{
-        polycommit::PolyCommitChip,
-        poseidon::{
-            spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH},
-            PoseidonChip,
-        },
-        Module,
-    },
+    circuit::modules::polycommit::PolyCommitChip,
     fieldutils::{felt_to_integer_rep, integer_rep_to_felt},
     graph::{quantize_float, scale_to_multiplier, GraphCircuit, GraphSettings},
 };
@@ -15,6 +8,7 @@ use halo2_proofs::{
     plonk::*,
     poly::kzg::commitment::{KZGCommitmentScheme, ParamsKZG},
 };
+use halo2_solidity_verifier::Evm;
 use halo2curves::{
     bn256::{Bn256, Fr, G1Affine},
     ff::PrimeField,
@@ -225,15 +219,9 @@ pub fn bufferToVecOfFelt(
 pub fn poseidonHash(
     message: wasm_bindgen::Clamped<Vec<u8>>,
 ) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
-    let message: Vec<Fr> = serde_json::from_slice(&message[..])
-        .map_err(|e| JsError::new(&format!("Failed to deserialize message: {}", e)))?;
-
-    let output = PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE>::run(message.clone())
-        .map_err(|e| JsError::new(&format!("{}", e)))?;
-
-    Ok(wasm_bindgen::Clamped(serde_json::to_vec(&output).map_err(
-        |e| JsError::new(&format!("Failed to serialize poseidon hash output: {}", e)),
-    )?))
+    super::universal::poseidon_hash(message.0)
+        .map_err(JsError::from)
+        .map(|x| wasm_bindgen::Clamped(x.clone()))
 }
 
 /// Generate a witness file from input.json, compiled model and a settings.json file.
@@ -279,6 +267,33 @@ pub fn verify(
     super::universal::verify(proof_js.0, vk.0, settings.0, srs.0).map_err(JsError::from)
 }
 
+/// Verify proof in browser evm using wasm
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+pub fn verifyEVM(
+    proof_js: wasm_bindgen::Clamped<Vec<u8>>,
+    bytecode_verifier: Vec<u8>,
+    bytecode_vka: Option<Vec<u8>>,
+) -> Result<bool, JsError> {
+    let mut evm = Evm::unlimited();
+    let decoded_verifier = utf8_bytes_to_hex_decoded(&bytecode_verifier)?;
+    let (verifier_address, _) = evm.create(decoded_verifier);
+    // if bytecode_vk is Some, then create the vk contract
+    let vk_address = if let Some(bytecode_vka) = bytecode_vka {
+        let decoded_vka = utf8_bytes_to_hex_decoded(&bytecode_vka)?;
+        let (address, _) = evm.create(decoded_vka);
+        Some(address.as_slice().to_vec())
+        // check if bytecode_verifier is none and if so then generate the
+        // reusable verifier
+    } else {
+        None
+    };
+    let calldata = encode_verifier_calldata(proof_js.0, vk_address).map_err(JsError::from);
+    let output = evm.call(verifier_address, calldata?).1;
+    let true_word = [vec![0; 31], vec![1]].concat();
+    Ok(output == true_word)
+}
+
 /// Verify aggregate proof in browser using wasm
 #[wasm_bindgen]
 #[allow(non_snake_case)]
@@ -371,3 +386,13 @@ pub fn u8_array_to_u128_le(arr: [u8; 16]) -> u128 {
     }
     n
 }
+///
+pub fn utf8_bytes_to_hex_decoded(input: &[u8]) -> Result<Vec<u8>, JsError> {
+    let string = std::str::from_utf8(input)?.trim();
+    let hex_string = if string.starts_with("0x") {
+        &string[2..]
+    } else {
+        string
+    };
+    hex::decode(hex_string).map_err(JsError::from)
+}

src/circuit/ops/chip.rs

@@ -962,7 +962,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
     pub fn layout(
         &mut self,
         region: &mut RegionCtx<F>,
-        values: &[ValTensor<F>],
+        values: &[&ValTensor<F>],
         op: Box<dyn Op<F>>,
     ) -> Result<Option<ValTensor<F>>, CircuitError> {
         op.layout(self, region, values)

src/circuit/ops/hybrid.rs

@@ -15,10 +15,12 @@ use serde::{Deserialize, Serialize};
 pub enum HybridOp {
     Ln {
         scale: utils::F32,
+        eps: f64,
     },
     Rsqrt {
         input_scale: utils::F32,
         output_scale: utils::F32,
+        eps: f64,
     },
     Sqrt {
         scale: utils::F32,
@@ -42,6 +44,7 @@ pub enum HybridOp {
     Recip {
         input_scale: utils::F32,
         output_scale: utils::F32,
+        eps: f64,
     },
     Div {
         denom: utils::F32,
@@ -77,6 +80,7 @@ pub enum HybridOp {
         input_scale: utils::F32,
         output_scale: utils::F32,
         axes: Vec<usize>,
+        eps: f64,
     },
     Output {
         decomp: bool,
@@ -105,13 +109,13 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
     ///
     fn requires_homogenous_input_scales(&self) -> Vec<usize> {
         match self {
-            HybridOp::Greater { .. }
-            | HybridOp::Less { .. }
-            | HybridOp::Equals { .. }
-            | HybridOp::GreaterEqual { .. }
+            HybridOp::Greater
+            | HybridOp::Less
+            | HybridOp::Equals
+            | HybridOp::GreaterEqual
             | HybridOp::Max
             | HybridOp::Min
-            | HybridOp::LessEqual { .. } => {
+            | HybridOp::LessEqual => {
                 vec![0, 1]
             }
             _ => vec![],
@@ -128,12 +132,13 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
             HybridOp::Rsqrt {
                 input_scale,
                 output_scale,
+                eps,
             } => format!(
-                "RSQRT (input_scale={}, output_scale={})",
-                input_scale, output_scale
+                "RSQRT (input_scale={}, output_scale={}, eps={})",
+                input_scale, output_scale, eps
             ),
             HybridOp::Sqrt { scale } => format!("SQRT(scale={})", scale),
-            HybridOp::Ln { scale } => format!("LN(scale={})", scale),
+            HybridOp::Ln { scale, eps } => format!("LN(scale={}, eps={})", scale, eps),
             HybridOp::RoundHalfToEven { scale, legs } => {
                 format!("ROUND_HALF_TO_EVEN(scale={}, legs={})", scale, legs)
             }
@@ -146,16 +151,18 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
             HybridOp::Recip {
                 input_scale,
                 output_scale,
+                eps,
             } => format!(
-                "RECIP (input_scale={}, output_scale={})",
-                input_scale, output_scale
+                "RECIP (input_scale={}, output_scale={}, eps={})",
+                input_scale, output_scale, eps
             ),
             HybridOp::Div { denom } => format!("DIV (denom={})", denom),
             HybridOp::SumPool {
                 padding,
                 stride,
                 kernel_shape,
-                normalized, data_format
+                normalized,
+                data_format,
             } => format!(
                 "SUMPOOL (padding={:?}, stride={:?}, kernel_shape={:?}, normalized={}, data_format={:?})",
                 padding, stride, kernel_shape, normalized, data_format
@@ -177,10 +184,11 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                 input_scale,
                 output_scale,
                 axes,
+                eps,
             } => {
                 format!(
-                    "SOFTMAX (input_scale={}, output_scale={}, axes={:?})",
-                    input_scale, output_scale, axes
+                    "SOFTMAX (input_scale={}, output_scale={}, axes={:?}, eps={})",
+                    input_scale, output_scale, axes, eps
                 )
             }
             HybridOp::Output { decomp } => {
@@ -205,23 +213,27 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
         &self,
         config: &mut crate::circuit::BaseConfig<F>,
         region: &mut RegionCtx<F>,
-        values: &[ValTensor<F>],
+        values: &[&ValTensor<F>],
     ) -> Result<Option<ValTensor<F>>, CircuitError> {
         Ok(Some(match self {
             HybridOp::Rsqrt {
                 input_scale,
                 output_scale,
+                eps,
             } => layouts::rsqrt(
                 config,
                 region,
                 values[..].try_into()?,
                 *input_scale,
                 *output_scale,
+                *eps,
             )?,
             HybridOp::Sqrt { scale } => {
                 layouts::sqrt(config, region, values[..].try_into()?, *scale)?
             }
-            HybridOp::Ln { scale } => layouts::ln(config, region, values[..].try_into()?, *scale)?,
+            HybridOp::Ln { scale, eps } => {
+                layouts::ln(config, region, values[..].try_into()?, *scale, *eps)?
+            }
             HybridOp::RoundHalfToEven { scale, legs } => {
                 layouts::round_half_to_even(config, region, values[..].try_into()?, *scale, *legs)?
             }
@@ -255,12 +267,14 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
             HybridOp::Recip {
                 input_scale,
                 output_scale,
+                eps,
             } => layouts::recip(
                 config,
                 region,
                 values[..].try_into()?,
                 integer_rep_to_felt(input_scale.0 as IntegerRep),
                 integer_rep_to_felt(output_scale.0 as IntegerRep),
+                *eps,
             )?,
             HybridOp::Div { denom, .. } => {
                 if denom.0.fract() == 0.0 {
@@ -317,6 +331,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                 input_scale,
                 output_scale,
                 axes,
+                eps,
             } => layouts::softmax_axes(
                 config,
                 region,
@@ -324,6 +339,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
                 *input_scale,
                 *output_scale,
                 axes,
+                *eps,
             )?,
             HybridOp::Output { decomp } => {
                 layouts::output(config, region, values[..].try_into()?, *decomp)?
@@ -346,10 +362,10 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
 
     fn out_scale(&self, in_scales: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
         let scale = match self {
-            HybridOp::Greater { .. }
-            | HybridOp::GreaterEqual { .. }
-            | HybridOp::Less { .. }
-            | HybridOp::LessEqual { .. }
+            HybridOp::Greater
+            | HybridOp::GreaterEqual
+            | HybridOp::Less
+            | HybridOp::LessEqual
             | HybridOp::ReduceArgMax { .. }
             | HybridOp::OneHot { .. }
             | HybridOp::ReduceArgMin { .. } => 0,
@@ -364,6 +380,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
             } => multiplier_to_scale((output_scale.0 * input_scale.0) as f64),
             HybridOp::Ln {
                 scale: output_scale,
+                eps: _,
             } => 4 * multiplier_to_scale(output_scale.0 as f64),
             _ => in_scales[0],
         };

src/circuit/ops/lookup.rs

@@ -186,7 +186,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Lookup
         &self,
         config: &mut crate::circuit::BaseConfig<F>,
         region: &mut RegionCtx<F>,
-        values: &[ValTensor<F>],
+        values: &[&ValTensor<F>],
     ) -> Result<Option<ValTensor<F>>, CircuitError> {
         Ok(Some(layouts::nonlinearity(
             config,

src/circuit/ops/mod.rs

@@ -49,7 +49,7 @@ pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>:
         &self,
         config: &mut crate::circuit::BaseConfig<F>,
         region: &mut RegionCtx<F>,
-        values: &[ValTensor<F>],
+        values: &[&ValTensor<F>],
     ) -> Result<Option<ValTensor<F>>, CircuitError>;
 
     /// Returns the scale of the output of the operation.
@@ -209,7 +209,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input
         &self,
         config: &mut crate::circuit::BaseConfig<F>,
         region: &mut RegionCtx<F>,
-        values: &[ValTensor<F>],
+        values: &[&ValTensor<F>],
     ) -> Result<Option<ValTensor<F>>, CircuitError> {
         let value = values[0].clone();
         if !value.all_prev_assigned() {
@@ -223,12 +223,29 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input
                         true,
                     )?))
                 }
-                _ => Ok(Some(super::layouts::identity(
-                    config,
-                    region,
-                    values[..].try_into()?,
-                    self.decomp,
-                )?)),
+                _ => {
+                    if self.decomp {
+                        log::debug!("constraining input to be decomp");
+                        Ok(Some(
+                            super::layouts::decompose(
+                                config,
+                                region,
+                                values[..].try_into()?,
+                                &region.base(),
+                                &region.legs(),
+                                false,
+                            )?
+                            .1,
+                        ))
+                    } else {
+                        log::debug!("constraining input to be identity");
+                        Ok(Some(super::layouts::identity(
+                            config,
+                            region,
+                            values[..].try_into()?,
+                        )?))
+                    }
+                }
             }
         } else {
             Ok(Some(value))
@@ -263,7 +280,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Unknow
         &self,
         _: &mut crate::circuit::BaseConfig<F>,
         _: &mut RegionCtx<F>,
-        _: &[ValTensor<F>],
+        _: &[&ValTensor<F>],
     ) -> Result<Option<ValTensor<F>>, CircuitError> {
         Err(super::CircuitError::UnsupportedOp)
     }
@@ -319,8 +336,13 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Constant<F> {
 }
 
 impl<
-    F: PrimeField + TensorType + PartialOrd + std::hash::Hash + Serialize + for<'de> Deserialize<'de>,
-> Op<F> for Constant<F>
+        F: PrimeField
+            + TensorType
+            + PartialOrd
+            + std::hash::Hash
+            + Serialize
+            + for<'de> Deserialize<'de>,
+    > Op<F> for Constant<F>
 {
     fn as_any(&self) -> &dyn Any {
         self
@@ -333,20 +355,20 @@ impl<
         &self,
         config: &mut crate::circuit::BaseConfig<F>,
         region: &mut RegionCtx<F>,
-        _: &[ValTensor<F>],
+        _: &[&ValTensor<F>],
     ) -> Result<Option<ValTensor<F>>, CircuitError> {
         let value = if let Some(value) = &self.pre_assigned_val {
             value.clone()
         } else {
             self.quantized_values.clone().try_into()?
         };
-        // we gotta constrain it once if its used multiple times
-        Ok(Some(layouts::identity(
-            config,
-            region,
-            &[value],
-            self.decomp,
-        )?))
+        Ok(Some(if self.decomp {
+            log::debug!("constraining constant to be decomp");
+            super::layouts::decompose(config, region, &[&value], &region.base(), &region.legs(), false)?.1
+        } else {
+            log::debug!("constraining constant to be identity");
+            super::layouts::identity(config, region, &[&value])?
+        }))
     }
 
     fn clone_dyn(&self) -> Box<dyn Op<F>> {

src/circuit/ops/poly.rs

@@ -108,8 +108,13 @@ pub enum PolyOp {
 }
 
 impl<
-    F: PrimeField + TensorType + PartialOrd + std::hash::Hash + Serialize + for<'de> Deserialize<'de>,
-> Op<F> for PolyOp
+        F: PrimeField
+            + TensorType
+            + PartialOrd
+            + std::hash::Hash
+            + Serialize
+            + for<'de> Deserialize<'de>,
+    > Op<F> for PolyOp
 {
     /// Returns a reference to the Any trait.
     fn as_any(&self) -> &dyn Any {
@@ -203,11 +208,11 @@ impl<
         &self,
         config: &mut crate::circuit::BaseConfig<F>,
         region: &mut RegionCtx<F>,
-        values: &[ValTensor<F>],
+        values: &[&ValTensor<F>],
     ) -> Result<Option<ValTensor<F>>, CircuitError> {
         Ok(Some(match self {
             PolyOp::Abs => layouts::abs(config, region, values[..].try_into()?)?,
-            PolyOp::Sign => layouts::sign(config, region, values[..].try_into()?)?,
+            PolyOp::Sign => layouts::sign(config, region, values[..].try_into()?, true)?,
             PolyOp::LeakyReLU { slope, scale } => {
                 layouts::leaky_relu(config, region, values[..].try_into()?, slope, scale)?
             }
@@ -335,9 +340,7 @@ impl<
             PolyOp::Mult => {
                 layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Mult)?
             }
-            PolyOp::Identity { .. } => {
-                layouts::identity(config, region, values[..].try_into()?, false)?
-            }
+            PolyOp::Identity { .. } => layouts::identity(config, region, values[..].try_into()?)?,
             PolyOp::Reshape(d) | PolyOp::Flatten(d) => layouts::reshape(values[..].try_into()?, d)?,
             PolyOp::Pad(p) => {
                 if values.len() != 1 {
@@ -416,14 +419,14 @@ impl<
             PolyOp::Reshape(_) | PolyOp::Flatten(_) => in_scales[0],
             PolyOp::Pow(pow) => in_scales[0] * (*pow as crate::Scale),
             PolyOp::Identity { out_scale } => out_scale.unwrap_or(in_scales[0]),
-            PolyOp::Sign { .. } => 0,
+            PolyOp::Sign => 0,
             _ => in_scales[0],
         };
         Ok(scale)
     }
 
     fn requires_homogenous_input_scales(&self) -> Vec<usize> {
-        if matches!(self, PolyOp::Add { .. } | PolyOp::Sub) {
+        if matches!(self, PolyOp::Add | PolyOp::Sub) {
             vec![0, 1]
         } else if matches!(self, PolyOp::Iff) {
             vec![1, 2]

src/circuit/ops/region.rs

@@ -10,7 +10,6 @@ use halo2_proofs::{
     plonk::{Error, Selector},
 };
 use halo2curves::ff::PrimeField;
-use itertools::Itertools;
 use maybe_rayon::iter::ParallelExtend;
 use std::{
     cell::RefCell,
@@ -462,15 +461,14 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
     /// Update the max and min from inputs
     pub fn update_max_min_lookup_inputs(
         &mut self,
-        inputs: &[ValTensor<F>],
+        inputs: &ValTensor<F>,
     ) -> Result<(), CircuitError> {
-        let (mut min, mut max) = (0, 0);
-        for i in inputs {
-            max = max.max(i.int_evals()?.into_iter().max().unwrap_or_default());
-            min = min.min(i.int_evals()?.into_iter().min().unwrap_or_default());
-        }
-        self.statistics.max_lookup_inputs = self.statistics.max_lookup_inputs.max(max);
-        self.statistics.min_lookup_inputs = self.statistics.min_lookup_inputs.min(min);
+        let int_eval = inputs.int_evals()?;
+        let max = int_eval.iter().max().unwrap_or(&0);
+        let min = int_eval.iter().min().unwrap_or(&0);
+
+        self.statistics.max_lookup_inputs = self.statistics.max_lookup_inputs.max(*max);
+        self.statistics.min_lookup_inputs = self.statistics.min_lookup_inputs.min(*min);
         Ok(())
     }
 
@@ -505,10 +503,10 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
     /// add used lookup
     pub fn add_used_lookup(
         &mut self,
-        lookup: LookupOp,
-        inputs: &[ValTensor<F>],
+        lookup: &LookupOp,
+        inputs: &ValTensor<F>,
     ) -> Result<(), CircuitError> {
-        self.statistics.used_lookups.insert(lookup);
+        self.statistics.used_lookups.insert(lookup.clone());
         self.update_max_min_lookup_inputs(inputs)
     }
 
@@ -642,34 +640,6 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
         self.assign_dynamic_lookup(var, values)
     }
 
-    /// Assign a valtensor to a vartensor
-    pub fn assign_with_omissions(
-        &mut self,
-        var: &VarTensor,
-        values: &ValTensor<F>,
-        ommissions: &HashSet<usize>,
-    ) -> Result<ValTensor<F>, CircuitError> {
-        if let Some(region) = &self.region {
-            Ok(var.assign_with_omissions(
-                &mut region.borrow_mut(),
-                self.linear_coord,
-                values,
-                ommissions,
-                &mut self.assigned_constants,
-            )?)
-        } else {
-            let mut values_clone = values.clone();
-            let mut indices = ommissions.clone().into_iter().collect_vec();
-            values_clone.remove_indices(&mut indices, false)?;
-
-            let values_map = values.create_constants_map();
-
-            self.assigned_constants.par_extend(values_map);
-
-            Ok(values.clone())
-        }
-    }
-
     /// Assign a valtensor to a vartensor with duplication
     pub fn assign_with_duplication_unconstrained(
         &mut self,

src/circuit/tests.rs

@@ -9,6 +9,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::Fr as F;
 use halo2curves::ff::{Field, PrimeField};
+use itertools::Itertools;
 #[cfg(not(any(
     all(target_arch = "wasm32", target_os = "unknown"),
     not(feature = "ezkl")
@@ -64,7 +65,7 @@ mod matmul {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Einsum {
                                     equation: "ij,jk->ik".to_string(),
                                 }),
@@ -141,7 +142,7 @@ mod matmul_col_overflow_double_col {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Einsum {
                                     equation: "ij,jk->ik".to_string(),
                                 }),
@@ -215,7 +216,7 @@ mod matmul_col_overflow {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Einsum {
                                     equation: "ij,jk->ik".to_string(),
                                 }),
@@ -302,7 +303,7 @@ mod matmul_col_ultra_overflow_double_col {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Einsum {
                                     equation: "ij,jk->ik".to_string(),
                                 }),
@@ -380,6 +381,7 @@ mod matmul_col_ultra_overflow {
         multiopen::{ProverSHPLONK, VerifierSHPLONK},
         strategy::SingleStrategy,
     };
+    use itertools::Itertools;
     use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 
     use super::*;
@@ -422,7 +424,7 @@ mod matmul_col_ultra_overflow {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Einsum {
                                     equation: "ij,jk->ik".to_string(),
                                 }),
@@ -533,7 +535,7 @@ mod dot {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Einsum {
                                     equation: "i,i->".to_string(),
                                 }),
@@ -610,7 +612,7 @@ mod dot_col_overflow_triple_col {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Einsum {
                                     equation: "i,i->".to_string(),
                                 }),
@@ -683,7 +685,7 @@ mod dot_col_overflow {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Einsum {
                                     equation: "i,i->".to_string(),
                                 }),
@@ -756,7 +758,7 @@ mod sum {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Sum { axes: vec![0] }),
                             )
                             .map_err(|_| Error::Synthesis)
@@ -826,7 +828,7 @@ mod sum_col_overflow_double_col {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Sum { axes: vec![0] }),
                             )
                             .map_err(|_| Error::Synthesis)
@@ -895,7 +897,7 @@ mod sum_col_overflow {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Sum { axes: vec![0] }),
                             )
                             .map_err(|_| Error::Synthesis)
@@ -966,7 +968,7 @@ mod composition {
                         let _ = config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Einsum {
                                     equation: "i,i->".to_string(),
                                 }),
@@ -975,7 +977,7 @@ mod composition {
                         let _ = config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Einsum {
                                     equation: "i,i->".to_string(),
                                 }),
@@ -984,7 +986,7 @@ mod composition {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs.clone(),
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Einsum {
                                     equation: "i,i->".to_string(),
                                 }),
@@ -1061,7 +1063,7 @@ mod conv {
                         config
                             .layout(
                                 &mut region,
-                                &self.inputs,
+                                &self.inputs.iter().collect_vec(),
                                 Box::new(PolyOp::Conv {
                                     padding: vec![(1, 1); 2],
                                     stride: vec![2; 2],
@@ -1218,7 +1220,7 @@ mod conv_col_ultra_overflow {
                         config
                             .layout(
                                 &mut region,
-                                &[self.image.clone(), self.kernel.clone()],
+                                &[&self.image, &self.kernel],
                                 Box::new(PolyOp::Conv {
                                     padding: vec![(1, 1); 2],
                                     stride: vec![2; 2],
@@ -1377,7 +1379,7 @@ mod conv_relu_col_ultra_overflow {
                         let output = config
                             .layout(
                                 &mut region,
-                                &[self.image.clone(), self.kernel.clone()],
+                                &[&self.image, &self.kernel],
                                 Box::new(PolyOp::Conv {
                                     padding: vec![(1, 1); 2],
                                     stride: vec![2; 2],
@@ -1390,7 +1392,7 @@ mod conv_relu_col_ultra_overflow {
                         let _output = config
                             .layout(
                                 &mut region,
-                                &[output.unwrap().unwrap()],
+                                &[&output.unwrap().unwrap()],
                                 Box::new(PolyOp::LeakyReLU {
                                     slope: 0.0.into(),
                                     scale: 1,
@@ -1517,7 +1519,11 @@ mod add_w_shape_casting {
                     |region| {
                         let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
-                            .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Add))
+                            .layout(
+                                &mut region,
+                                &self.inputs.iter().collect_vec(),
+                                Box::new(PolyOp::Add),
+                            )
                             .map_err(|_| Error::Synthesis)
                     },
                 )
@@ -1584,7 +1590,11 @@ mod add {
                     |region| {
                         let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
-                            .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Add))
+                            .layout(
+                                &mut region,
+                                &self.inputs.iter().collect_vec(),
+                                Box::new(PolyOp::Add),
+                            )
                             .map_err(|_| Error::Synthesis)
                     },
                 )
@@ -1671,8 +1681,8 @@ mod dynamic_lookup {
                             layouts::dynamic_lookup(
                                 &config,
                                 &mut region,
-                                &self.lookups[i],
-                                &self.tables[i],
+                                &self.lookups[i].iter().collect_vec().try_into().unwrap(),
+                                &self.tables[i].iter().collect_vec().try_into().unwrap(),
                             )
                             .map_err(|_| Error::Synthesis)?;
                         }
@@ -1767,8 +1777,8 @@ mod shuffle {
 
     #[derive(Clone)]
     struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
-        inputs: [[ValTensor<F>; 1]; NUM_LOOP],
-        references: [[ValTensor<F>; 1]; NUM_LOOP],
+        inputs: [ValTensor<F>; NUM_LOOP],
+        references: [ValTensor<F>; NUM_LOOP],
         _marker: PhantomData<F>,
     }
 
@@ -1818,15 +1828,15 @@ mod shuffle {
                             layouts::shuffles(
                                 &config,
                                 &mut region,
-                                &self.inputs[i],
-                                &self.references[i],
+                                &[&self.inputs[i]],
+                                &[&self.references[i]],
                                 layouts::SortCollisionMode::Unsorted,
                             )
                             .map_err(|_| Error::Synthesis)?;
                         }
                         assert_eq!(
                             region.shuffle_col_coord(),
-                            NUM_LOOP * self.references[0][0].len()
+                            NUM_LOOP * self.references[0].len()
                         );
                         assert_eq!(region.shuffle_index(), NUM_LOOP);
 
@@ -1843,17 +1853,19 @@ mod shuffle {
         // parameters
         let references = (0..NUM_LOOP)
             .map(|loop_idx| {
-                [ValTensor::from(Tensor::from((0..LEN).map(|i| {
-                    Value::known(F::from((i * loop_idx) as u64 + 1))
-                })))]
+                ValTensor::from(Tensor::from(
+                    (0..LEN).map(|i| Value::known(F::from((i * loop_idx) as u64 + 1))),
+                ))
             })
             .collect::<Vec<_>>();
 
         let inputs = (0..NUM_LOOP)
             .map(|loop_idx| {
-                [ValTensor::from(Tensor::from((0..LEN).rev().map(|i| {
-                    Value::known(F::from((i * loop_idx) as u64 + 1))
-                })))]
+                ValTensor::from(Tensor::from(
+                    (0..LEN)
+                        .rev()
+                        .map(|i| Value::known(F::from((i * loop_idx) as u64 + 1))),
+                ))
             })
             .collect::<Vec<_>>();
 
@@ -1873,9 +1885,11 @@ mod shuffle {
                 } else {
                     loop_idx - 1
                 };
-                [ValTensor::from(Tensor::from((0..LEN).rev().map(|i| {
-                    Value::known(F::from((i * prev_idx) as u64 + 1))
-                })))]
+                ValTensor::from(Tensor::from(
+                    (0..LEN)
+                        .rev()
+                        .map(|i| Value::known(F::from((i * prev_idx) as u64 + 1))),
+                ))
             })
             .collect::<Vec<_>>();
 
@@ -1931,7 +1945,11 @@ mod add_with_overflow {
                     |region| {
                         let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
-                            .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Add))
+                            .layout(
+                                &mut region,
+                                &self.inputs.iter().collect_vec(),
+                                Box::new(PolyOp::Add),
+                            )
                             .map_err(|_| Error::Synthesis)
                     },
                 )
@@ -2026,7 +2044,7 @@ mod add_with_overflow_and_poseidon {
 
             layouter.assign_region(|| "_new_module", |_| Ok(()))?;
 
-            let inputs = vec![assigned_inputs_a, assigned_inputs_b];
+            let inputs = vec![&assigned_inputs_a, &assigned_inputs_b];
 
             layouter.assign_region(
                 || "model",
@@ -2135,7 +2153,11 @@ mod sub {
                     |region| {
                         let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
-                            .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Sub))
+                            .layout(
+                                &mut region,
+                                &self.inputs.iter().collect_vec(),
+                                Box::new(PolyOp::Sub),
+                            )
                             .map_err(|_| Error::Synthesis)
                     },
                 )
@@ -2202,7 +2224,11 @@ mod mult {
                     |region| {
                         let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
-                            .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Mult))
+                            .layout(
+                                &mut region,
+                                &self.inputs.iter().collect_vec(),
+                                Box::new(PolyOp::Mult),
+                            )
                             .map_err(|_| Error::Synthesis)
                     },
                 )
@@ -2269,7 +2295,11 @@ mod pow {
                     |region| {
                         let mut region = RegionCtx::new(region, 0, 1, 128, 2);
                         config
-                            .layout(&mut region, &self.inputs.clone(), Box::new(PolyOp::Pow(5)))
+                            .layout(
+                                &mut region,
+                                &self.inputs.iter().collect_vec(),
+                                Box::new(PolyOp::Pow(5)),
+                            )
                             .map_err(|_| Error::Synthesis)
                     },
                 )
@@ -2360,13 +2390,13 @@ mod matmul_relu {
                     };
                     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(PolyOp::LeakyReLU {
                                 slope: 0.0.into(),
                                 scale: 1,
@@ -2465,7 +2495,7 @@ mod relu {
                         Ok(config
                             .layout(
                                 &mut region,
-                                &[self.input.clone()],
+                                &[&self.input],
                                 Box::new(PolyOp::LeakyReLU {
                                     slope: 0.0.into(),
                                     scale: 1,
@@ -2563,7 +2593,7 @@ mod lookup_ultra_overflow {
                         config
                             .layout(
                                 &mut region,
-                                &[self.input.clone()],
+                                &[&self.input],
                                 Box::new(LookupOp::Sigmoid { scale: 1.0.into() }),
                             )
                             .map_err(|_| Error::Synthesis)

src/commands.rs

@@ -1,6 +1,7 @@
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 use alloy::primitives::Address as H160;
 use clap::{Command, Parser, Subcommand};
-use clap_complete::{Generator, Shell, generate};
+use clap_complete::{generate, Generator, Shell};
 #[cfg(feature = "python-bindings")]
 use pyo3::{conversion::FromPyObject, exceptions::PyValueError, prelude::*};
 use serde::{Deserialize, Serialize};
@@ -8,10 +9,9 @@ use std::path::PathBuf;
 use std::str::FromStr;
 use tosubcommand::{ToFlags, ToSubcommand};
 
-use crate::{Commitments, RunArgs, pfsys::ProofType};
+use crate::{pfsys::ProofType, Commitments, RunArgs};
 
 use crate::circuit::CheckMode;
-use crate::graph::TestDataSource;
 use crate::pfsys::TranscriptType;
 
 /// The default path to the .json data file
@@ -42,20 +42,14 @@ pub const DEFAULT_SPLIT: &str = "false";
 pub const DEFAULT_VERIFIER_ABI: &str = "verifier_abi.json";
 /// Default verifier abi for aggregated proofs
 pub const DEFAULT_VERIFIER_AGGREGATED_ABI: &str = "verifier_aggr_abi.json";
-/// Default verifier abi for data attestation
-pub const DEFAULT_VERIFIER_DA_ABI: &str = "verifier_da_abi.json";
 /// Default solidity code
 pub const DEFAULT_SOL_CODE: &str = "evm_deploy.sol";
 /// Default calldata path
 pub const DEFAULT_CALLDATA: &str = "calldata.bytes";
 /// Default solidity code for aggregated proofs
 pub const DEFAULT_SOL_CODE_AGGREGATED: &str = "evm_deploy_aggr.sol";
-/// Default solidity code for data attestation
-pub const DEFAULT_SOL_CODE_DA: &str = "evm_deploy_da.sol";
 /// Default contract address
 pub const DEFAULT_CONTRACT_ADDRESS: &str = "contract.address";
-/// Default contract address for data attestation
-pub const DEFAULT_CONTRACT_ADDRESS_DA: &str = "contract_da.address";
 /// Default contract address for vk
 pub const DEFAULT_CONTRACT_ADDRESS_VK: &str = "contract_vk.address";
 /// Default check mode
@@ -78,8 +72,8 @@ pub const DEFAULT_DISABLE_SELECTOR_COMPRESSION: &str = "false";
 pub const DEFAULT_RENDER_REUSABLE: &str = "false";
 /// Default contract deployment type
 pub const DEFAULT_CONTRACT_DEPLOYMENT_TYPE: &str = "verifier";
-/// Default VK sol path
-pub const DEFAULT_VK_SOL: &str = "vk.sol";
+/// Default VKA calldata path
+pub const DEFAULT_VKA: &str = "vka.bytes";
 /// Default VK abi path
 pub const DEFAULT_VK_ABI: &str = "vk.abi";
 /// Default scale rebase multipliers for calibration
@@ -92,6 +86,10 @@ pub const DEFAULT_ONLY_RANGE_CHECK_REBASE: &str = "false";
 pub const DEFAULT_COMMITMENT: &str = "kzg";
 /// Default seed used to generate random data
 pub const DEFAULT_SEED: &str = "21242";
+/// Default number of decimals for instances rescaling on-chain.
+pub const DEFAULT_DECIMALS: &str = "18";
+/// Default path for the vka digest file
+pub const DEFAULT_VKA_DIGEST: &str = "vka.digest";
 
 #[cfg(feature = "python-bindings")]
 /// Converts TranscriptType into a PyObject (Required for TranscriptType to be compatible with Python)
@@ -187,8 +185,6 @@ pub enum ContractType {
         /// Can also be used as an alternative to aggregation for verifiers that are otherwise too large to fit on-chain.
         reusable: bool,
     },
-    /// Deploys a verifying key artifact that the reusable verifier loads into memory during runtime. Encodes the circuit specific data that was otherwise hardcoded onto the stack.
-    VerifyingKeyArtifact,
 }
 
 impl Default for ContractType {
@@ -207,7 +203,6 @@ impl std::fmt::Display for ContractType {
                     "verifier/reusable".to_string()
                 }
                 ContractType::Verifier { reusable: false } => "verifier".to_string(),
-                ContractType::VerifyingKeyArtifact => "vka".to_string(),
             }
         )
     }
@@ -224,7 +219,6 @@ impl From<&str> for ContractType {
         match s {
             "verifier" => ContractType::Verifier { reusable: false },
             "verifier/reusable" => ContractType::Verifier { reusable: true },
-            "vka" => ContractType::VerifyingKeyArtifact,
             _ => {
                 log::error!("Invalid value for ContractType");
                 log::warn!("Defaulting to verifier");
@@ -234,24 +228,25 @@ impl From<&str> for ContractType {
     }
 }
 
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 #[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, PartialOrd)]
 /// wrapper for H160 to make it easy to parse into flag vals
 pub struct H160Flag {
     inner: H160,
 }
-
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 impl From<H160Flag> for H160 {
     fn from(val: H160Flag) -> H160 {
         val.inner
     }
 }
-
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 impl ToFlags for H160Flag {
     fn to_flags(&self) -> Vec<String> {
         vec![format!("{:#x}", self.inner)]
     }
 }
-
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 impl From<&str> for H160Flag {
     fn from(s: &str) -> Self {
         Self {
@@ -299,7 +294,6 @@ impl IntoPy<PyObject> for ContractType {
         match self {
             ContractType::Verifier { reusable: true } => "verifier/reusable".to_object(py),
             ContractType::Verifier { reusable: false } => "verifier".to_object(py),
-            ContractType::VerifyingKeyArtifact => "vka".to_object(py),
         }
     }
 }
@@ -312,7 +306,6 @@ impl<'source> FromPyObject<'source> for ContractType {
         match strval.to_lowercase().as_str() {
             "verifier" => Ok(ContractType::Verifier { reusable: false }),
             "verifier/reusable" => Ok(ContractType::Verifier { reusable: true }),
-            "vka" => Ok(ContractType::VerifyingKeyArtifact),
             _ => Err(PyValueError::new_err("Invalid value for ContractType")),
         }
     }
@@ -382,6 +375,42 @@ pub struct Cli {
     pub command: Option<Commands>,
 }
 
+/// Custom parser for data field that handles both direct JSON strings and file paths with '@' prefix
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, PartialOrd)]
+pub struct DataField(pub String);
+
+impl FromStr for DataField {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // Check if the input starts with '@'
+        if let Some(file_path) = s.strip_prefix('@') {
+            // Extract the file path (remove the '@' prefix)
+            // Read the file content
+            let content = std::fs::read_to_string(file_path)
+                .map_err(|e| format!("Failed to read data file '{}': {}", file_path, e))?;
+
+            // Return the file content as the data field value
+            Ok(DataField(content))
+        } else {
+            // Use the input string directly
+            Ok(DataField(s.to_string()))
+        }
+    }
+}
+
+impl ToFlags for DataField {
+    fn to_flags(&self) -> Vec<String> {
+        vec![self.0.clone()]
+    }
+}
+
+impl std::fmt::Display for DataField {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 #[allow(missing_docs)]
 #[derive(Debug, Subcommand, Clone, Deserialize, Serialize, PartialEq, PartialOrd, ToSubcommand)]
 pub enum Commands {
@@ -400,9 +429,9 @@ pub enum Commands {
 
     /// Generates the witness from an input file.
     GenWitness {
-        /// The path to the .json data file
-        #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
+        /// The path to the .json data file (with @ prefix) or a raw data string of the form '{"input_data": [[1, 2, 3]]}'
+        #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_parser = DataField::from_str)]
+        data: Option<DataField>,
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT, value_hint = clap::ValueHint::FilePath)]
         compiled_circuit: Option<PathBuf>,
@@ -443,6 +472,12 @@ pub enum Commands {
         /// random seed for reproducibility (optional)
         #[arg(long, value_hint = clap::ValueHint::Other, default_value = DEFAULT_SEED)]
         seed: u64,
+        /// min value for random data
+        #[arg(long, value_hint = clap::ValueHint::Other)]
+        min: Option<f32>,
+        /// max value for random data
+        #[arg(long, value_hint = clap::ValueHint::Other)]
+        max: Option<f32>,
     },
     /// Calibrates the proving scale, lookup bits and logrows from a circuit settings file.
     CalibrateSettings {
@@ -627,30 +662,6 @@ pub enum Commands {
         #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION, action = clap::ArgAction::SetTrue)]
         disable_selector_compression: Option<bool>,
     },
-    /// Deploys a test contact that the data attester reads from and creates a data attestation formatted input.json file that contains call data information
-    #[command(arg_required_else_help = true)]
-    SetupTestEvmData {
-        /// The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
-        #[arg(short = 'D', long, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
-        /// The path to the compiled model file (generated using the compile-circuit command)
-        #[arg(short = 'M', long, value_hint = clap::ValueHint::FilePath)]
-        compiled_circuit: Option<PathBuf>,
-        /// For testing purposes only. The optional path to the .json data file that will be generated that contains the OnChain data storage information
-        /// derived from the file information in the data .json file.
-        /// Should include both the network input (possibly private) and the network output (public input to the proof)
-        #[arg(short = 'T', long, value_hint = clap::ValueHint::FilePath)]
-        test_data: PathBuf,
-        /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
-        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
-        rpc_url: Option<String>,
-        /// where the input data come from
-        #[arg(long, default_value = "on-chain", value_hint = clap::ValueHint::Other)]
-        input_source: TestDataSource,
-        /// where the output data come from
-        #[arg(long, default_value = "on-chain", value_hint = clap::ValueHint::Other)]
-        output_source: TestDataSource,
-    },
     /// Swaps the positions in the transcript that correspond to commitments
     SwapProofCommitments {
         /// The path to the proof file
@@ -693,6 +704,7 @@ pub enum Commands {
     },
     /// Encodes a proof into evm calldata
     #[command(name = "encode-evm-calldata")]
+    #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
     EncodeEvmCalldata {
         /// The path to the proof file (generated using the prove command)
         #[arg(long, default_value = DEFAULT_PROOF, value_hint = clap::ValueHint::FilePath)]
@@ -700,12 +712,13 @@ pub enum Commands {
         /// The path to save the calldata to
         #[arg(long, default_value = DEFAULT_CALLDATA, value_hint = clap::ValueHint::FilePath)]
         calldata_path: Option<PathBuf>,
-        /// The path to the verification key address (only used if the vk is rendered as a separate contract)
-        #[arg(long, value_hint = clap::ValueHint::Other)]
-        addr_vk: Option<H160Flag>,
+        /// The path to the serialized VKA file
+        #[cfg_attr(all(feature = "reusable-verifier", not(target_arch = "wasm32")), arg(long, value_hint = clap::ValueHint::Other))]
+        vka_path: Option<PathBuf>,
     },
     /// Creates an Evm verifier for a single proof
     #[command(name = "create-evm-verifier")]
+    #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
     CreateEvmVerifier {
         /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
@@ -722,13 +735,18 @@ pub enum Commands {
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VERIFIER_ABI, value_hint = clap::ValueHint::FilePath)]
         abi_path: Option<PathBuf>,
-        /// Whether the to render the verifier as reusable or not. If true, you will need to deploy a VK artifact, passing it as part of the calldata to the verifier.
-        #[arg(long, default_value = DEFAULT_RENDER_REUSABLE, action = clap::ArgAction::SetTrue)]
+        /// Whether to render the verifier as reusable or not. If true, you will need to deploy a VK artifact, passing it as part of the calldata to the verifier.
+        #[cfg_attr(all(feature = "reusable-verifier", not(target_arch = "wasm32")), arg(short = 'R', long, default_value = DEFAULT_RENDER_REUSABLE, action = clap::ArgAction::SetTrue))]
         reusable: Option<bool>,
     },
-    /// Creates an Evm verifier artifact for a single proof to be used by the reusable verifier
+    /// Creates an evm verifier artifact to be used by the reusable verifier
     #[command(name = "create-evm-vka")]
-    CreateEvmVKArtifact {
+    #[cfg(all(
+        feature = "eth",
+        feature = "reusable-verifier",
+        not(target_arch = "wasm32")
+    ))]
+    CreateEvmVka {
         /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
@@ -738,39 +756,18 @@ pub enum Commands {
         /// The path to load the desired verification key file
         #[arg(long, default_value = DEFAULT_VK, value_hint = clap::ValueHint::FilePath)]
         vk_path: Option<PathBuf>,
-        /// The path to output the Solidity code
-        #[arg(long, default_value = DEFAULT_VK_SOL, value_hint = clap::ValueHint::FilePath)]
-        sol_code_path: Option<PathBuf>,
-        /// The path to output the Solidity verifier ABI
-        #[arg(long, default_value = DEFAULT_VK_ABI, value_hint = clap::ValueHint::FilePath)]
-        abi_path: Option<PathBuf>,
-    },
-    /// Creates an Evm verifier that attests to on-chain inputs for a single proof
-    #[command(name = "create-evm-da")]
-    CreateEvmDataAttestation {
-        /// The path to load circuit settings .json file from (generated using the gen-settings command)
-        #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
-        settings_path: Option<PathBuf>,
-        /// The path to output the Solidity code
-        #[arg(long, default_value = DEFAULT_SOL_CODE_DA, value_hint = clap::ValueHint::FilePath)]
-        sol_code_path: Option<PathBuf>,
-        /// The path to output the Solidity verifier ABI
-        #[arg(long, default_value = DEFAULT_VERIFIER_DA_ABI, value_hint = clap::ValueHint::FilePath)]
-        abi_path: Option<PathBuf>,
-        /// The path to the .json data file, which should
-        /// contain the necessary calldata and account addresses
-        /// needed to read from all the on-chain
-        /// view functions that return the data that the network
-        /// ingests as inputs.
-        #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
-        /// The path to the witness file. This is needed for proof swapping for kzg commitments.
-        #[arg(short = 'W', long, default_value = DEFAULT_WITNESS, value_hint = clap::ValueHint::FilePath)]
-        witness: Option<PathBuf>,
+        /// The path to output the vka calldata
+        #[arg(long, default_value = DEFAULT_VKA, value_hint = clap::ValueHint::FilePath)]
+        vka_path: Option<PathBuf>,
+        /// The number of decimals we want to use for the rescaling of the instances into on-chain floats
+        /// Default is 18, which is the number of decimals used by most ERC20 tokens
+        #[arg(long, default_value = DEFAULT_DECIMALS, value_hint = clap::ValueHint::Other)]
+        decimals: Option<usize>,
     },
 
     /// Creates an Evm verifier for an aggregate proof
     #[command(name = "create-evm-verifier-aggr")]
+    #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
     CreateEvmVerifierAggr {
         /// The path to SRS, if None will use ~/.ezkl/srs/kzg{logrows}.srs
         #[arg(long, value_hint = clap::ValueHint::FilePath)]
@@ -790,8 +787,8 @@ pub enum Commands {
         // logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS, value_hint = clap::ValueHint::Other)]
         logrows: Option<u32>,
-        /// Whether the to render the verifier as reusable or not. If true, you will need to deploy a VK artifact, passing it as part of the calldata to the verifier.
-        #[arg(long, default_value = DEFAULT_RENDER_REUSABLE, action = clap::ArgAction::SetTrue)]
+        /// Whether to render the verifier as reusable or not. If true, you will need to deploy a VK artifact, passing it as part of the calldata to the verifier.
+        #[cfg_attr(all(feature = "reusable-verifier", not(target_arch = "wasm32")), arg(short = 'R', long, action = clap::ArgAction::SetTrue))]
         reusable: Option<bool>,
     },
     /// Verifies a proof, returning accept or reject
@@ -834,13 +831,14 @@ pub enum Commands {
         commitment: Option<Commitments>,
     },
     /// Deploys an evm contract (verifier, reusable verifier, or vk artifact) that is generated by ezkl
+    #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
     DeployEvm {
         /// The path to the Solidity code (generated using the create-evm-verifier command)
         #[arg(long, default_value = DEFAULT_SOL_CODE, value_hint = clap::ValueHint::FilePath)]
         sol_code_path: Option<PathBuf>,
-        /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
-        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
-        rpc_url: Option<String>,
+        /// RPC URL for an Ethereum node
+        #[arg(short = 'U', long,  default_value = DEFAULT_CONTRACT_ADDRESS, value_hint = clap::ValueHint::Url)]
+        rpc_url: String,
         #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS, value_hint = clap::ValueHint::Other)]
         /// The path to output the contract address
         addr_path: Option<PathBuf>,
@@ -851,36 +849,13 @@ pub enum Commands {
         #[arg(short = 'P', long, value_hint = clap::ValueHint::Other)]
         private_key: Option<String>,
         /// Contract type to be deployed
+        #[cfg(all(feature = "reusable-verifier", not(target_arch = "wasm32")))]
         #[arg(long = "contract-type", short = 'C', default_value = DEFAULT_CONTRACT_DEPLOYMENT_TYPE, value_hint = clap::ValueHint::Other)]
         contract: ContractType,
     },
-    /// Deploys an evm verifier that allows for data attestation
-    #[command(name = "deploy-evm-da")]
-    DeployEvmDataAttestation {
-        /// The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
-        #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
-        /// The path to load circuit settings .json file from (generated using the gen-settings command)
-        #[arg(long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
-        settings_path: Option<PathBuf>,
-        /// The path to the Solidity code
-        #[arg(long, default_value = DEFAULT_SOL_CODE_DA, value_hint = clap::ValueHint::FilePath)]
-        sol_code_path: Option<PathBuf>,
-        /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
-        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
-        rpc_url: Option<String>,
-        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_DA, value_hint = clap::ValueHint::FilePath)]
-        /// The path to output the contract address
-        addr_path: Option<PathBuf>,
-        /// The optimizer runs to set on the verifier. (Lower values optimize for deployment, while higher values optimize for execution)
-        #[arg(long, default_value = DEFAULT_OPTIMIZER_RUNS, value_hint = clap::ValueHint::Other)]
-        optimizer_runs: usize,
-        /// Private secp256K1 key in hex format, 64 chars, no 0x prefix, of the account signing transactions. If None the private key will be generated by Anvil
-        #[arg(short = 'P', long, value_hint = clap::ValueHint::Other)]
-        private_key: Option<String>,
-    },
     /// Verifies a proof using a local Evm executor, returning accept or reject
     #[command(name = "verify-evm")]
+    #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
     VerifyEvm {
         /// The path to the proof file (generated using the prove command)
         #[arg(long, default_value = DEFAULT_PROOF, value_hint = clap::ValueHint::FilePath)]
@@ -888,15 +863,35 @@ pub enum Commands {
         /// The path to verifier contract's address
         #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS, value_hint = clap::ValueHint::Other)]
         addr_verifier: H160Flag,
+        /// RPC URL for an Ethereum node
+        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
+        rpc_url: String,
+        /// The path to the serialized vka file
+        #[cfg_attr(all(feature = "reusable-verifier", not(target_arch = "wasm32")), arg(long, value_hint = clap::ValueHint::FilePath))]
+        vka_path: Option<PathBuf>,
+        /// The path to the serialized encoded calldata file generated via the encode_calldata command
+        #[arg(long, value_hint = clap::ValueHint::FilePath)]
+        encoded_calldata: Option<PathBuf>,
+    },
+    /// Registers a VKA, returning the its digest used to identify it on-chain.
+    #[command(name = "register-vka")]
+    #[cfg(feature = "reusable-verifier")]
+    RegisterVka {
         /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
         #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
-        rpc_url: Option<String>,
-        /// does the verifier use data attestation ?
-        #[arg(long, value_hint = clap::ValueHint::Other)]
-        addr_da: Option<H160Flag>,
-        // is the vk rendered seperately, if so specify an address
-        #[arg(long, value_hint = clap::ValueHint::Other)]
-        addr_vk: Option<H160Flag>,
+        rpc_url: String,
+        /// The path to the reusable verifier contract's address
+        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS, value_hint = clap::ValueHint::Other)]
+        addr_verifier: H160Flag,
+        /// The path to the serialized VKA file
+        #[arg(long, default_value = DEFAULT_VKA, value_hint = clap::ValueHint::FilePath)]
+        vka_path: Option<PathBuf>,
+        /// The path to output the VKA digest to
+        #[arg(long, default_value = DEFAULT_VKA_DIGEST, value_hint = clap::ValueHint::FilePath)]
+        vka_digest_path: Option<PathBuf>,
+        /// Private secp256K1 key in hex format, 64 chars, no 0x prefix, of the account signing transactions. If None the private key will be generated by Anvil
+        #[arg(short = 'P', long, value_hint = clap::ValueHint::Other)]
+        private_key: Option<String>,
     },
     #[cfg(not(feature = "no-update"))]
     /// Updates ezkl binary to version specified (or latest if not specified)