refactor: DataSource enum -> struct

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

.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/rust.yml

@@ -24,16 +24,37 @@ jobs:
     permissions:
       contents: read
     runs-on: large-self-hosted
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_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:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_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:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_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:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_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:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_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:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_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:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -220,10 +367,31 @@ jobs:
     permissions:
       contents: read
     runs-on: non-gpu
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -233,7 +401,7 @@ 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
@@ -245,14 +413,54 @@ jobs:
         #   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
 
-  mock-proving-tests:
+  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@3b74dacdda3c0b763089addb99ed86bc3800e68b
+
+      - 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
+
+  mock-proving-tests:
+    permissions:
+      contents: read
+    runs-on: non-gpu
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -316,10 +524,31 @@ jobs:
       contents: read
     runs-on: non-gpu
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -435,10 +664,31 @@ jobs:
       contents: read
     runs-on: non-gpu
     needs: [build, library-tests, docs]
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -554,10 +804,31 @@ jobs:
       contents: read
     runs-on: self-hosted
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: dtolnay/rust-toolchain@4f94fbe7e03939b0e674bcc9ca609a16088f63ff  #nightly branch, TODO: update when required
         with:
           toolchain: nightly-2025-02-17
@@ -595,10 +866,31 @@ jobs:
       contents: read
     runs-on: large-self-hosted
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -616,10 +908,31 @@ jobs:
       contents: read
     runs-on: large-self-hosted
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -641,10 +954,31 @@ jobs:
       contents: read
     runs-on: ubuntu-latest-32-cores
     needs: [build, library-tests, docs]
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -662,10 +996,31 @@ jobs:
       contents: read
     runs-on: non-gpu
     needs: [build, library-tests, docs]
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
         with:
           python-version: "3.12"
@@ -692,10 +1047,31 @@ jobs:
       contents: read
     runs-on: non-gpu
     needs: [build, library-tests, docs, python-tests, python-integration-tests]
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
         with:
           python-version: "3.12"
@@ -743,10 +1119,31 @@ jobs:
         ports:
           # Maps tcp port 5432 on service container to the host
           - 5432:5432
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions/setup-python@b64ffcaf5b410884ad320a9cfac8866006a109aa  #v4.8.0
         with:
           python-version: "3.11"
@@ -779,8 +1176,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
@@ -795,16 +1190,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:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -823,10 +1241,31 @@ jobs:
     runs-on: macos-latest
     needs: [ios-integration-tests]
 
+    env:
+      VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  #v4.2.2
         with:
           persist-credentials: false
+      - name: Configure Git credentials
+        run: |
+          if [ -z "$VERIFICATION_EZKL_TOKEN" ]; then
+            echo "❌ VERIFICATION_EZKL_TOKEN is empty – check repo/org secrets" >&2
+            exit 1
+          fi
+
+          # Configure git to use the token for all GitHub requests
+          git config --global credential.helper store
+          echo "https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com" > ~/.git-credentials
+          chmod 600 ~/.git-credentials
+
+          # Also set the URL replacement as before
+          git config --global \
+            url."https://${VERIFICATION_EZKL_TOKEN}:x-oauth-basic@github.com/".insteadOf \
+            "https://github.com/"
+        env:
+          VERIFICATION_EZKL_TOKEN: ${{ secrets.VERIFICATION_EZKL_TOKEN }}
+
       - uses: actions-rs/toolchain@b2417cde72dcf67f306c0ae8e0828a81bf0b189f  #v1.0.6
         with:
           toolchain: nightly-2025-02-17
@@ -875,4 +1314,4 @@ jobs:
             -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=17.5' \
             -parallel-testing-enabled NO \
             -resultBundlePath ../../exampleTestResults \
-            -skip-testing:EzklAppUITests/EzklAppUITests/testButtonClicksInOrder
+            -skip-testing:EzklAppUITests/EzklAppUITests/testButtonClicksInOrder

.gitignore

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

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,7 @@ 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/verification-ezkl", branch = "vka-hash", optional = true }
 maybe-rayon = { version = "0.1.1", default-features = false }
 bincode = { version = "1.3.3", default-features = false }
 unzip-n = "0.1.2"
@@ -69,20 +69,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 }
@@ -219,15 +217,15 @@ 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"]
+ios-bindings = ["eth-mv-lookup", "precompute-coset", "parallel-poly-read", "uniffi"]
 ios-bindings-test = ["ios-bindings", "uniffi/bindgen-tests"]
 ezkl = [
     "onnx",
@@ -236,14 +234,10 @@ ezkl = [
     "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",
@@ -251,11 +245,30 @@ ezkl = [
     "dep:chrono",
     "dep:sha256",
     "dep:clap_complete",
-    "dep:halo2_solidity_verifier",
     "dep:semver",
     "dep:clap",
     "dep:tosubcommand",
 ]
+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",
@@ -263,7 +276,6 @@ parallel-poly-read = [
 mv-lookup = [
     "halo2_proofs/mv-lookup",
     "snark-verifier/mv-lookup",
-    "halo2_solidity_verifier/mv-lookup",
 ]
 asm = ["halo2curves/asm", "halo2_proofs/asm"]
 precompute-coset = ["halo2_proofs/precompute-coset"]
@@ -275,12 +287,6 @@ 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" }
-
 
 [patch.crates-io]
 uniffi_testing = { git = "https://github.com/ElusAegis/uniffi-rs", branch = "feat/testing-feature-build-fix" }
@@ -289,7 +295,7 @@ uniffi_testing = { git = "https://github.com/ElusAegis/uniffi-rs", branch = "fea
 rustflags = ["-C", "relocation-model=pic"]
 lto = "fat"
 codegen-units = 1
-#panic = "abort"
+# panic = "abort"
 
 
 [profile.test-runs]
@@ -297,8 +303,4 @@ inherits = "dev"
 opt-level = 3
 
 [package.metadata.wasm-pack.profile.release]
-wasm-opt = [
-    "-O4",
-    "--flexible-inline-max-function-size",
-    "4294967295",
-]
+wasm-opt = ["-O4", "--flexible-inline-max-function-size", "4294967295"]

README.md

@@ -43,7 +43,7 @@ The generated proofs can then be verified with much less computational resources
 
 ----------------------
 
-### getting started ⚙️
+### Getting Started ⚙️
 
 The easiest way to get started is to try out a notebook. 
 
@@ -76,12 +76,12 @@ 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
+#### In-browser EVM Verifier
 
 As an alternative to running the native Halo2 verifier as a WASM binding in the browser, you can use the in-browser EVM verifier. The source code of which you can find in the `in-browser-evm-verifier` directory and a README with instructions on how to use it.
 
 
-### building the project 🔨
+### Building the Project 🔨
 
 #### Rust CLI
 
@@ -96,7 +96,7 @@ cargo install --locked --path .
 
 
 
-#### building python bindings
+#### Building Python Bindings
 Python bindings exists and can be built using `maturin`. You will need `rust` and `cargo` to be installed.
 
 ```bash
@@ -126,7 +126,7 @@ unset ENABLE_ICICLE_GPU
 
 **NOTE:** Even with the above environment variable set, icicle is disabled for circuits where k <= 8. To change the value of `k` where icicle is enabled, you can set the environment variable `ICICLE_SMALL_K`.
 
-### contributing 🌎
+### Contributing 🌎
 
 If you're interested in contributing and are unsure where to start, reach out to one of the maintainers:
 
@@ -144,20 +144,21 @@ More broadly:
 
 Any contribution intentionally submitted for inclusion in the work by you shall be licensed to Zkonduit Inc. under the terms and conditions specified in the [CLA](https://github.com/zkonduit/ezkl/blob/main/cla.md), which you agree to by intentionally submitting a contribution. In particular, you have the right to submit the contribution and we can distribute it, among other terms and conditions. 
 
-### no security guarantees
 
-Ezkl is unaudited, beta software undergoing rapid development. There may be bugs. No guarantees of security are made and it should not be relied on in production.
+### Audits & Security
 
-> NOTE: Because operations are quantized when they are converted from an onnx file to a zk-circuit, outputs in python and ezkl may differ slightly. 
+[v21.0.0](https://github.com/zkonduit/ezkl/releases/tag/v21.0.0) has been audited by Trail of Bits, the report can be found [here](https://github.com/trailofbits/publications/blob/master/reviews/2025-03-zkonduit-ezkl-securityreview.pdf).
+
+> NOTE: Because operations are quantized when they are converted from an onnx file to a zk-circuit, outputs in python and ezkl may differ slightly.
 
 
-### Advanced security topics 
-
-Check out `docs/advanced_security` for more advanced information on potential threat vectors. 
+Check out `docs/advanced_security` for more advanced information on potential threat vectors that are specific to zero-knowledge inference, quantization, and to machine learning models generally.
 
 
+### No Warranty
 
-### no warranty
-
-Copyright (c) 2024 Zkonduit Inc. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Copyright (c) 2025 Zkonduit Inc. 
+

abis/DataAttestation.json

@@ -0,0 +1,312 @@
+[
+    {
+        "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/DataAttestationMulti.json

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

abis/DataAttestationSingle.json

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

contracts/AttestData.sol

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

docs/advanced_security/quantization_backdoors.md

@@ -1,20 +1,52 @@
-# EZKL Security Note: Quantization-Induced Model Backdoors
+# EZKL Security Note: Quantization-Activated Model Backdoors
 
-> Note: this only affects a situation where a party separate to an application's developer has access to the model's weights and can modify them. This is a common scenario in adversarial machine learning research, but can be less common in real-world applications. If you're building your models in house and deploying them yourself, this is less of a concern. If you're building a permisionless system where anyone can submit models, this is more of a concern.
+## Model backdoors and provenance
 
-Models processed through EZKL's quantization step can harbor backdoors that are dormant in the original full-precision model but activate during quantization. These backdoors force specific outputs when triggered, with impact varying by application.
+Machine learning models inherently suffer from robustness issues, which can lead to various
+kinds of attacks, from backdoors to evasion attacks. These vulnerabilities are a direct byproductof how machine learning models learn and cannot be remediated.
 
-Key Factors:
+We say a model has a backdoor whenever a specific attacker-chosen trigger in the input leads
+to the model misbehaving. For instance, if we have an image classifier discriminating cats from dogs, the ability to turn any image of a cat into an image classified as a dog by changing a specific pixel pattern constitutes a backdoor.
 
-- Larger models increase attack feasibility through more parameter capacity
-- Smaller quantization scales facilitate attacks by allowing greater weight modifications
-- Rebase ratio of 1 enables exploitation of convolutional layer consistency
+Backdoors can be introduced using many different vectors. An attacker can introduce a
+backdoor using traditional security vulnerabilities. For instance, they could directly alter the file containing model weights or dynamically hack the Python code of the model. In addition, backdoors can be introduced by the training data through a process known as poisoning. In this case, an attacker adds malicious data points to the dataset before the model is trained so that the model learns to associate the backdoor trigger with the intended misbehavior.
 
-Limitations: 
+All these vectors constitute a whole range of provenance challenges, as any component of an
+AI system can virtually be an entrypoint for a backdoor. Although provenance is already a
+concern with traditional code, the issue is exacerbated with AI, as retraining a model is
+cost-prohibitive. It is thus impractical to translate the “recompile it yourself” thinking to AI.
 
-- Attack effectiveness depends on calibration settings and internal rescaling operations. 
+## Quantization activated backdoors
+
+Backdoors are a generic concern in AI that is outside the scope of EZKL. However, EZKL may
+activate a specific subset of backdoors. Several academic papers have demonstrated the
+possibility, both in theory and in practice, of implanting undetectable and inactive backdoors in a full precision model that can be reactivated by quantization.
+
+An external attacker may trick the user of an application running EZKL into loading a model
+containing a quantization backdoor. This backdoor is active in the resulting model and circuit but not in the full-precision model supplied to EZKL, compromising the integrity of the target application and the resulting proof.
+
+### When is this a concern for me as a user?
+
+Any untrusted component in your AI stack may be a backdoor vector. In practice, the most
+sensitive parts include:
+
+- Datasets downloaded from the web or containing crowdsourced data
+- Models downloaded from the web even after finetuning
+- Untrusted software dependencies (well-known frameworks such as PyTorch can typically
+be considered trusted)
+- Any component loaded through an unsafe serialization format, such as Pickle.
+Because backdoors are inherent to ML and cannot be eliminated, reviewing the provenance of
+these sensitive components is especially important.
+
+### Responsibilities of the user and EZKL
+
+As EZKL cannot prevent backdoored models from being used, it is the responsibility of the user to review the provenance of all the components in their AI stack to ensure that no backdoor could have been implanted. EZKL shall not be held responsible for misleading prediction proofs resulting from using a backdoored model or for any harm caused to a system or its users due to a misbehaving model.
+
+### Limitations:
+
+- Attack effectiveness depends on calibration settings and internal rescaling operations.
 - Further research needed on backdoor persistence through witness/proof stages.
-- Can be mitigated by evaluating the quantized model (using `ezkl gen-witness`), rather than relying on the evaluation of the original model. 
+- Can be mitigated by evaluating the quantized model (using `ezkl gen-witness`), rather than relying on the evaluation of the original model in pytorch or onnx-runtime as difference in evaluation could reveal a backdoor.
 
 References:
 

examples/notebooks/cat_and_dog.ipynb

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

examples/notebooks/data_attest.ipynb

@@ -1,601 +0,0 @@
-{
-    "cells": [
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "# data-attest-ezkl\n",
-                "\n",
-                "Here's an example leveraging EZKL whereby the inputs to the model are read and attested to from an on-chain source.\n",
-                "\n",
-                "In this setup:\n",
-                "- the inputs and outputs are publicly known to the prover and verifier\n",
-                "- the on chain inputs will be fetched and then fed directly into the circuit\n",
-                "- the quantization of the on-chain inputs happens within the evm and is replicated at proving time \n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "First we import the necessary dependencies and set up logging to be as informative as possible. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# check if notebook is in colab\n",
-                "try:\n",
-                "    # install ezkl\n",
-                "    import google.colab\n",
-                "    import subprocess\n",
-                "    import sys\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
-                "\n",
-                "# rely on local installation of ezkl if the notebook is not in colab\n",
-                "except:\n",
-                "    pass\n",
-                "\n",
-                "\n",
-                "from torch import nn\n",
-                "import ezkl\n",
-                "import os\n",
-                "import json\n",
-                "import logging\n",
-                "\n",
-                "# uncomment for more descriptive logging \n",
-                "FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
-                "logging.basicConfig(format=FORMAT)\n",
-                "logging.getLogger().setLevel(logging.DEBUG)\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we define our model. It is a very simple PyTorch model that has just one layer, an average pooling 2D layer. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import torch\n",
-                "# Defines the model\n",
-                "\n",
-                "class MyModel(nn.Module):\n",
-                "    def __init__(self):\n",
-                "        super(MyModel, self).__init__()\n",
-                "        self.layer = nn.AvgPool2d(2, 1, (1, 1))\n",
-                "\n",
-                "    def forward(self, x):\n",
-                "        return self.layer(x)[0]\n",
-                "\n",
-                "\n",
-                "circuit = MyModel()\n",
-                "\n",
-                "# this is where you'd train your model"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We omit training for purposes of this demonstration. We've marked where training would happen in the cell above. \n",
-                "Now we export the model to onnx and create a corresponding (randomly generated) input. This input data will eventually be stored on chain and read from according to the call_data field in the graph input.\n",
-                "\n",
-                "You can replace the random `x` with real data if you so wish. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "x = 0.1*torch.rand(1,*[3, 2, 2], requires_grad=True)\n",
-                "\n",
-                "# Flips the neural net into inference mode\n",
-                "circuit.eval()\n",
-                "\n",
-                "    # Export the model\n",
-                "torch.onnx.export(circuit,               # model being run\n",
-                "                      x,                   # model input (or a tuple for multiple inputs)\n",
-                "                      \"network.onnx\",            # where to save the model (can be a file or file-like object)\n",
-                "                      export_params=True,        # store the trained parameter weights inside the model file\n",
-                "                      opset_version=10,          # the ONNX version to export the model to\n",
-                "                      do_constant_folding=True,  # whether to execute constant folding for optimization\n",
-                "                      input_names = ['input'],   # the model's input names\n",
-                "                      output_names = ['output'], # the model's output names\n",
-                "                      dynamic_axes={'input' : {0 : 'batch_size'},    # variable length axes\n",
-                "                                    'output' : {0 : 'batch_size'}})\n",
-                "\n",
-                "data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
-                "\n",
-                "data = dict(input_data = [data_array])\n",
-                "\n",
-                "    # Serialize data into file:\n",
-                "json.dump(data, open(\"input.json\", 'w' ))\n",
-                "\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now define a function that will create a new anvil instance which we will deploy our test contract too. This contract will contain in its storage the data that we will read from and attest to. In production you would not need to set up a local anvil instance. Instead you would replace RPC_URL with the actual RPC endpoint of the chain you are deploying your verifiers too, reading from the data on said chain."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import subprocess\n",
-                "import time\n",
-                "import threading\n",
-                "\n",
-                "# make sure anvil is running locally\n",
-                "# $ anvil -p 3030\n",
-                "\n",
-                "RPC_URL = \"http://localhost:3030\"\n",
-                "\n",
-                "# Save process globally\n",
-                "anvil_process = None\n",
-                "\n",
-                "def start_anvil():\n",
-                "    global anvil_process\n",
-                "    if anvil_process is None:\n",
-                "        anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--code-size-limit=41943040\"])\n",
-                "        if anvil_process.returncode is not None:\n",
-                "            raise Exception(\"failed to start anvil process\")\n",
-                "        time.sleep(3)\n",
-                "\n",
-                "def stop_anvil():\n",
-                "    global anvil_process\n",
-                "    if anvil_process is not None:\n",
-                "        anvil_process.terminate()\n",
-                "        anvil_process = None\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
-                "- `input_visibility` defines the visibility of the model inputs\n",
-                "- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
-                "- `output_visibility` defines the visibility of the model outputs\n",
-                "\n",
-                "Here we create the following setup:\n",
-                "- `input_visibility`: \"public\"\n",
-                "- `param_visibility`: \"private\"\n",
-                "- `output_visibility`: public\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import ezkl\n",
-                "\n",
-                "model_path = os.path.join('network.onnx')\n",
-                "compiled_model_path = os.path.join('network.compiled')\n",
-                "pk_path = os.path.join('test.pk')\n",
-                "vk_path = os.path.join('test.vk')\n",
-                "settings_path = os.path.join('settings.json')\n",
-                "srs_path = os.path.join('kzg.srs')\n",
-                "data_path = os.path.join('input.json')\n",
-                "\n",
-                "run_args = ezkl.PyRunArgs()\n",
-                "run_args.input_visibility = \"public\"\n",
-                "run_args.param_visibility = \"private\"\n",
-                "run_args.output_visibility = \"public\"\n",
-                "run_args.num_inner_cols = 1\n",
-                "run_args.variables = [(\"batch_size\", 1)]\n",
-                "\n",
-                "\n",
-                "\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
-                "\n",
-                "You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "!RUST_LOG=trace\n",
-                "# TODO: Dictionary outputs\n",
-                "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# generate a bunch of dummy calibration data\n",
-                "cal_data = {\n",
-                "    \"input_data\": [(0.1*torch.rand(2, *[3, 2, 2])).flatten().tolist()],\n",
-                "}\n",
-                "\n",
-                "cal_path = os.path.join('val_data.json')\n",
-                "# save as json file\n",
-                "with open(cal_path, \"w\") as f:\n",
-                "    json.dump(cal_data, f)\n",
-                "\n",
-                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "The graph input for on chain data sources is formatted completely differently compared to file based data sources.\n",
-                "\n",
-                "- For file data sources, the raw floating point values that eventually get quantized, converted into field elements and stored in `witness.json` to be consumed by the circuit are stored. The output data contains the expected floating point values returned as outputs from running your vanilla pytorch model on the given inputs.\n",
-                "- For on chain data sources, the input_data field contains all the data necessary to read and format the on chain data into something digestable by EZKL (aka field elements :-D). \n",
-                "Here is what the schema for an on-chain data source graph input file should look like:\n",
-                "    \n",
-                "```json\n",
-                "{\n",
-                "  \"input_data\": {\n",
-                "    \"rpc\": \"http://localhost:3030\", // The rpc endpoint of the chain you are deploying your verifier to\n",
-                "    \"calls\": [\n",
-                "      {\n",
-                "        \"call_data\": [\n",
-                "          [\n",
-                "            \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000000\", // The abi encoded call data to a view function that returns a single on-chain data point (we only support uint256 returns for now)\n",
-                "            7 // The number of decimal places of the large uint256 value. This is our way of representing large wei values as floating points on chain, since the evm only natively supports integer values.\n",
-                "          ],\n",
-                "          [\n",
-                "            \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000001\",\n",
-                "            5\n",
-                "          ],\n",
-                "          [\n",
-                "            \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000002\",\n",
-                "            5\n",
-                "          ]\n",
-                "        ],\n",
-                "        \"address\": \"5fbdb2315678afecb367f032d93f642f64180aa3\" // The address of the contract that we are calling to get the data. \n",
-                "      }\n",
-                "    ]\n",
-                "  }\n",
-                "}"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "await ezkl.setup_test_evm_witness(\n",
-                "    data_path,\n",
-                "    compiled_model_path,\n",
-                "    # we write the call data to the same file as the input data\n",
-                "    data_path,\n",
-                "    input_source=ezkl.PyTestDataSource.OnChain,\n",
-                "    output_source=ezkl.PyTestDataSource.File,\n",
-                "    rpc_url=RPC_URL)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
-                "\n",
-                "These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = await ezkl.get_srs( settings_path)\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now need to generate the circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "!export RUST_BACKTRACE=1\n",
-                "\n",
-                "witness_path = \"witness.json\"\n",
-                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# HERE WE SETUP THE CIRCUIT PARAMS\n",
-                "# WE GOT KEYS\n",
-                "# WE GOT CIRCUIT PARAMETERS\n",
-                "# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
-                "res = ezkl.setup(\n",
-                "        compiled_model_path,\n",
-                "        vk_path,\n",
-                "        pk_path,\n",
-                "        \n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "assert os.path.isfile(vk_path)\n",
-                "assert os.path.isfile(pk_path)\n",
-                "assert os.path.isfile(settings_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we generate a full proof. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# GENERATE A PROOF\n",
-                "\n",
-                "proof_path = os.path.join('test.pf')\n",
-                "\n",
-                "res = ezkl.prove(\n",
-                "        witness_path,\n",
-                "        compiled_model_path,\n",
-                "        pk_path,\n",
-                "        proof_path,\n",
-                "        \n",
-                "        \"single\",\n",
-                "    )\n",
-                "\n",
-                "print(res)\n",
-                "assert os.path.isfile(proof_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "And verify it as a sanity check. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# VERIFY IT\n",
-                "\n",
-                "res = ezkl.verify(\n",
-                "        proof_path,\n",
-                "        settings_path,\n",
-                "        vk_path,\n",
-                "        \n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "print(\"verified\")"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We can now create and then deploy a vanilla evm verifier."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "\n",
-                "res = await ezkl.create_evm_verifier(\n",
-                "        vk_path,\n",
-                "        \n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "    )\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import json\n",
-                "\n",
-                "addr_path_verifier = \"addr_verifier.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_evm(\n",
-                "    addr_path_verifier,\n",
-                "    sol_code_path,\n",
-                "    'http://127.0.0.1:3030'\n",
-                ")\n",
-                "\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "With the vanilla verifier deployed, we can now create the data attestation contract, which will read in the instances from the calldata to the verifier, attest to them, call the verifier and then return the result. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "input_path = 'input.json'\n",
-                "\n",
-                "res = await ezkl.create_evm_data_attestation(\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "    )"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we can deploy the data attest verifier contract. For security reasons, this binding will only deploy to a local anvil instance, using accounts generated by anvil. \n",
-                "So should only be used for testing purposes."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "addr_path_da = \"addr_da.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_da_evm(\n",
-                "        addr_path_da,\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        RPC_URL,\n",
-                "    )\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# read the verifier address\n",
-                "addr_verifier = None\n",
-                "with open(addr_path_verifier, 'r') as f:\n",
-                "    addr = f.read()\n",
-                "#read the data attestation address\n",
-                "addr_da = None\n",
-                "with open(addr_path_da, 'r') as f:\n",
-                "    addr_da = f.read()\n",
-                "\n",
-                "res = await ezkl.verify_evm(\n",
-                "    addr,\n",
-                "    proof_path,\n",
-                "    RPC_URL,\n",
-                "    addr_da,\n",
-                ")"
-            ]
-        }
-    ],
-    "metadata": {
-        "kernelspec": {
-            "display_name": "ezkl",
-            "language": "python",
-            "name": "python3"
-        },
-        "language_info": {
-            "codemirror_mode": {
-                "name": "ipython",
-                "version": 3
-            },
-            "file_extension": ".py",
-            "mimetype": "text/x-python",
-            "name": "python",
-            "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3",
-            "version": "3.12.5"
-        },
-        "orig_nbformat": 4
-    },
-    "nbformat": 4,
-    "nbformat_minor": 2
-}

examples/notebooks/data_attest_hashed.ipynb

@@ -1,657 +0,0 @@
-{
-    "cells": [
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "# data-attest-ezkl hashed\n",
-                "\n",
-                "Here's an example leveraging EZKL whereby the hashes of the outputs to the model are read and attested to from an on-chain source.\n",
-                "\n",
-                "In this setup:\n",
-                "- the hashes of outputs are publicly known to the prover and verifier\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "First we import the necessary dependencies and set up logging to be as informative as possible. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# check if notebook is in colab\n",
-                "try:\n",
-                "    # install ezkl\n",
-                "    import google.colab\n",
-                "    import subprocess\n",
-                "    import sys\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
-                "\n",
-                "# rely on local installation of ezkl if the notebook is not in colab\n",
-                "except:\n",
-                "    pass\n",
-                "\n",
-                "\n",
-                "from torch import nn\n",
-                "import ezkl\n",
-                "import os\n",
-                "import json\n",
-                "import logging\n",
-                "\n",
-                "# uncomment for more descriptive logging \n",
-                "# FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
-                "# logging.basicConfig(format=FORMAT)\n",
-                "# logging.getLogger().setLevel(logging.DEBUG)\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we define our model. It is a very simple PyTorch model that has just one layer, an average pooling 2D layer. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import torch\n",
-                "# Defines the model\n",
-                "\n",
-                "class MyModel(nn.Module):\n",
-                "    def __init__(self):\n",
-                "        super(MyModel, self).__init__()\n",
-                "        self.layer = nn.AvgPool2d(2, 1, (1, 1))\n",
-                "\n",
-                "    def forward(self, x):\n",
-                "        return self.layer(x)[0]\n",
-                "\n",
-                "\n",
-                "circuit = MyModel()\n",
-                "\n",
-                "# this is where you'd train your model\n",
-                "\n",
-                "\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We omit training for purposes of this demonstration. We've marked where training would happen in the cell above. \n",
-                "Now we export the model to onnx and create a corresponding (randomly generated) input. This input data will eventually be stored on chain and read from according to the call_data field in the graph input.\n",
-                "\n",
-                "You can replace the random `x` with real data if you so wish. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "x = 0.1*torch.rand(1,*[3, 2, 2], requires_grad=True)\n",
-                "\n",
-                "# Flips the neural net into inference mode\n",
-                "circuit.eval()\n",
-                "\n",
-                "    # Export the model\n",
-                "torch.onnx.export(circuit,               # model being run\n",
-                "                      x,                   # model input (or a tuple for multiple inputs)\n",
-                "                      \"network.onnx\",            # where to save the model (can be a file or file-like object)\n",
-                "                      export_params=True,        # store the trained parameter weights inside the model file\n",
-                "                      opset_version=10,          # the ONNX version to export the model to\n",
-                "                      do_constant_folding=True,  # whether to execute constant folding for optimization\n",
-                "                      input_names = ['input'],   # the model's input names\n",
-                "                      output_names = ['output'], # the model's output names\n",
-                "                      dynamic_axes={'input' : {0 : 'batch_size'},    # variable length axes\n",
-                "                                    'output' : {0 : 'batch_size'}})\n",
-                "\n",
-                "data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
-                "\n",
-                "data = dict(input_data = [data_array])\n",
-                "\n",
-                "    # Serialize data into file:\n",
-                "json.dump(data, open(\"input.json\", 'w' ))\n",
-                "\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now define a function that will create a new anvil instance which we will deploy our test contract too. This contract will contain in its storage the data that we will read from and attest to. In production you would not need to set up a local anvil instance. Instead you would replace RPC_URL with the actual RPC endpoint of the chain you are deploying your verifiers too, reading from the data on said chain."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import subprocess\n",
-                "import time\n",
-                "import threading\n",
-                "\n",
-                "# make sure anvil is running locally\n",
-                "# $ anvil -p 3030\n",
-                "\n",
-                "RPC_URL = \"http://localhost:3030\"\n",
-                "\n",
-                "# Save process globally\n",
-                "anvil_process = None\n",
-                "\n",
-                "def start_anvil():\n",
-                "    global anvil_process\n",
-                "    if anvil_process is None:\n",
-                "        anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--code-size-limit=41943040\"])\n",
-                "        if anvil_process.returncode is not None:\n",
-                "            raise Exception(\"failed to start anvil process\")\n",
-                "        time.sleep(3)\n",
-                "\n",
-                "def stop_anvil():\n",
-                "    global anvil_process\n",
-                "    if anvil_process is not None:\n",
-                "        anvil_process.terminate()\n",
-                "        anvil_process = None\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
-                "- `input_visibility` defines the visibility of the model inputs\n",
-                "- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
-                "- `output_visibility` defines the visibility of the model outputs\n",
-                "\n",
-                "Here we create the following setup:\n",
-                "- `input_visibility`: \"private\"\n",
-                "- `param_visibility`: \"private\"\n",
-                "- `output_visibility`: hashed\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import ezkl\n",
-                "\n",
-                "model_path = os.path.join('network.onnx')\n",
-                "compiled_model_path = os.path.join('network.compiled')\n",
-                "pk_path = os.path.join('test.pk')\n",
-                "vk_path = os.path.join('test.vk')\n",
-                "settings_path = os.path.join('settings.json')\n",
-                "srs_path = os.path.join('kzg.srs')\n",
-                "data_path = os.path.join('input.json')\n",
-                "\n",
-                "run_args = ezkl.PyRunArgs()\n",
-                "run_args.input_visibility = \"private\"\n",
-                "run_args.param_visibility = \"private\"\n",
-                "run_args.output_visibility = \"hashed\"\n",
-                "run_args.variables = [(\"batch_size\", 1)]\n",
-                "\n",
-                "\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
-                "\n",
-                "You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "!RUST_LOG=trace\n",
-                "# TODO: Dictionary outputs\n",
-                "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# generate a bunch of dummy calibration data\n",
-                "cal_data = {\n",
-                "    \"input_data\": [(0.1*torch.rand(2, *[3, 2, 2])).flatten().tolist()],\n",
-                "}\n",
-                "\n",
-                "cal_path = os.path.join('val_data.json')\n",
-                "# save as json file\n",
-                "with open(cal_path, \"w\") as f:\n",
-                "    json.dump(cal_data, f)\n",
-                "\n",
-                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
-                "\n",
-                "These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = await ezkl.get_srs( settings_path)\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now need to generate the circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "!export RUST_BACKTRACE=1\n",
-                "\n",
-                "witness_path = \"witness.json\"\n",
-                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
-                "\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "print(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]))"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now post the hashes of the outputs to the chain. This is the data that will be read from and attested to."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "from web3 import Web3, HTTPProvider\n",
-                "from solcx import compile_standard\n",
-                "from decimal import Decimal\n",
-                "import json\n",
-                "import os\n",
-                "import torch\n",
-                "\n",
-                "\n",
-                "# setup web3 instance\n",
-                "w3 = Web3(HTTPProvider(RPC_URL))\n",
-                "\n",
-                "def test_on_chain_data(res):\n",
-                "    # Step 0: Convert the tensor to a flat list\n",
-                "    data = [int(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
-                "\n",
-                "    # Step 1: Prepare the data\n",
-                "    # Step 2: Prepare and compile the contract.\n",
-                "    # We are using a test contract here but in production you would\n",
-                "    # use whatever contract you are fetching data from.\n",
-                "    contract_source_code = '''\n",
-                "    // SPDX-License-Identifier: UNLICENSED\n",
-                "    pragma solidity ^0.8.17;\n",
-                "\n",
-                "    contract TestReads {\n",
-                "\n",
-                "        uint[] public arr;\n",
-                "        constructor(uint256[] memory _numbers) {\n",
-                "            for(uint256 i = 0; i < _numbers.length; i++) {\n",
-                "                arr.push(_numbers[i]);\n",
-                "            }\n",
-                "        }\n",
-                "    }\n",
-                "    '''\n",
-                "\n",
-                "    compiled_sol = compile_standard({\n",
-                "        \"language\": \"Solidity\",\n",
-                "        \"sources\": {\"testreads.sol\": {\"content\": contract_source_code}},\n",
-                "        \"settings\": {\"outputSelection\": {\"*\": {\"*\": [\"metadata\", \"evm.bytecode\", \"abi\"]}}}\n",
-                "    })\n",
-                "\n",
-                "    # Get bytecode\n",
-                "    bytecode = compiled_sol['contracts']['testreads.sol']['TestReads']['evm']['bytecode']['object']\n",
-                "\n",
-                "    # Get ABI\n",
-                "    # In production if you are reading from really large contracts you can just use\n",
-                "    # a stripped down version of the ABI of the contract you are calling, containing only the view functions you will fetch data from.\n",
-                "    abi = json.loads(compiled_sol['contracts']['testreads.sol']['TestReads']['metadata'])['output']['abi']\n",
-                "\n",
-                "    # Step 3: Deploy the contract\n",
-                "    TestReads = w3.eth.contract(abi=abi, bytecode=bytecode)\n",
-                "    tx_hash = TestReads.constructor(data).transact()\n",
-                "    tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)\n",
-                "    # If you are deploying to production you can skip the 3 lines of code above and just instantiate the contract like this,\n",
-                "    # passing the address and abi of the contract you are fetching data from.\n",
-                "    contract = w3.eth.contract(address=tx_receipt['contractAddress'], abi=abi)\n",
-                "\n",
-                "    # Step 4: Interact with the contract\n",
-                "    calldata = []\n",
-                "    for i, _ in enumerate(data):\n",
-                "        call = contract.functions.arr(i).build_transaction()\n",
-                "        calldata.append((call['data'][2:], 0))\n",
-                "\n",
-                "    # Prepare the calls_to_account object\n",
-                "    # If you were calling view functions across multiple contracts,\n",
-                "    # you would have multiple entries in the calls_to_account array,\n",
-                "    # one for each contract.\n",
-                "    calls_to_account = [{\n",
-                "        'call_data': calldata,\n",
-                "        'address': contract.address[2:], # remove the '0x' prefix\n",
-                "    }]\n",
-                "\n",
-                "    print(f'calls_to_account: {calls_to_account}')\n",
-                "\n",
-                "    return calls_to_account\n",
-                "\n",
-                "# Now let's start the Anvil process. You don't need to do this if you are deploying to a non-local chain.\n",
-                "start_anvil()\n",
-                "\n",
-                "# Now let's call our function, passing in the same input tensor we used to export the model 2 cells above.\n",
-                "calls_to_account = test_on_chain_data(res)\n",
-                "\n",
-                "data = dict(input_data = [data_array], output_data =  {'rpc': RPC_URL, 'calls': calls_to_account })\n",
-                "\n",
-                "# Serialize on-chain data into file:\n",
-                "json.dump(data, open(\"input.json\", 'w'))\n",
-                "\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# HERE WE SETUP THE CIRCUIT PARAMS\n",
-                "# WE GOT KEYS\n",
-                "# WE GOT CIRCUIT PARAMETERS\n",
-                "# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
-                "res = ezkl.setup(\n",
-                "        compiled_model_path,\n",
-                "        vk_path,\n",
-                "        pk_path,\n",
-                "        \n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "assert os.path.isfile(vk_path)\n",
-                "assert os.path.isfile(pk_path)\n",
-                "assert os.path.isfile(settings_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we generate a full proof. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# GENERATE A PROOF\n",
-                "\n",
-                "proof_path = os.path.join('test.pf')\n",
-                "\n",
-                "res = ezkl.prove(\n",
-                "        witness_path,\n",
-                "        compiled_model_path,\n",
-                "        pk_path,\n",
-                "        proof_path,\n",
-                "        \n",
-                "        \"single\",\n",
-                "    )\n",
-                "\n",
-                "print(res)\n",
-                "assert os.path.isfile(proof_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "And verify it as a sanity check. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# VERIFY IT\n",
-                "\n",
-                "res = ezkl.verify(\n",
-                "        proof_path,\n",
-                "        settings_path,\n",
-                "        vk_path,\n",
-                "        \n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "print(\"verified\")"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We can now create and then deploy a vanilla evm verifier."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "\n",
-                "res = await ezkl.create_evm_verifier(\n",
-                "        vk_path,\n",
-                "        \n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "    )\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import json\n",
-                "\n",
-                "addr_path_verifier = \"addr_verifier.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_evm(\n",
-                "    addr_path_verifier,\n",
-                "    sol_code_path,\n",
-                "    'http://127.0.0.1:3030'\n",
-                ")\n",
-                "\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "With the vanilla verifier deployed, we can now create the data attestation contract, which will read in the instances from the calldata to the verifier, attest to them, call the verifier and then return the result. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "input_path = 'input.json'\n",
-                "\n",
-                "res = await ezkl.create_evm_data_attestation(\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "    )"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we can deploy the data attest verifier contract. For security reasons, this binding will only deploy to a local anvil instance, using accounts generated by anvil. \n",
-                "So should only be used for testing purposes."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "addr_path_da = \"addr_da.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_da_evm(\n",
-                "        addr_path_da,\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        RPC_URL,\n",
-                "    )\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# read the verifier address\n",
-                "addr_verifier = None\n",
-                "with open(addr_path_verifier, 'r') as f:\n",
-                "    addr = f.read()\n",
-                "#read the data attestation address\n",
-                "addr_da = None\n",
-                "with open(addr_path_da, 'r') as f:\n",
-                "    addr_da = f.read()\n",
-                "\n",
-                "res = await ezkl.verify_evm(\n",
-                "    addr,\n",
-                "    proof_path,\n",
-                "    RPC_URL,\n",
-                "    addr_da,\n",
-                ")"
-            ]
-        }
-    ],
-    "metadata": {
-        "kernelspec": {
-            "display_name": "ezkl",
-            "language": "python",
-            "name": "python3"
-        },
-        "language_info": {
-            "codemirror_mode": {
-                "name": "ipython",
-                "version": 3
-            },
-            "file_extension": ".py",
-            "mimetype": "text/x-python",
-            "name": "python",
-            "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3",
-            "version": "3.12.7"
-        },
-        "orig_nbformat": 4
-    },
-    "nbformat": 4,
-    "nbformat_minor": 2
-}

examples/notebooks/data_attest_kzg_vis.ipynb

@@ -1,604 +0,0 @@
-{
-    "cells": [
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "# data-attest-kzg-vis\n",
-                "\n",
-                "Here's an example leveraging EZKL whereby the inputs to the model are read and attested to from an on-chain source and the params and outputs are committed to using kzg-commitments. \n",
-                "\n",
-                "In this setup:\n",
-                "- the inputs and outputs are publicly known to the prover and verifier\n",
-                "- the on chain inputs will be fetched and then fed directly into the circuit\n",
-                "- the quantization of the on-chain inputs happens within the evm and is replicated at proving time \n",
-                "- The kzg commitment to the params and inputs will be read from the proof and checked to make sure it matches the expected commitment stored on-chain.\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "First we import the necessary dependencies and set up logging to be as informative as possible. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# check if notebook is in colab\n",
-                "try:\n",
-                "    # install ezkl\n",
-                "    import google.colab\n",
-                "    import subprocess\n",
-                "    import sys\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
-                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
-                "\n",
-                "# rely on local installation of ezkl if the notebook is not in colab\n",
-                "except:\n",
-                "    pass\n",
-                "\n",
-                "\n",
-                "from torch import nn\n",
-                "import ezkl\n",
-                "import os\n",
-                "import json\n",
-                "import logging\n",
-                "\n",
-                "# uncomment for more descriptive logging \n",
-                "FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
-                "logging.basicConfig(format=FORMAT)\n",
-                "logging.getLogger().setLevel(logging.DEBUG)\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we define our model. It is a very simple PyTorch model that has just one layer, an average pooling 2D layer. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import torch\n",
-                "# Defines the model\n",
-                "\n",
-                "class MyModel(nn.Module):\n",
-                "    def __init__(self):\n",
-                "        super(MyModel, self).__init__()\n",
-                "        self.layer = nn.AvgPool2d(2, 1, (1, 1))\n",
-                "\n",
-                "    def forward(self, x):\n",
-                "        return self.layer(x)[0]\n",
-                "\n",
-                "\n",
-                "circuit = MyModel()\n",
-                "\n",
-                "# this is where you'd train your model"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We omit training for purposes of this demonstration. We've marked where training would happen in the cell above. \n",
-                "Now we export the model to onnx and create a corresponding (randomly generated) input. This input data will eventually be stored on chain and read from according to the call_data field in the graph input.\n",
-                "\n",
-                "You can replace the random `x` with real data if you so wish. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "x = 0.1*torch.rand(1,*[3, 2, 2], requires_grad=True)\n",
-                "\n",
-                "# Flips the neural net into inference mode\n",
-                "circuit.eval()\n",
-                "\n",
-                "    # Export the model\n",
-                "torch.onnx.export(circuit,               # model being run\n",
-                "                      x,                   # model input (or a tuple for multiple inputs)\n",
-                "                      \"network.onnx\",            # where to save the model (can be a file or file-like object)\n",
-                "                      export_params=True,        # store the trained parameter weights inside the model file\n",
-                "                      opset_version=10,          # the ONNX version to export the model to\n",
-                "                      do_constant_folding=True,  # whether to execute constant folding for optimization\n",
-                "                      input_names = ['input'],   # the model's input names\n",
-                "                      output_names = ['output'], # the model's output names\n",
-                "                      dynamic_axes={'input' : {0 : 'batch_size'},    # variable length axes\n",
-                "                                    'output' : {0 : 'batch_size'}})\n",
-                "\n",
-                "data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
-                "\n",
-                "data = dict(input_data = [data_array])\n",
-                "\n",
-                "    # Serialize data into file:\n",
-                "json.dump(data, open(\"input.json\", 'w' ))\n",
-                "\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now define a function that will create a new anvil instance which we will deploy our test contract too. This contract will contain in its storage the data that we will read from and attest to. In production you would not need to set up a local anvil instance. Instead you would replace RPC_URL with the actual RPC endpoint of the chain you are deploying your verifiers too, reading from the data on said chain."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import subprocess\n",
-                "import time\n",
-                "import threading\n",
-                "\n",
-                "# make sure anvil is running locally\n",
-                "# $ anvil -p 3030\n",
-                "\n",
-                "RPC_URL = \"http://localhost:3030\"\n",
-                "\n",
-                "# Save process globally\n",
-                "anvil_process = None\n",
-                "\n",
-                "def start_anvil():\n",
-                "    global anvil_process\n",
-                "    if anvil_process is None:\n",
-                "        anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--code-size-limit=41943040\"])\n",
-                "        if anvil_process.returncode is not None:\n",
-                "            raise Exception(\"failed to start anvil process\")\n",
-                "        time.sleep(3)\n",
-                "\n",
-                "def stop_anvil():\n",
-                "    global anvil_process\n",
-                "    if anvil_process is not None:\n",
-                "        anvil_process.terminate()\n",
-                "        anvil_process = None\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
-                "- `input_visibility` defines the visibility of the model inputs\n",
-                "- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
-                "- `output_visibility` defines the visibility of the model outputs\n",
-                "\n",
-                "Here we create the following setup:\n",
-                "- `input_visibility`: \"public\"\n",
-                "- `param_visibility`: \"polycommitment\" \n",
-                "- `output_visibility`: \"polycommitment\"\n",
-                "\n",
-                "**Note**:\n",
-                "When we set this to polycommitment, we are saying that the model parameters are committed to using a polynomial commitment scheme. This commitment will be stored on chain as a constant stored in the DA contract, and the proof will contain the commitment to the parameters. The DA verification will then check that the commitment in the proof matches the commitment stored on chain. \n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import ezkl\n",
-                "\n",
-                "model_path = os.path.join('network.onnx')\n",
-                "compiled_model_path = os.path.join('network.compiled')\n",
-                "pk_path = os.path.join('test.pk')\n",
-                "vk_path = os.path.join('test.vk')\n",
-                "settings_path = os.path.join('settings.json')\n",
-                "srs_path = os.path.join('kzg.srs')\n",
-                "data_path = os.path.join('input.json')\n",
-                "\n",
-                "run_args = ezkl.PyRunArgs()\n",
-                "run_args.input_visibility = \"public\"\n",
-                "run_args.param_visibility = \"polycommit\"\n",
-                "run_args.output_visibility = \"polycommit\"\n",
-                "run_args.num_inner_cols = 1\n",
-                "run_args.variables = [(\"batch_size\", 1)]\n",
-                "\n",
-                "\n",
-                "\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
-                "\n",
-                "You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "!RUST_LOG=trace\n",
-                "# TODO: Dictionary outputs\n",
-                "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# generate a bunch of dummy calibration data\n",
-                "cal_data = {\n",
-                "    \"input_data\": [(0.1*torch.rand(2, *[3, 2, 2])).flatten().tolist()],\n",
-                "}\n",
-                "\n",
-                "cal_path = os.path.join('val_data.json')\n",
-                "# save as json file\n",
-                "with open(cal_path, \"w\") as f:\n",
-                "    json.dump(cal_data, f)\n",
-                "\n",
-                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "The graph input for on chain data sources is formatted completely differently compared to file based data sources.\n",
-                "\n",
-                "- For file data sources, the raw floating point values that eventually get quantized, converted into field elements and stored in `witness.json` to be consumed by the circuit are stored. The output data contains the expected floating point values returned as outputs from running your vanilla pytorch model on the given inputs.\n",
-                "- For on chain data sources, the input_data field contains all the data necessary to read and format the on chain data into something digestable by EZKL (aka field elements :-D). \n",
-                "Here is what the schema for an on-chain data source graph input file should look like:\n",
-                "    \n",
-                "```json\n",
-                "{\n",
-                "  \"input_data\": {\n",
-                "    \"rpc\": \"http://localhost:3030\", // The rpc endpoint of the chain you are deploying your verifier to\n",
-                "    \"calls\": [\n",
-                "      {\n",
-                "        \"call_data\": [\n",
-                "          [\n",
-                "            \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000000\", // The abi encoded call data to a view function that returns a single on-chain data point (we only support uint256 returns for now)\n",
-                "            7 // The number of decimal places of the large uint256 value. This is our way of representing large wei values as floating points on chain, since the evm only natively supports integer values.\n",
-                "          ],\n",
-                "          [\n",
-                "            \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000001\",\n",
-                "            5\n",
-                "          ],\n",
-                "          [\n",
-                "            \"71e5ee5f0000000000000000000000000000000000000000000000000000000000000002\",\n",
-                "            5\n",
-                "          ]\n",
-                "        ],\n",
-                "        \"address\": \"5fbdb2315678afecb367f032d93f642f64180aa3\" // The address of the contract that we are calling to get the data. \n",
-                "      }\n",
-                "    ]\n",
-                "  }\n",
-                "}"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "await ezkl.setup_test_evm_witness(\n",
-                "    data_path,\n",
-                "    compiled_model_path,\n",
-                "    # we write the call data to the same file as the input data\n",
-                "    data_path,\n",
-                "    input_source=ezkl.PyTestDataSource.OnChain,\n",
-                "    output_source=ezkl.PyTestDataSource.File,\n",
-                "    rpc_url=RPC_URL)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
-                "\n",
-                "These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = await ezkl.get_srs( settings_path)\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now need to generate the circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "!export RUST_BACKTRACE=1\n",
-                "\n",
-                "witness_path = \"witness.json\"\n",
-                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path, vk_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# HERE WE SETUP THE CIRCUIT PARAMS\n",
-                "# WE GOT KEYS\n",
-                "# WE GOT CIRCUIT PARAMETERS\n",
-                "# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
-                "res = ezkl.setup(\n",
-                "        compiled_model_path,\n",
-                "        vk_path,\n",
-                "        pk_path,\n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "assert os.path.isfile(vk_path)\n",
-                "assert os.path.isfile(pk_path)\n",
-                "assert os.path.isfile(settings_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we generate a full proof. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# GENERATE A PROOF\n",
-                "\n",
-                "proof_path = os.path.join('test.pf')\n",
-                "\n",
-                "res = ezkl.prove(\n",
-                "        witness_path,\n",
-                "        compiled_model_path,\n",
-                "        pk_path,\n",
-                "        proof_path,\n",
-                "        \n",
-                "        \"single\",\n",
-                "    )\n",
-                "\n",
-                "print(res)\n",
-                "assert os.path.isfile(proof_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "And verify it as a sanity check. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# VERIFY IT\n",
-                "\n",
-                "res = ezkl.verify(\n",
-                "        proof_path,\n",
-                "        settings_path,\n",
-                "        vk_path,\n",
-                "        \n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "print(\"verified\")"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We can now create and then deploy a vanilla evm verifier."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "\n",
-                "res = await ezkl.create_evm_verifier(\n",
-                "        vk_path,\n",
-                "        \n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "    )\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "addr_path_verifier = \"addr_verifier.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_evm(\n",
-                "    addr_path_verifier,\n",
-                "    sol_code_path,\n",
-                "    'http://127.0.0.1:3030'\n",
-                ")\n",
-                "\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "When deploying a DA with kzg commitments, we need to make sure to also pass a witness file that contains the commitments to the parameters and inputs. This is because the verifier will need to check that the commitments in the proof match the commitments stored on chain."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "input_path = 'input.json'\n",
-                "\n",
-                "res = await ezkl.create_evm_data_attestation(\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "        witness_path = witness_path,\n",
-                "    )"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we can deploy the data attest verifier contract. For security reasons, this binding will only deploy to a local anvil instance, using accounts generated by anvil. \n",
-                "So should only be used for testing purposes."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "addr_path_da = \"addr_da.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_da_evm(\n",
-                "        addr_path_da,\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        RPC_URL,\n",
-                "    )\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# read the verifier address\n",
-                "addr_verifier = None\n",
-                "with open(addr_path_verifier, 'r') as f:\n",
-                "    addr = f.read()\n",
-                "#read the data attestation address\n",
-                "addr_da = None\n",
-                "with open(addr_path_da, 'r') as f:\n",
-                "    addr_da = f.read()\n",
-                "\n",
-                "res = await ezkl.verify_evm(\n",
-                "    addr,\n",
-                "    proof_path,\n",
-                "    RPC_URL,\n",
-                "    addr_da,\n",
-                ")"
-            ]
-        }
-    ],
-    "metadata": {
-        "kernelspec": {
-            "display_name": "ezkl",
-            "language": "python",
-            "name": "python3"
-        },
-        "language_info": {
-            "codemirror_mode": {
-                "name": "ipython",
-                "version": 3
-            },
-            "file_extension": ".py",
-            "mimetype": "text/x-python",
-            "name": "python",
-            "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3",
-            "version": "3.9.13"
-        },
-        "orig_nbformat": 4
-    },
-    "nbformat": 4,
-    "nbformat_minor": 2
-}

examples/notebooks/hashed_vis.ipynb

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

examples/notebooks/kzg_vis.ipynb

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

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

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

examples/notebooks/reusable_verifier.ipynb

@@ -125,7 +125,7 @@
     "\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",
+    "    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",
@@ -177,7 +177,7 @@
     "    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",
+    "    res = await ezkl.create_evm_vka(vk_path, settings_path, vka_path)\n",
     "    assert res == True\n"
    ]
   },
@@ -220,15 +220,6 @@
     "Check that the generated verifiers are identical for all models."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "start_anvil()"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -270,8 +261,8 @@
     "\n",
     "res = await ezkl.deploy_evm(\n",
     "    addr_path_verifier,\n",
-    "    sol_code_path,\n",
     "    'http://127.0.0.1:3030',\n",
+    "    sol_code_path,\n",
     "    \"verifier/reusable\"\n",
     ")\n",
     "\n",
@@ -296,20 +287,21 @@
    "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",
+    "    vka_path = os.path.join(name, 'vka.bytes')\n",
+    "    res = await ezkl.register_vka(\n",
+    "        addr,\n",
+    "        'http://127.0.0.1:3030',\n",
+    "        vka_path=vka_path,\n",
+    "    )\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",
+    "        proof_path,\n",
+    "        vka_path = vka_path\n",
     "    )\n",
     "    assert res == True"
    ]

examples/notebooks/univ3-da.ipynb

@@ -1,764 +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": 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\", \"--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": 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.decomp_legs=6\n",
-                "run_args.num_inner_cols = 1\n",
-                "run_args.variables = [(\"batch_size\", 1)]"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
-                "\n",
-                "You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# TODO: Dictionary outputs\n",
-                "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# generate a bunch of dummy calibration data\n",
-                "cal_data = {\n",
-                "    \"input_data\": [(0.1*torch.rand(2, *[3, 2, 2])).flatten().tolist()],\n",
-                "}\n",
-                "\n",
-                "cal_path = os.path.join('val_data.json')\n",
-                "# save as json file\n",
-                "with open(cal_path, \"w\") as f:\n",
-                "    json.dump(cal_data, f)\n",
-                "\n",
-                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "The graph input for on chain data sources is formatted completely differently compared to file based data sources.\n",
-                "\n",
-                "- For file data sources, the raw floating point values that eventually get quantized, converted into field elements and stored in `witness.json` to be consumed by the circuit are stored. The output data contains the expected floating point values returned as outputs from running your vanilla pytorch model on the given inputs.\n",
-                "- For on chain data sources, the input_data field contains all the data necessary to read and format the on chain data into something digestable by EZKL (aka field elements :-D). \n",
-                "Here is what the schema for an on-chain data source graph input file should look like for a single call data source:\n",
-                "    \n",
-                "```json\n",
-                "{\n",
-                "    \"input_data\": {\n",
-                "        \"rpc\": \"http://localhost:3030\", // The rpc endpoint of the chain you are deploying your verifier to\n",
-                "        \"calls\": {\n",
-                "            \"call_data\": \"1f3be514000000000000000000000000c6962004f452be9203591991d15f6b388e09e8d00000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000\", // The abi encoded call data to a view function that returns an array of on-chain data points we are attesting to. \n",
-                "            \"decimals\": 0, // The number of decimal places of the large uint256 value. This is our way of representing large wei values as floating points on chain, since the evm only natively supports integer values.\n",
-                "            \"address\": \"9A213F53334279C128C37DA962E5472eCD90554f\", // The address of the contract that we are calling to get the data. \n",
-                "            \"len\": 12 // The number of data points returned by the view function (the length of the array)\n",
-                "        }\n",
-                "    }\n",
-                "}\n",
-                "```"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "from web3 import Web3, HTTPProvider\n",
-                "from solcx import compile_standard\n",
-                "from decimal import Decimal\n",
-                "import json\n",
-                "import os\n",
-                "import torch\n",
-                "import requests\n",
-                "\n",
-                "# This function counts the decimal places of a floating point number\n",
-                "def count_decimal_places(num):\n",
-                "    num_str = str(num)\n",
-                "    if '.' in num_str:\n",
-                "        return len(num_str) - 1 - num_str.index('.')\n",
-                "    else:\n",
-                "        return 0\n",
-                "\n",
-                "# setup web3 instance\n",
-                "w3 = Web3(HTTPProvider(RPC_URL)) \n",
-                "\n",
-                "def set_next_block_timestamp(anvil_url, timestamp):\n",
-                "    # Send the JSON-RPC request to Anvil\n",
-                "    payload = {\n",
-                "        \"jsonrpc\": \"2.0\",\n",
-                "        \"id\": 1,\n",
-                "        \"method\": \"evm_setNextBlockTimestamp\",\n",
-                "        \"params\": [timestamp]\n",
-                "    }\n",
-                "    response = requests.post(anvil_url, json=payload)\n",
-                "    if response.status_code == 200:\n",
-                "        print(f\"Next block timestamp set to: {timestamp}\")\n",
-                "    else:\n",
-                "        print(f\"Failed to set next block timestamp: {response.text}\")\n",
-                "\n",
-                "def on_chain_data(tensor):\n",
-                "    # Step 0: Convert the tensor to a flat list\n",
-                "    data = tensor.view(-1).tolist()\n",
-                "\n",
-                "    # Step 1: Prepare the calldata\n",
-                "    secondsAgo = [len(data) - 1 - i for i in range(len(data))]\n",
-                "\n",
-                "    # Step 2: Prepare and compile the contract UniTickAttestor contract\n",
-                "    contract_source_code = '''\n",
-                "    // SPDX-License-Identifier: MIT\n",
-                "    pragma solidity ^0.8.20;\n",
-                "\n",
-                "    /// @title Pool state that is not stored\n",
-                "    /// @notice Contains view functions to provide information about the pool that is computed rather than stored on the\n",
-                "    /// blockchain. The functions here may have variable gas costs.\n",
-                "    interface IUniswapV3PoolDerivedState {\n",
-                "        /// @notice Returns the cumulative tick and liquidity as of each timestamp `secondsAgo` from the current block timestamp\n",
-                "        /// @dev To get a time weighted average tick or liquidity-in-range, you must call this with two values, one representing\n",
-                "        /// the beginning of the period and another for the end of the period. E.g., to get the last hour time-weighted average tick,\n",
-                "        /// you must call it with secondsAgos = [3600, 0].\n",
-                "        /// log base sqrt(1.0001) of token1 / token0. The TickMath library can be used to go from a tick value to a ratio.\n",
-                "        /// @dev The time weighted average tick represents the geometric time weighted average price of the pool, in\n",
-                "        /// @param secondsAgos From how long ago each cumulative tick and liquidity value should be returned\n",
-                "        /// @return tickCumulatives Cumulative tick values as of each `secondsAgos` from the current block timestamp\n",
-                "        /// @return secondsPerLiquidityCumulativeX128s Cumulative seconds per liquidity-in-range value as of each `secondsAgos` from the current block\n",
-                "        /// timestamp\n",
-                "        function observe(\n",
-                "            uint32[] calldata secondsAgos\n",
-                "        )\n",
-                "            external\n",
-                "            view\n",
-                "            returns (\n",
-                "                int56[] memory tickCumulatives,\n",
-                "                uint160[] memory secondsPerLiquidityCumulativeX128s\n",
-                "            );\n",
-                "    }\n",
-                "\n",
-                "    /// @title Uniswap Wrapper around `pool.observe` that stores the parameters for fetching and then attesting to historical data\n",
-                "    /// @notice Provides functions to integrate with V3 pool oracle\n",
-                "    contract UniTickAttestor {\n",
-                "        /**\n",
-                "        * @notice Calculates time-weighted means of tick and liquidity for a given Uniswap V3 pool\n",
-                "        * @param pool Address of the pool that we want to observe\n",
-                "        * @param secondsAgo Number of seconds in the past from which to calculate the time-weighted means\n",
-                "        * @return tickCumulatives The cumulative tick values as of each `secondsAgo` from the current block timestamp\n",
-                "        */\n",
-                "        function consult(\n",
-                "            IUniswapV3PoolDerivedState pool,\n",
-                "            uint32[] memory secondsAgo\n",
-                "        ) public view returns (int256[] memory tickCumulatives) {\n",
-                "            tickCumulatives = new int256[](secondsAgo.length);\n",
-                "            (int56[] memory _ticks,) = pool.observe(secondsAgo);\n",
-                "            for (uint256 i = 0; i < secondsAgo.length; i++) {\n",
-                "                tickCumulatives[i] = int256(_ticks[i]);\n",
-                "            }\n",
-                "        }\n",
-                "    }\n",
-                "    '''\n",
-                "\n",
-                "    compiled_sol = compile_standard({\n",
-                "        \"language\": \"Solidity\",\n",
-                "        \"sources\": {\"UniTickAttestor.sol\": {\"content\": contract_source_code}},\n",
-                "        \"settings\": {\"outputSelection\": {\"*\": {\"*\": [\"metadata\", \"evm.bytecode\", \"abi\"]}}}\n",
-                "    })\n",
-                "\n",
-                "    # Get bytecode\n",
-                "    bytecode = compiled_sol['contracts']['UniTickAttestor.sol']['UniTickAttestor']['evm']['bytecode']['object']\n",
-                "\n",
-                "    # Get ABI\n",
-                "    # In production if you are reading from really large contracts you can just use\n",
-                "    # a stripped down version of the ABI of the contract you are calling, containing only the view functions you will fetch data from.\n",
-                "    abi = json.loads(compiled_sol['contracts']['UniTickAttestor.sol']['UniTickAttestor']['metadata'])['output']['abi']\n",
-                "\n",
-                "    # Step 3: Deploy the contract\n",
-                "    UniTickAttestor = w3.eth.contract(abi=abi, bytecode=bytecode)\n",
-                "    tx_hash = UniTickAttestor.constructor().transact()\n",
-                "    tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)\n",
-                "    # If you are deploying to production you can skip the 3 lines of code above and just instantiate the contract like this,\n",
-                "    # passing the address and abi of the contract you are fetching data from.\n",
-                "    contract = w3.eth.contract(address=tx_receipt['contractAddress'], abi=abi)\n",
-                "\n",
-                "    # Step 4: Interact with the contract\n",
-                "    call = contract.functions.consult(\n",
-                "        # Address of the UniV3 usdc-weth pool 0.005 fee\n",
-                "        \"0xC6962004f452bE9203591991D15f6b388e09E8D0\",\n",
-                "        secondsAgo\n",
-                "    ).build_transaction()\n",
-                "    result = contract.functions.consult(\n",
-                "        # Address of the UniV3 usdc-weth pool 0.005 fee\n",
-                "        \"0xC6962004f452bE9203591991D15f6b388e09E8D0\",\n",
-                "        secondsAgo\n",
-                "    ).call()\n",
-                "    \n",
-                "    print(f'result: {result}')\n",
-                "    calldata = call['data'][2:]\n",
-                "\n",
-                "    time_stamp = w3.eth.get_block('latest')['timestamp']\n",
-                "\n",
-                "    print(f'time_stamp: {time_stamp}')\n",
-                "\n",
-                "    # Set the next block timestamp using the fetched time_stamp\n",
-                "    set_next_block_timestamp(RPC_URL, time_stamp)\n",
-                "\n",
-                "\n",
-                "    # Prepare the calls_to_account object\n",
-                "    # If you were calling view functions across multiple contracts,\n",
-                "    # you would have multiple entries in the calls_to_account array,\n",
-                "    # one for each contract.\n",
-                "    call_to_account = {\n",
-                "        'call_data': calldata,\n",
-                "        'decimals': 0,\n",
-                "        'address': contract.address[2:], # remove the '0x' prefix\n",
-                "        'len': len(data),\n",
-                "    }\n",
-                "\n",
-                "    print(f'call_to_account: {call_to_account}')\n",
-                "\n",
-                "    return call_to_account\n",
-                "\n",
-                "# Now let's start the Anvil process. You don't need to do this if you are deploying to a non-local chain.\n",
-                "start_anvil()\n",
-                "\n",
-                "# Now let's call our function, passing in the same input tensor we used to export the model 2 cells above.\n",
-                "calls_to_account = on_chain_data(x)\n",
-                "\n",
-                "data = dict(input_data =  {'rpc': RPC_URL, 'calls': calls_to_account })\n",
-                "\n",
-                "# Serialize on-chain data into file:\n",
-                "json.dump(data, open(\"input.json\", 'w'))"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
-                "\n",
-                "These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "res = await ezkl.get_srs( settings_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We now need to generate the circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# !export RUST_BACKTRACE=1\n",
-                "\n",
-                "witness_path = \"witness.json\"\n",
-                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# HERE WE SETUP THE CIRCUIT PARAMS\n",
-                "# WE GOT KEYS\n",
-                "# WE GOT CIRCUIT PARAMETERS\n",
-                "# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
-                "res = ezkl.setup(\n",
-                "        compiled_model_path,\n",
-                "        vk_path,\n",
-                "        pk_path,\n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "assert os.path.isfile(vk_path)\n",
-                "assert os.path.isfile(pk_path)\n",
-                "assert os.path.isfile(settings_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we generate a full proof. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# GENERATE A PROOF\n",
-                "\n",
-                "proof_path = os.path.join('test.pf')\n",
-                "\n",
-                "res = ezkl.prove(\n",
-                "        witness_path,\n",
-                "        compiled_model_path,\n",
-                "        pk_path,\n",
-                "        proof_path,\n",
-                "        \"single\",\n",
-                "    )\n",
-                "\n",
-                "print(res)\n",
-                "assert os.path.isfile(proof_path)"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "And verify it as a sanity check. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# VERIFY IT\n",
-                "\n",
-                "res = ezkl.verify(\n",
-                "        proof_path,\n",
-                "        settings_path,\n",
-                "        vk_path,\n",
-                "    )\n",
-                "\n",
-                "assert res == True\n",
-                "print(\"verified\")"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "We can now create and then deploy a vanilla evm verifier."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "\n",
-                "res = await ezkl.create_evm_verifier(\n",
-                "        vk_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "    )\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import json\n",
-                "\n",
-                "addr_path_verifier = \"addr_verifier.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_evm(\n",
-                "    addr_path_verifier,\n",
-                "    sol_code_path,\n",
-                "    'http://127.0.0.1:3030'\n",
-                ")\n",
-                "\n",
-                "assert res == True"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "With the vanilla verifier deployed, we can now create the data attestation contract, which will read in the instances from the calldata to the verifier, attest to them, call the verifier and then return the result. "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "\n",
-                "abi_path = 'test.abi'\n",
-                "sol_code_path = 'test.sol'\n",
-                "input_path = 'input.json'\n",
-                "\n",
-                "res = await ezkl.create_evm_data_attestation(\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        abi_path,\n",
-                "    )"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Now we can deploy the data attest verifier contract. For security reasons, this binding will only deploy to a local anvil instance, using accounts generated by anvil. \n",
-                "So should only be used for testing purposes."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "addr_path_da = \"addr_da.txt\"\n",
-                "\n",
-                "res = await ezkl.deploy_da_evm(\n",
-                "        addr_path_da,\n",
-                "        input_path,\n",
-                "        settings_path,\n",
-                "        sol_code_path,\n",
-                "        RPC_URL,\n",
-                "    )\n"
-            ]
-        },
-        {
-            "attachments": {},
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "Here we need to regenerate the witness, prove and then verify all within the same cell. This is because we want to reduce the amount of latency between reading on-chain state and verifying it on-chain. This is because the attest input values read from the oracle are time sensitive (their values are derived from computing on block.timestamp) and can change between the time of reading and the time of verifying.\n",
-                "\n",
-                "Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# !export RUST_BACKTRACE=1\n",
-                "\n",
-                "calls_to_account = on_chain_data(x)\n",
-                "\n",
-                "data = dict(input_data =  {'rpc': RPC_URL, 'calls': calls_to_account })\n",
-                "\n",
-                "# Serialize on-chain data into file:\n",
-                "json.dump(data, open(\"input.json\", 'w'))\n",
-                "\n",
-                "# setup web3 instance\n",
-                "w3 = Web3(HTTPProvider(RPC_URL)) \n",
-                "\n",
-                "time_stamp = w3.eth.get_block('latest')['timestamp']\n",
-                "\n",
-                "print(f'time_stamp: {time_stamp}')\n",
-                "\n",
-                "\n",
-                "witness_path = \"witness.json\"\n",
-                "\n",
-                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
-                "\n",
-                "res = ezkl.prove(\n",
-                "        witness_path,\n",
-                "        compiled_model_path,\n",
-                "        pk_path,\n",
-                "        proof_path,\n",
-                "        \"single\",\n",
-                "    )\n",
-                "\n",
-                "print(res)\n",
-                "assert os.path.isfile(proof_path)\n",
-                "# read the verifier address\n",
-                "addr_verifier = None\n",
-                "with open(addr_path_verifier, 'r') as f:\n",
-                "    addr = f.read()\n",
-                "#read the data attestation address\n",
-                "addr_da = None\n",
-                "with open(addr_path_da, 'r') as f:\n",
-                "    addr_da = f.read()\n",
-                "\n",
-                "res = await ezkl.verify_evm(\n",
-                "    addr,\n",
-                "    proof_path,\n",
-                "    RPC_URL,\n",
-                "    addr_da,\n",
-                ")"
-            ]
-        }
-    ],
-    "metadata": {
-        "kernelspec": {
-            "display_name": ".env",
-            "language": "python",
-            "name": "python3"
-        },
-        "language_info": {
-            "codemirror_mode": {
-                "name": "ipython",
-                "version": 3
-            },
-            "file_extension": ".py",
-            "mimetype": "text/x-python",
-            "name": "python",
-            "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3",
-            "version": "3.11.5"
-        },
-        "orig_nbformat": 4
-    },
-    "nbformat": 4,
-    "nbformat_minor": 2
-}

examples/notebooks/variance.ipynb

@@ -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,7 +757,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.12.2"
+      "version": "3.12.9"
     }
   },
   "nbformat": 4,

examples/notebooks/voice_judge.ipynb

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

examples/notebooks/world_rotation.ipynb

@@ -1,547 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
-   "metadata": {},
-   "source": [
-    "## World rotation\n",
-    "\n",
-    "Here we demonstrate how to use the EZKL package to rotate an on-chain world. \n",
-    "\n",
-    "![zk-gaming-diagram-transformed](https://hackmd.io/_uploads/HkApuQGV6.png)\n",
-    "> **A typical ZK application flow**. For the shape rotators out there — this is an easily digestible example. A user computes a ZK-proof that they have calculated a valid rotation of a world. They submit this proof to a verifier contract which governs an on-chain world, along with a new set of coordinates, and the world rotation updates. Observe that it’s possible for one player to initiate a *global* change.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "95613ee9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# check if notebook is in colab\n",
-    "try:\n",
-    "    # install ezkl\n",
-    "    import google.colab\n",
-    "    import subprocess\n",
-    "    import sys\n",
-    "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
-    "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
-    "\n",
-    "# rely on local installation of ezkl if the notebook is not in colab\n",
-    "except:\n",
-    "    pass\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from torch import nn\n",
-    "import ezkl\n",
-    "import os\n",
-    "import json\n",
-    "import torch\n",
-    "import math\n",
-    "\n",
-    "# these are constants for the rotation\n",
-    "phi = torch.tensor(5 * math.pi / 180)\n",
-    "s = torch.sin(phi)\n",
-    "c = torch.cos(phi)\n",
-    "\n",
-    "\n",
-    "class RotateStuff(nn.Module):\n",
-    "    def __init__(self):\n",
-    "        super(RotateStuff, self).__init__()\n",
-    "\n",
-    "        # create a rotation matrix -- the matrix is constant and is transposed for convenience\n",
-    "        self.rot = torch.stack([torch.stack([c, -s]),\n",
-    "                   torch.stack([s, c])]).t()\n",
-    "\n",
-    "    def forward(self, x):\n",
-    "        x_rot = x @ self.rot   # same as x_rot = (rot @ x.t()).t() due to rot in O(n) (SO(n) even)\n",
-    "        return x_rot\n",
-    "\n",
-    "\n",
-    "circuit = RotateStuff()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This will showcase the principle directions of rotation by plotting the rotation of a single unit vector."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from matplotlib import pyplot\n",
-    "pyplot.figure(figsize=(3, 3))\n",
-    "pyplot.arrow(0, 0, 1, 0, width=0.02, alpha=0.5)\n",
-    "pyplot.arrow(0, 0, 0, 1, width=0.02, alpha=0.5)\n",
-    "pyplot.arrow(0, 0, circuit.rot[0, 0].item(), circuit.rot[0, 1].item(), width=0.02)\n",
-    "pyplot.arrow(0, 0, circuit.rot[1, 0].item(), circuit.rot[1, 1].item(), width=0.02)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b37637c4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model_path = os.path.join('network.onnx')\n",
-    "compiled_model_path = os.path.join('network.compiled')\n",
-    "pk_path = os.path.join('test.pk')\n",
-    "vk_path = os.path.join('test.vk')\n",
-    "settings_path = os.path.join('settings.json')\n",
-    "srs_path = os.path.join('kzg.srs')\n",
-    "witness_path = os.path.join('witness.json')\n",
-    "data_path = os.path.join('input.json')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "82db373a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "\n",
-    "# initial principle vectors for the rotation are as in the plot above\n",
-    "x = torch.tensor([[1, 0], [0, 1]], dtype=torch.float32)\n",
-    "\n",
-    "# Flips the neural net into inference mode\n",
-    "circuit.eval()\n",
-    "\n",
-    "    # Export the model\n",
-    "torch.onnx.export(circuit,               # model being run\n",
-    "                      x,                   # model input (or a tuple for multiple inputs)\n",
-    "                      model_path,            # where to save the model (can be a file or file-like object)\n",
-    "                      export_params=True,        # store the trained parameter weights inside the model file\n",
-    "                      opset_version=10,          # the ONNX version to export the model to\n",
-    "                      do_constant_folding=True,  # whether to execute constant folding for optimization\n",
-    "                      input_names = ['input'],   # the model's input names\n",
-    "                      output_names = ['output'], # the model's output names\n",
-    "                      )\n",
-    "\n",
-    "data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
-    "\n",
-    "data = dict(input_data = [data_array])\n",
-    "\n",
-    "    # Serialize data into file:\n",
-    "json.dump( data, open(data_path, 'w' ))\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### World rotation in 2D on-chain"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For demo purposes we deploy these coordinates to a contract running locally using Anvil. This creates our on-chain world. We then rotate the world using the EZKL package and submit the proof to the contract. The contract then updates the world rotation. For demo purposes we do this repeatedly, rotating the world by 1 transform each time."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import subprocess\n",
-    "import time\n",
-    "import threading\n",
-    "\n",
-    "# make sure anvil is running locally\n",
-    "# $ anvil -p 3030\n",
-    "\n",
-    "RPC_URL = \"http://localhost:3030\"\n",
-    "\n",
-    "# Save process globally\n",
-    "anvil_process = None\n",
-    "\n",
-    "def start_anvil():\n",
-    "    global anvil_process\n",
-    "    if anvil_process is None:\n",
-    "        anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--code-size-limit=41943040\"])\n",
-    "        if anvil_process.returncode is not None:\n",
-    "            raise Exception(\"failed to start anvil process\")\n",
-    "        time.sleep(3)\n",
-    "\n",
-    "def stop_anvil():\n",
-    "    global anvil_process\n",
-    "    if anvil_process is not None:\n",
-    "        anvil_process.terminate()\n",
-    "        anvil_process = None\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
-    "- `input_visibility` defines the visibility of the model inputs\n",
-    "- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
-    "- `output_visibility` defines the visibility of the model outputs\n",
-    "\n",
-    "Here we create the following setup:\n",
-    "- `input_visibility`: \"public\"\n",
-    "- `param_visibility`: \"fixed\"\n",
-    "- `output_visibility`: public"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d5e374a2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "py_run_args = ezkl.PyRunArgs()\n",
-    "py_run_args.input_visibility = \"public\"\n",
-    "py_run_args.output_visibility = \"public\"\n",
-    "py_run_args.param_visibility = \"private\" # private by default\n",
-    "py_run_args.scale_rebase_multiplier = 10\n",
-    "\n",
-    "res = ezkl.gen_settings(model_path, settings_path, py_run_args=py_run_args)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3aa4f090",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
-    "assert res == True"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We also define a contract that holds out test data. This contract will contain in its storage the data that we will read from and attest to. In production you would not need to set up a local anvil instance. Instead you would replace RPC_URL with the actual RPC endpoint of the chain you are deploying your verifiers too, reading from the data on said chain."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2007dc77",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ezkl.setup_test_evm_witness(\n",
-    "    data_path,\n",
-    "    compiled_model_path,\n",
-    "    # we write the call data to the same file as the input data\n",
-    "    data_path,\n",
-    "    input_source=ezkl.PyTestDataSource.OnChain,\n",
-    "    output_source=ezkl.PyTestDataSource.File,\n",
-    "    rpc_url=RPC_URL)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ab993958",
-   "metadata": {},
-   "source": [
-    "As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
-    "\n",
-    "These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8b74dcee",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# srs path\n",
-    "res = await ezkl.get_srs( settings_path)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "18c8b7c7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# now generate the witness file \n",
-    "\n",
-    "witness = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
-    "assert os.path.isfile(witness_path)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ad58432e",
-   "metadata": {},
-   "source": [
-    "Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b1c561a8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "res = ezkl.setup(\n",
-    "        compiled_model_path,\n",
-    "        vk_path,\n",
-    "        pk_path,\n",
-    "        \n",
-    "    )\n",
-    "\n",
-    "assert res == True\n",
-    "assert os.path.isfile(vk_path)\n",
-    "assert os.path.isfile(pk_path)\n",
-    "assert os.path.isfile(settings_path)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1746c8d1",
-   "metadata": {},
-   "source": [
-    "We can now create an EVM verifier contract from our circuit. This contract will be deployed to the chain we are using. In this case we are using a local anvil instance."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d1920c0f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "abi_path = 'test.abi'\n",
-    "sol_code_path = 'test.sol'\n",
-    "\n",
-    "res = await ezkl.create_evm_verifier(\n",
-    "        vk_path,\n",
-    "        settings_path,\n",
-    "        sol_code_path,\n",
-    "        abi_path,\n",
-    "    )\n",
-    "assert res == True"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0fd7f22b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import json\n",
-    "\n",
-    "addr_path_verifier = \"addr_verifier.txt\"\n",
-    "\n",
-    "res = await ezkl.deploy_evm(\n",
-    "    addr_path_verifier,\n",
-    "    sol_code_path,\n",
-    "    'http://127.0.0.1:3030'\n",
-    ")\n",
-    "\n",
-    "assert res == True"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9c0dffab",
-   "metadata": {},
-   "source": [
-    "With the vanilla verifier deployed, we can now create the data attestation contract, which will read in the instances from the calldata to the verifier, attest to them, call the verifier and then return the result. \n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cc888848",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c2db14d7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "abi_path = 'test.abi'\n",
-    "sol_code_path = 'test.sol'\n",
-    "input_path = 'input.json'\n",
-    "\n",
-    "res = await ezkl.create_evm_data_attestation(\n",
-    "        input_path,\n",
-    "        settings_path,\n",
-    "        sol_code_path,\n",
-    "        abi_path,\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5a018ba6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "addr_path_da = \"addr_da.txt\"\n",
-    "\n",
-    "res = await ezkl.deploy_da_evm(\n",
-    "        addr_path_da,\n",
-    "        input_path,\n",
-    "        settings_path,\n",
-    "        sol_code_path,\n",
-    "        RPC_URL,\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2adad845",
-   "metadata": {},
-   "source": [
-    "Now we can pull in the data from the contract and calculate a new set of coordinates. We then rotate the world by 1 transform and submit the proof to the contract. The contract could then update the world rotation (logic not inserted here). For demo purposes we do this repeatedly, rotating the world by 1 transform. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c384cbc8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# GENERATE A PROOF\n",
-    "\n",
-    "\n",
-    "proof_path = os.path.join('test.pf')\n",
-    "\n",
-    "res = ezkl.prove(\n",
-    "        witness_path,\n",
-    "        compiled_model_path,\n",
-    "        pk_path,\n",
-    "        proof_path,\n",
-    "        \n",
-    "        \"single\",\n",
-    "    )\n",
-    "\n",
-    "print(res)\n",
-    "assert os.path.isfile(proof_path)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "90eda56e",
-   "metadata": {},
-   "source": [
-    "Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "76f00d41",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# read the verifier address\n",
-    "addr_verifier = None\n",
-    "with open(addr_path_verifier, 'r') as f:\n",
-    "    addr = f.read()\n",
-    "#read the data attestation address\n",
-    "addr_da = None\n",
-    "with open(addr_path_da, 'r') as f:\n",
-    "    addr_da = f.read()\n",
-    "\n",
-    "res = ezkl.verify_evm(\n",
-    "    addr,\n",
-    "    proof_path,\n",
-    "    RPC_URL,\n",
-    "    addr_da,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As a sanity check lets plot the rotations of the unit vectors. We can see that the unit vectors rotate as expected by the output of the circuit. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "witness['outputs'][0][0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "settings = json.load(open(settings_path, 'r'))\n",
-    "out_scale = settings[\"model_output_scales\"][0]\n",
-    "\n",
-    "from matplotlib import pyplot\n",
-    "pyplot.figure(figsize=(3, 3))\n",
-    "pyplot.arrow(0, 0, 1, 0, width=0.02, alpha=0.5)\n",
-    "pyplot.arrow(0, 0, 0, 1, width=0.02, alpha=0.5)\n",
-    "\n",
-    "arrow_x = ezkl.felt_to_float(witness['outputs'][0][0], out_scale)\n",
-    "arrow_y = ezkl.felt_to_float(witness['outputs'][0][1], out_scale)\n",
-    "pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)\n",
-    "arrow_x = ezkl.felt_to_float(witness['outputs'][0][2], out_scale)\n",
-    "arrow_y = ezkl.felt_to_float(witness['outputs'][0][3], out_scale)\n",
-    "pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

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_witness(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 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
-    """
-    ...
 
 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

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)
     })?;
@@ -1030,25 +1040,22 @@ fn calibrate_settings(
     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)
-        })?;
+    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
@@ -1091,15 +1098,12 @@ fn gen_witness(
     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)))
-    })
+    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 +1601,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)
     })
@@ -1692,15 +1689,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 +1705,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 +1730,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_witness(
-    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_witness(
-            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_witness: {}", 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 +1743,8 @@ fn setup_test_evm_witness(
 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 +1768,64 @@ fn deploy_evm(
     })
 }
 
-/// deploys the solidity da 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,47 +1839,30 @@ 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 ?
-///
-/// addr_vk: str
-///     The address 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
 ///
 #[pyfunction(signature = (
     addr_verifier,
+    rpc_url,
     proof_path=PathBuf::from(DEFAULT_PROOF),
-    rpc_url=None,
-    addr_da = None,
-    addr_vk = None,
+    vka_path = 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>,
 ) -> 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)
+        crate::execute::verify_evm(proof_path, addr_verifier, rpc_url, vka_path)
             .await
             .map_err(|e| {
                 let err_str = format!("Failed to run verify_evm: {}", e);
@@ -2105,12 +1986,10 @@ fn ezkl(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(create_evm_verifier, m)?)?;
     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_witness, 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)?)?;
+    m.add_function(wrap_pyfunction!(register_vka, m)?)?;
     Ok(())
 }
 

src/bindings/universal.rs

@@ -1,6 +1,7 @@
 use halo2_proofs::{
     plonk::*,
     poly::{
+        VerificationStrategy,
         commitment::{CommitmentScheme, ParamsProver},
         ipa::{
             commitment::{IPACommitmentScheme, ParamsIPA},
@@ -12,7 +13,6 @@ use halo2_proofs::{
             multiopen::{ProverSHPLONK, VerifierSHPLONK},
             strategy::SingleStrategy as KZGSingleStrategy,
         },
-        VerificationStrategy,
     },
 };
 use std::fmt::Display;
@@ -20,15 +20,15 @@ use std::io::BufReader;
 use std::str::FromStr;
 
 use crate::{
+    CheckMode, Commitments, EZKLError as InnerEZKLError,
     circuit::region::RegionSettings,
     graph::GraphSettings,
     pfsys::{
-        create_proof_circuit,
+        TranscriptType, create_proof_circuit,
         evm::aggregation_kzg::{AggregationCircuit, PoseidonTranscript},
-        verify_proof_circuit, TranscriptType,
+        verify_proof_circuit,
     },
     tensor::TensorType,
-    CheckMode, Commitments, EZKLError as InnerEZKLError,
 };
 
 use crate::graph::{GraphCircuit, GraphWitness};
@@ -66,26 +66,24 @@ impl From<InnerEZKLError> for EZKLError {
 pub(crate) fn encode_verifier_calldata(
     // TODO - shuold it be pub(crate) 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)
 }

src/circuit/ops/base.rs

@@ -21,7 +21,10 @@ pub enum BaseOp {
 
 /// Matches a [BaseOp] to an operation over inputs
 impl BaseOp {
-    /// forward func
+    /// forward func for non-accumulating operations
+    /// # Panics
+    /// Panics if called on an accumulating operation
+    /// # Examples
     pub fn nonaccum_f<
         T: TensorType + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Neg<Output = T>,
     >(
@@ -37,7 +40,9 @@ impl BaseOp {
         }
     }
 
-    /// forward func
+    /// forward func for accumulating operations
+    /// # Panics
+    /// Panics if called on a non-accumulating operation
     pub fn accum_f<
         T: TensorType + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Neg<Output = T>,
     >(

src/circuit/ops/hybrid.rs

@@ -1,7 +1,7 @@
 use super::*;
 use crate::{
     circuit::{layouts, utils},
-    fieldutils::{integer_rep_to_felt, IntegerRep},
+    fieldutils::{IntegerRep, integer_rep_to_felt},
     graph::multiplier_to_scale,
     tensor::{self, DataFormat, Tensor, TensorType, ValTensor},
 };
@@ -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,
@@ -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 } => {
@@ -211,17 +219,21 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
             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)?
@@ -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/mod.rs

@@ -159,6 +159,8 @@ impl std::str::FromStr for InputType {
 
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 impl From<DatumType> for InputType {
+    /// # Panics
+    /// Panics if the datum type is not supported
     fn from(datum_type: DatumType) -> Self {
         match datum_type {
             DatumType::Bool => InputType::Bool,
@@ -317,13 +319,8 @@ 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

src/circuit/ops/poly.rs

@@ -49,7 +49,7 @@ pub enum PolyOp {
     },
     Downsample {
         axis: usize,
-        stride: usize,
+        stride: isize,
         modulo: usize,
     },
     DeConv {
@@ -108,13 +108,8 @@ 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 {
@@ -188,7 +183,8 @@ impl<
             } => {
                 format!(
                     "DECONV (stride={:?}, padding={:?}, output_padding={:?}, group={}, data_format={:?}, kernel_format={:?})",
-                    stride, padding, output_padding, group, data_format, kernel_format)
+                    stride, padding, output_padding, group, data_format, kernel_format
+                )
             }
             PolyOp::Concat { axis } => format!("CONCAT (axis={})", axis),
             PolyOp::Slice { axis, start, end } => {

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,44 @@ 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 s.starts_with('@') {
+            // Extract the file path (remove the '@' prefix)
+            let file_path = &s[1..];
+
+            // 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,10 +431,9 @@ pub enum Commands {
 
     /// Generates the witness from an input file.
     GenWitness {
-        /// The path to the .json data file
-        /// You can also pass the input data as a string, eg. --data '{"input_data": [1.0,2.0,3.0]}' directly and skip the file
-        #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
+        /// 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>,
@@ -435,7 +465,7 @@ pub enum Commands {
         /// The path to the .onnx model file
         #[arg(short = 'M', long, default_value = DEFAULT_MODEL, value_hint = clap::ValueHint::FilePath)]
         model: Option<PathBuf>,
-        /// The path to the .json data file to output
+        /// The path to the .json data file
         #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
         data: Option<PathBuf>,
         /// Hand-written parser for graph variables, eg. batch_size=1
@@ -444,11 +474,16 @@ 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 {
         /// The path to the .json calibration data file.
-        /// You can also pass the input data as a string, eg. --data '{"input_data": [1.0,2.0,3.0]}' directly and skip the file
         #[arg(short = 'D', long, default_value = DEFAULT_CALIBRATION_FILE, value_hint = clap::ValueHint::FilePath)]
         data: Option<String>,
         /// The path to the .onnx model file
@@ -629,45 +664,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)
-        /// You can also pass the input data as a string, eg. --data '{"input_data": [1.0,2.0,3.0]}' directly and skip the file
-        #[arg(short = 'D', long, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
-        /// 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,
-    },
-    /// The Data Attestation Verifier contract stores the account calls to fetch data to feed into ezkl. This call data can be updated by an admin account. This tests that admin account is able to update this call data.
-    #[command(arg_required_else_help = true)]
-    TestUpdateAccountCalls {
-        /// The path to the verifier contract's address
-        #[arg(long, value_hint = clap::ValueHint::Other)]
-        addr: H160Flag,
-        /// The path to the .json data file.
-        /// You can also pass the input data as a string, eg. --data '{"input_data": [1.0,2.0,3.0]}' directly and skip the file
-        #[arg(short = 'D', long, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
-        /// 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>,
-    },
     /// Swaps the positions in the transcript that correspond to commitments
     SwapProofCommitments {
         /// The path to the proof file
@@ -710,6 +706,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)]
@@ -717,12 +714,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)
+        /// The path to the serialized VKA file
         #[arg(long, value_hint = clap::ValueHint::Other)]
-        addr_vk: Option<H160Flag>,
+        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)]
@@ -743,9 +741,10 @@ pub enum Commands {
         #[arg(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", 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>,
@@ -755,39 +754,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)]
@@ -851,13 +829,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>,
@@ -871,34 +850,9 @@ pub enum Commands {
         #[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)
-        /// You can also pass the input data as a string, eg. --data '{"input_data": [1.0,2.0,3.0]}' directly and skip the file
-        #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
-        data: Option<String>,
-        /// 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)]
@@ -906,15 +860,32 @@ 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
+        #[arg(long, default_value = DEFAULT_VKA, value_hint = clap::ValueHint::FilePath)]
+        vka_path: Option<PathBuf>,
+    },
+    /// Registers a VKA, returning the its digest used to identify it on-chain.
+    #[command(name = "register-vka")]
+    #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
+    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)

src/execute.rs

@@ -1,33 +1,30 @@
-use crate::EZKL_BUF_CAPACITY;
-use crate::circuit::CheckMode;
 use crate::circuit::region::RegionSettings;
+use crate::circuit::CheckMode;
 use crate::commands::CalibrationTarget;
-use crate::eth::{
-    deploy_contract_via_solidity, deploy_da_verifier_via_solidity, fix_da_multi_sol,
-    fix_da_single_sol,
-};
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
+use crate::eth::{deploy_contract_via_solidity, register_vka_via_rv};
 #[allow(unused_imports)]
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 use crate::eth::{get_contract_artifacts, verify_proof_via_solidity};
-use crate::graph::input::{Calls, GraphData};
+use crate::graph::input::GraphData;
 use crate::graph::{GraphCircuit, GraphSettings, GraphWitness, Model};
-use crate::graph::{TestDataSource, TestSources};
 use crate::pfsys::evm::aggregation_kzg::{AggregationCircuit, PoseidonTranscript};
 use crate::pfsys::{
-    ProofSplitCommit, create_proof_circuit, swap_proof_commitments_polycommit, verify_proof_circuit,
+    create_keys, load_pk, load_vk, save_params, save_pk, Snark, StrategyType, TranscriptType,
 };
 use crate::pfsys::{
-    Snark, StrategyType, TranscriptType, create_keys, load_pk, load_vk, save_params, save_pk,
+    create_proof_circuit, swap_proof_commitments_polycommit, verify_proof_circuit, ProofSplitCommit,
 };
 use crate::pfsys::{save_vk, srs::*};
 use crate::tensor::TensorError;
+use crate::EZKL_BUF_CAPACITY;
+use crate::{commands::*, EZKLError};
 use crate::{Commitments, RunArgs};
-use crate::{EZKLError, commands::*};
 use colored::Colorize;
 #[cfg(unix)]
 use gag::Gag;
 use halo2_proofs::dev::VerifyFailure;
 use halo2_proofs::plonk::{self, Circuit};
-use halo2_proofs::poly::VerificationStrategy;
 use halo2_proofs::poly::commitment::{CommitmentScheme, Params};
 use halo2_proofs::poly::commitment::{ParamsProver, Verifier};
 use halo2_proofs::poly::ipa::commitment::{IPACommitmentScheme, ParamsIPA};
@@ -40,7 +37,9 @@ use halo2_proofs::poly::kzg::strategy::AccumulatorStrategy as KZGAccumulatorStra
 use halo2_proofs::poly::kzg::{
     commitment::ParamsKZG, strategy::SingleStrategy as KZGSingleStrategy,
 };
+use halo2_proofs::poly::VerificationStrategy;
 use halo2_proofs::transcript::{EncodedChallenge, TranscriptReadBuffer};
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 use halo2_solidity_verifier;
 use halo2curves::bn256::{Bn256, Fr, G1Affine};
 use halo2curves::ff::{FromUniformBytes, WithSmallOrderMulGroup};
@@ -48,17 +47,21 @@ use halo2curves::serde::SerdeObject;
 use indicatif::{ProgressBar, ProgressStyle};
 use instant::Instant;
 use itertools::Itertools;
+use lazy_static::lazy_static;
 use log::debug;
 use log::{info, trace, warn};
-use serde::Serialize;
 use serde::de::DeserializeOwned;
+use serde::Serialize;
 use snark_verifier::loader::native::NativeLoader;
-use snark_verifier::system::halo2::Config;
 use snark_verifier::system::halo2::compile;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
+use snark_verifier::system::halo2::Config;
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 use std::fs::File;
 use std::io::BufWriter;
-use std::io::{Cursor, Write};
+use std::io::Cursor;
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
+use std::io::Write;
 use std::path::Path;
 use std::path::PathBuf;
 use std::str::FromStr;
@@ -68,8 +71,6 @@ use thiserror::Error;
 use tract_onnx::prelude::IntoTensor;
 use tract_onnx::prelude::Tensor as TractTensor;
 
-use lazy_static::lazy_static;
-
 lazy_static! {
     #[derive(Debug)]
     /// The path to the ezkl related data.
@@ -141,11 +142,15 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             data,
             variables,
             seed,
+            min,
+            max,
         } => gen_random_data(
             model.unwrap_or(DEFAULT_MODEL.into()),
             data.unwrap_or(DEFAULT_DATA.into()),
             variables,
             seed,
+            min,
+            max,
         ),
         Commands::CalibrateSettings {
             model,
@@ -166,7 +171,6 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             scale_rebase_multiplier,
             max_logrows,
         )
-        .await
         .map(|e| serde_json::to_string(&e).unwrap()),
         Commands::GenWitness {
             data,
@@ -176,17 +180,17 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             srs_path,
         } => gen_witness(
             compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
-            data.unwrap_or(DEFAULT_DATA.into()),
+            data.unwrap_or(DataField(DEFAULT_DATA.into())).to_string(),
             Some(output.unwrap_or(DEFAULT_WITNESS.into())),
             vk_path,
             srs_path,
         )
-        .await
         .map(|e| serde_json::to_string(&e).unwrap()),
         Commands::Mock { model, witness } => mock(
             model.unwrap_or(DEFAULT_MODEL.into()),
             witness.unwrap_or(DEFAULT_WITNESS.into()),
         ),
+        #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
         Commands::CreateEvmVerifier {
             vk_path,
             srs_path,
@@ -205,49 +209,35 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             )
             .await
         }
+        #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
         Commands::EncodeEvmCalldata {
             proof_path,
             calldata_path,
-            addr_vk,
+            vka_path,
         } => encode_evm_calldata(
             proof_path.unwrap_or(DEFAULT_PROOF.into()),
             calldata_path.unwrap_or(DEFAULT_CALLDATA.into()),
-            addr_vk,
+            vka_path,
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
-
-        Commands::CreateEvmVKArtifact {
+        #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
+        Commands::CreateEvmVka {
             vk_path,
             srs_path,
             settings_path,
-            sol_code_path,
-            abi_path,
+            vka_path,
+            decimals,
         } => {
             create_evm_vka(
                 vk_path.unwrap_or(DEFAULT_VK.into()),
                 srs_path,
                 settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
-                sol_code_path.unwrap_or(DEFAULT_VK_SOL.into()),
-                abi_path.unwrap_or(DEFAULT_VK_ABI.into()),
-            )
-            .await
-        }
-        Commands::CreateEvmDataAttestation {
-            settings_path,
-            sol_code_path,
-            abi_path,
-            data,
-            witness,
-        } => {
-            create_evm_data_attestation(
-                settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
-                sol_code_path.unwrap_or(DEFAULT_SOL_CODE_DA.into()),
-                abi_path.unwrap_or(DEFAULT_VERIFIER_DA_ABI.into()),
-                data.unwrap_or(DEFAULT_DATA.into()),
-                witness,
+                vka_path.unwrap_or(DEFAULT_VKA.into()),
+                decimals.unwrap_or(DEFAULT_DECIMALS.parse().unwrap()),
             )
             .await
         }
+        #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
         Commands::CreateEvmVerifierAggr {
             vk_path,
             srs_path,
@@ -293,29 +283,6 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             disable_selector_compression
                 .unwrap_or(DEFAULT_DISABLE_SELECTOR_COMPRESSION.parse().unwrap()),
         ),
-        Commands::SetupTestEvmData {
-            data,
-            compiled_circuit,
-            test_data,
-            rpc_url,
-            input_source,
-            output_source,
-        } => {
-            setup_test_evm_witness(
-                data.unwrap_or(DEFAULT_DATA.into()),
-                compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
-                test_data,
-                rpc_url,
-                input_source,
-                output_source,
-            )
-            .await
-        }
-        Commands::TestUpdateAccountCalls {
-            addr,
-            data,
-            rpc_url,
-        } => test_update_account_calls(addr, data.unwrap_or(DEFAULT_DATA.into()), rpc_url).await,
         Commands::SwapProofCommitments {
             proof_path,
             witness_path,
@@ -424,6 +391,7 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             commitment.into(),
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
+        #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
         Commands::DeployEvm {
             sol_code_path,
             rpc_url,
@@ -442,39 +410,35 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             )
             .await
         }
-        Commands::DeployEvmDataAttestation {
-            data,
-            settings_path,
-            sol_code_path,
-            rpc_url,
-            addr_path,
-            optimizer_runs,
-            private_key,
-        } => {
-            deploy_da_evm(
-                data.unwrap_or(DEFAULT_DATA.into()),
-                settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
-                sol_code_path.unwrap_or(DEFAULT_SOL_CODE_DA.into()),
-                rpc_url,
-                addr_path.unwrap_or(DEFAULT_CONTRACT_ADDRESS_DA.into()),
-                optimizer_runs,
-                private_key,
-            )
-            .await
-        }
+        #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
         Commands::VerifyEvm {
             proof_path,
             addr_verifier,
             rpc_url,
-            addr_da,
-            addr_vk,
+            vka_path,
         } => {
             verify_evm(
                 proof_path.unwrap_or(DEFAULT_PROOF.into()),
                 addr_verifier,
                 rpc_url,
-                addr_da,
-                addr_vk,
+                vka_path,
+            )
+            .await
+        }
+        #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
+        Commands::RegisterVka {
+            addr_verifier,
+            vka_path,
+            rpc_url,
+            vka_digest_path,
+            private_key,
+        } => {
+            register_vka(
+                rpc_url,
+                addr_verifier,
+                vka_path.unwrap_or(DEFAULT_VKA.into()),
+                vka_digest_path.unwrap_or(DEFAULT_VKA_DIGEST.into()),
+                private_key,
             )
             .await
         }
@@ -725,7 +689,7 @@ pub(crate) fn table(model: PathBuf, run_args: RunArgs) -> Result<String, EZKLErr
     Ok(String::new())
 }
 
-pub(crate) async fn gen_witness(
+pub(crate) fn gen_witness(
     compiled_circuit_path: PathBuf,
     data: String,
     output: Option<PathBuf>,
@@ -747,7 +711,7 @@ pub(crate) async fn gen_witness(
         None
     };
 
-    let mut input = circuit.load_graph_input(&data).await?;
+    let mut input = circuit.load_graph_input(&data)?;
     #[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
     let mut input = circuit.load_graph_input(&data)?;
 
@@ -849,6 +813,8 @@ pub(crate) fn gen_random_data(
     data_path: PathBuf,
     variables: Vec<(String, usize)>,
     seed: u64,
+    min: Option<f32>,
+    max: Option<f32>,
 ) -> Result<String, EZKLError> {
     let mut file = std::fs::File::open(&model_path).map_err(|e| {
         crate::graph::errors::GraphError::ReadWriteFileError(
@@ -867,22 +833,32 @@ pub(crate) fn gen_random_data(
         .collect::<tract_onnx::prelude::TractResult<Vec<_>>>()
         .map_err(|e| EZKLError::from(e.to_string()))?;
 
+    let min = min.unwrap_or(0.0);
+    let max = max.unwrap_or(1.0);
+
     /// Generates a random tensor of a given size and type.
     fn random(
         sizes: &[usize],
         datum_type: tract_onnx::prelude::DatumType,
         seed: u64,
+        min: f32,
+        max: f32,
     ) -> TractTensor {
         use rand::{Rng, SeedableRng};
         let mut rng = rand::rngs::StdRng::seed_from_u64(seed);
 
         let mut tensor = TractTensor::zero::<f32>(sizes).unwrap();
         let slice = tensor.as_slice_mut::<f32>().unwrap();
-        slice.iter_mut().for_each(|x| *x = rng.r#gen());
+        slice.iter_mut().for_each(|x| *x = rng.gen_range(min..max));
         tensor.cast_to_dt(datum_type).unwrap().into_owned()
     }
 
-    fn tensor_for_fact(fact: &tract_onnx::prelude::TypedFact, seed: u64) -> TractTensor {
+    fn tensor_for_fact(
+        fact: &tract_onnx::prelude::TypedFact,
+        seed: u64,
+        min: f32,
+        max: f32,
+    ) -> TractTensor {
         if let Some(value) = &fact.konst {
             return value.clone().into_tensor();
         }
@@ -893,12 +869,14 @@ pub(crate) fn gen_random_data(
                 .expect("Expected concrete shape, found: {fact:?}"),
             fact.datum_type,
             seed,
+            min,
+            max,
         )
     }
 
     let generated = input_facts
         .iter()
-        .map(|v| tensor_for_fact(v, seed))
+        .map(|v| tensor_for_fact(v, seed, min, max))
         .collect_vec();
 
     let data = GraphData::from_tract_data(&generated)?;
@@ -1044,7 +1022,7 @@ impl AccuracyResults {
 /// Calibrate the circuit parameters to a given a dataset
 #[allow(trivial_casts)]
 #[allow(clippy::too_many_arguments)]
-pub(crate) async fn calibrate(
+pub(crate) fn calibrate(
     model_path: PathBuf,
     data: String,
     settings_path: PathBuf,
@@ -1070,7 +1048,7 @@ pub(crate) async fn calibrate(
 
     let input_shapes = model.graph.input_shapes()?;
 
-    let chunks = data.split_into_batches(input_shapes).await?;
+    let chunks = data.split_into_batches(input_shapes)?;
     info!("num calibration batches: {}", chunks.len());
 
     debug!("running onnx predictions...");
@@ -1181,7 +1159,7 @@ pub(crate) async fn calibrate(
                 let chunk = chunk.clone();
 
                 let data = circuit
-                    .load_graph_from_file_exclusively(&chunk)
+                    .load_graph_input(&chunk)
                     .map_err(|e| format!("failed to load circuit inputs: {}", e))?;
 
                 let forward_res = circuit
@@ -1436,6 +1414,7 @@ pub(crate) fn mock(
     Ok(String::new())
 }
 
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 pub(crate) async fn create_evm_verifier(
     vk_path: PathBuf,
     srs_path: Option<PathBuf>,
@@ -1453,7 +1432,9 @@ pub(crate) async fn create_evm_verifier(
     )?;
 
     let num_instance = settings.total_instances();
-    let num_instance: usize = num_instance.iter().sum::<usize>();
+    // create a scales array that is the same length as the number of instances, all populated with 0
+    let scales = vec![0; num_instance.len()];
+    // let poseidon_instance = settings.module_sizes.num_instances().iter().sum::<usize>();
 
     let vk = load_vk::<KZGCommitmentScheme<Bn256>, GraphCircuit>(vk_path, settings)?;
     trace!("params computed");
@@ -1462,7 +1443,10 @@ pub(crate) async fn create_evm_verifier(
         &params,
         &vk,
         halo2_solidity_verifier::BatchOpenScheme::Bdfg21,
-        num_instance,
+        &num_instance,
+        &scales,
+        0,
+        0,
     );
     let (verifier_solidity, name) = if reusable {
         (generator.render_separately()?.0, "Halo2VerifierReusable") // ignore the rendered vk artifact for now and generate it in create_evm_vka
@@ -1480,12 +1464,13 @@ pub(crate) async fn create_evm_verifier(
     Ok(String::new())
 }
 
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 pub(crate) async fn create_evm_vka(
     vk_path: PathBuf,
     srs_path: Option<PathBuf>,
     settings_path: PathBuf,
-    sol_code_path: PathBuf,
-    abi_path: PathBuf,
+    vka_path: PathBuf,
+    decimals: usize,
 ) -> Result<String, EZKLError> {
     let settings = GraphSettings::load(&settings_path)?;
     let commitment: Commitments = settings.run_args.commitment.into();
@@ -1495,166 +1480,55 @@ pub(crate) async fn create_evm_vka(
         commitment,
     )?;
 
-    let num_instance = settings.total_instances();
-    let num_instance: usize = num_instance.iter().sum::<usize>();
+    let num_poseidon_instance = settings.module_sizes.num_instances().iter().sum::<usize>();
+    let num_fixed_point_instance = settings
+        .model_instance_shapes
+        .iter()
+        .map(|x| x.iter().product::<usize>())
+        .collect_vec();
 
+    let scales = settings.get_model_instance_scales();
     let vk = load_vk::<KZGCommitmentScheme<Bn256>, GraphCircuit>(vk_path, settings)?;
     trace!("params computed");
+    // assert that the decimals must be less than or equal to 38 to prevent overflow
+    if decimals > 38 {
+        return Err("decimals must be less than or equal to 38".into());
+    }
 
     let generator = halo2_solidity_verifier::SolidityGenerator::new(
         &params,
         &vk,
         halo2_solidity_verifier::BatchOpenScheme::Bdfg21,
-        num_instance,
+        &num_fixed_point_instance,
+        &scales,
+        decimals,
+        num_poseidon_instance,
     );
 
-    let vk_solidity = generator.render_separately()?.1;
+    let vka_words: Vec<[u8; 32]> = generator.render_separately_vka_words()?.1;
+    let serialized_vka_words = bincode::serialize(&vka_words).or_else(|e| {
+        Err(EZKLError::from(format!(
+            "Failed to serialize vka words: {}",
+            e
+        )))
+    })?;
 
-    File::create(sol_code_path.clone())?.write_all(vk_solidity.as_bytes())?;
+    File::create(vka_path.clone())?.write_all(&serialized_vka_words)?;
 
-    // fetch abi of the contract
-    let (abi, _, _) = get_contract_artifacts(sol_code_path, "Halo2VerifyingArtifact", 0).await?;
-    // save abi to file
-    serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
+    // Load in the vka words and deserialize them and check that they match the original
+    let bytes = std::fs::read(vka_path)?;
+    let vka_buf: Vec<[u8; 32]> = bincode::deserialize(&bytes)
+        .map_err(|e| EZKLError::from(format!("Failed to deserialize vka words: {e}")))?;
+    if vka_buf != vka_words {
+        return Err("vka words do not match".into());
+    };
 
     Ok(String::new())
 }
-
-pub(crate) async fn create_evm_data_attestation(
-    settings_path: PathBuf,
-    sol_code_path: PathBuf,
-    abi_path: PathBuf,
-    input: String,
-    witness: Option<PathBuf>,
-) -> Result<String, EZKLError> {
-    #[allow(unused_imports)]
-    use crate::graph::{DataSource, VarVisibility};
-    use crate::{graph::Visibility, pfsys::get_proof_commitments};
-
-    let settings = GraphSettings::load(&settings_path)?;
-
-    let visibility = VarVisibility::from_args(&settings.run_args)?;
-    trace!("params computed");
-
-    // if input is not provided, we just instantiate dummy input data
-    let data =
-        GraphData::from_str(&input).unwrap_or_else(|_| GraphData::new(DataSource::File(vec![])));
-
-    // The number of input and output instances we attest to for the single call data attestation
-    let mut input_len = None;
-    let mut output_len = None;
-
-    let output_data = if let Some(DataSource::OnChain(source)) = data.output_data {
-        if visibility.output.is_private() {
-            return Err("private output data on chain is not supported on chain".into());
-        }
-        let mut on_chain_output_data = vec![];
-        match source.calls {
-            Calls::Multiple(calls) => {
-                for call in calls {
-                    on_chain_output_data.push(call);
-                }
-            }
-            Calls::Single(call) => {
-                output_len = Some(call.len);
-            }
-        }
-        Some(on_chain_output_data)
-    } else {
-        None
-    };
-
-    let input_data = if let DataSource::OnChain(source) = data.input_data {
-        if visibility.input.is_private() {
-            return Err("private input data on chain is not supported on chain".into());
-        }
-        let mut on_chain_input_data = vec![];
-        match source.calls {
-            Calls::Multiple(calls) => {
-                for call in calls {
-                    on_chain_input_data.push(call);
-                }
-            }
-            Calls::Single(call) => {
-                input_len = Some(call.len);
-            }
-        }
-        Some(on_chain_input_data)
-    } else {
-        None
-    };
-
-    // Read the settings file. Look if either the run_ars.input_visibility, run_args.output_visibility or run_args.param_visibility is KZGCommit
-    // if so, then we need to load the witness
-
-    let commitment_bytes = if settings.run_args.input_visibility == Visibility::KZGCommit
-        || settings.run_args.output_visibility == Visibility::KZGCommit
-        || settings.run_args.param_visibility == Visibility::KZGCommit
-    {
-        let witness = GraphWitness::from_path(witness.unwrap_or(DEFAULT_WITNESS.into()))?;
-        let commitments = witness.get_polycommitments();
-        let proof_first_bytes = get_proof_commitments::<
-            KZGCommitmentScheme<Bn256>,
-            _,
-            EvmTranscript<G1Affine, _, _, _>,
-        >(&commitments);
-
-        Some(proof_first_bytes.unwrap())
-    } else {
-        None
-    };
-
-    // if either input_len or output_len is Some then we are in the single call data attestation mode
-    if input_len.is_some() || output_len.is_some() {
-        let output = fix_da_single_sol(input_len, output_len)?;
-        let mut f = File::create(sol_code_path.clone())?;
-        let _ = f.write(output.as_bytes());
-        // fetch abi of the contract
-        let (abi, _, _) = get_contract_artifacts(sol_code_path, "DataAttestationSingle", 0).await?;
-        // save abi to file
-        serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
-    } else {
-        let output = fix_da_multi_sol(input_data, output_data, commitment_bytes)?;
-        let mut f = File::create(sol_code_path.clone())?;
-        let _ = f.write(output.as_bytes());
-        // fetch abi of the contract
-        let (abi, _, _) = get_contract_artifacts(sol_code_path, "DataAttestationMulti", 0).await?;
-        // save abi to file
-        serde_json::to_writer(std::fs::File::create(abi_path)?, &abi)?;
-    }
-
-    Ok(String::new())
-}
-
-pub(crate) async fn deploy_da_evm(
-    data: String,
-    settings_path: PathBuf,
-    sol_code_path: PathBuf,
-    rpc_url: Option<String>,
-    addr_path: PathBuf,
-    runs: usize,
-    private_key: Option<String>,
-) -> Result<String, EZKLError> {
-    let contract_address = deploy_da_verifier_via_solidity(
-        settings_path,
-        data,
-        sol_code_path,
-        rpc_url.as_deref(),
-        runs,
-        private_key.as_deref(),
-    )
-    .await?;
-    info!("Contract deployed at: {}", contract_address);
-
-    let mut f = File::create(addr_path)?;
-    write!(f, "{:#?}", contract_address)?;
-
-    Ok(String::new())
-}
-
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 pub(crate) async fn deploy_evm(
     sol_code_path: PathBuf,
-    rpc_url: Option<String>,
+    rpc_url: String,
     addr_path: PathBuf,
     runs: usize,
     private_key: Option<String>,
@@ -1663,11 +1537,10 @@ pub(crate) async fn deploy_evm(
     let contract_name = match contract {
         ContractType::Verifier { reusable: false } => "Halo2Verifier",
         ContractType::Verifier { reusable: true } => "Halo2VerifierReusable",
-        ContractType::VerifyingKeyArtifact => "Halo2VerifyingArtifact",
     };
     let contract_address = deploy_contract_via_solidity(
         sol_code_path,
-        rpc_url.as_deref(),
+        &rpc_url,
         runs,
         private_key.as_deref(),
         contract_name,
@@ -1681,21 +1554,61 @@ pub(crate) async fn deploy_evm(
     Ok(String::new())
 }
 
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
+pub(crate) async fn register_vka(
+    rpc_url: String,
+    rv_addr: H160Flag,
+    vka_path: PathBuf,
+    vka_digest_path: PathBuf,
+    private_key: Option<String>,
+) -> Result<String, EZKLError> {
+    // Load the vka, which is bincode serialized, from the vka_path
+    let bytes = std::fs::read(vka_path)?;
+    let vka_buf: Vec<[u8; 32]> = bincode::deserialize(&bytes)
+        .map_err(|e| EZKLError::from(format!("Failed to deserialize vka words: {e}")))?;
+    let vka_digest = register_vka_via_rv(
+        rpc_url.as_ref(),
+        private_key.as_deref(),
+        rv_addr.into(),
+        &vka_buf,
+    )
+    .await?;
+
+    info!("VKA digest: {:#?}", vka_digest);
+
+    let mut f = File::create(vka_digest_path)?;
+    write!(f, "{:#?}", vka_digest)?;
+    Ok(String::new())
+}
+
 /// Encodes the calldata for the EVM verifier (both aggregated and single proof)
+/// TODO: Add a "RV address param" which will query the "RegisteredVKA" events to fetch the
+/// VKA from the vka_digest.
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 pub(crate) fn encode_evm_calldata(
     proof_path: PathBuf,
     calldata_path: PathBuf,
-    addr_vk: Option<H160Flag>,
+    vka_path: Option<PathBuf>,
 ) -> Result<Vec<u8>, EZKLError> {
     let snark = Snark::load::<IPACommitmentScheme<G1Affine>>(&proof_path)?;
 
     let flattened_instances = snark.instances.into_iter().flatten();
 
+    // Load the vka, which is bincode serialized, from the vka_path
+    let vka_buf: Option<Vec<[u8; 32]>> =
+        match vka_path {
+            Some(path) => {
+                let bytes = std::fs::read(path)?;
+                Some(bincode::deserialize(&bytes).map_err(|e| {
+                    EZKLError::from(format!("Failed to deserialize vka words: {e}"))
+                })?)
+            }
+            None => None,
+        };
+
+    let vka: Option<&[[u8; 32]]> = vka_buf.as_deref();
     let encoded = halo2_solidity_verifier::encode_calldata(
-        addr_vk
-            .as_ref()
-            .map(|x| alloy::primitives::Address::from(*x).0)
-            .map(|x| x.0),
+        vka,
         &snark.proof,
         &flattened_instances.collect::<Vec<_>>(),
     );
@@ -1707,35 +1620,24 @@ pub(crate) fn encode_evm_calldata(
     Ok(encoded)
 }
 
+/// TODO: Add an optional vka_digest param that will allow use to fetch the assocaited VKA
+/// from the RegisteredVKA events on the RV.
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 pub(crate) async fn verify_evm(
     proof_path: PathBuf,
     addr_verifier: H160Flag,
-    rpc_url: Option<String>,
-    addr_da: Option<H160Flag>,
-    addr_vk: Option<H160Flag>,
+    rpc_url: String,
+    vka_path: Option<PathBuf>,
 ) -> Result<String, EZKLError> {
-    use crate::eth::verify_proof_with_data_attestation;
-
     let proof = Snark::load::<KZGCommitmentScheme<Bn256>>(&proof_path)?;
 
-    let result = if let Some(addr_da) = addr_da {
-        verify_proof_with_data_attestation(
-            proof.clone(),
-            addr_verifier.into(),
-            addr_da.into(),
-            addr_vk.map(|s| s.into()),
-            rpc_url.as_deref(),
-        )
-        .await?
-    } else {
-        verify_proof_via_solidity(
-            proof.clone(),
-            addr_verifier.into(),
-            addr_vk.map(|s| s.into()),
-            rpc_url.as_deref(),
-        )
-        .await?
-    };
+    let result = verify_proof_via_solidity(
+        proof.clone(),
+        addr_verifier.into(),
+        vka_path.map(|s| s.into()),
+        rpc_url.as_ref(),
+    )
+    .await?;
 
     info!("Solidity verification result: {}", result);
 
@@ -1746,6 +1648,7 @@ pub(crate) async fn verify_evm(
     Ok(String::new())
 }
 
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 pub(crate) async fn create_evm_aggregate_verifier(
     vk_path: PathBuf,
     srs_path: Option<PathBuf>,
@@ -1771,8 +1674,8 @@ pub(crate) async fn create_evm_aggregate_verifier(
         .sum();
 
     let num_instance = AggregationCircuit::num_instance(num_instance);
+    let scales = vec![0; num_instance.len()];
     assert_eq!(num_instance.len(), 1);
-    let num_instance = num_instance[0];
 
     let agg_vk = load_vk::<KZGCommitmentScheme<Bn256>, AggregationCircuit>(vk_path, ())?;
 
@@ -1780,7 +1683,10 @@ pub(crate) async fn create_evm_aggregate_verifier(
         &params,
         &agg_vk,
         halo2_solidity_verifier::BatchOpenScheme::Bdfg21,
-        num_instance,
+        &num_instance,
+        &scales,
+        0,
+        0,
     );
 
     let acc_encoding = halo2_solidity_verifier::AccumulatorEncoding::new(
@@ -1869,53 +1775,7 @@ pub(crate) fn setup(
     Ok(String::new())
 }
 
-pub(crate) async fn setup_test_evm_witness(
-    data_path: String,
-    compiled_circuit_path: PathBuf,
-    test_data: PathBuf,
-    rpc_url: Option<String>,
-    input_source: TestDataSource,
-    output_source: TestDataSource,
-) -> Result<String, EZKLError> {
-    use crate::graph::TestOnChainData;
-
-    let mut data = GraphData::from_str(&data_path)?;
-    let mut circuit = GraphCircuit::load(compiled_circuit_path)?;
-
-    // if both input and output are from files fail
-    if matches!(input_source, TestDataSource::File) && matches!(output_source, TestDataSource::File)
-    {
-        return Err("Both input and output cannot be from files".into());
-    }
-
-    let test_on_chain_data = TestOnChainData {
-        data: test_data.clone(),
-        rpc: rpc_url,
-        data_sources: TestSources {
-            input: input_source,
-            output: output_source,
-        },
-    };
-
-    circuit
-        .populate_on_chain_test_data(&mut data, test_on_chain_data)
-        .await?;
-
-    Ok(String::new())
-}
-
 use crate::pfsys::ProofType;
-pub(crate) async fn test_update_account_calls(
-    addr: H160Flag,
-    data: String,
-    rpc_url: Option<String>,
-) -> Result<String, EZKLError> {
-    use crate::eth::update_account_calls;
-
-    update_account_calls(addr.into(), data, rpc_url.as_deref()).await?;
-
-    Ok(String::new())
-}
 
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn prove(

src/graph/errors.rs

@@ -98,14 +98,13 @@ pub enum GraphError {
         feature = "ezkl",
         not(all(target_arch = "wasm32", target_os = "unknown"))
     ))]
-    #[error("[tokio postgres] {0}")]
-    TokioPostgresError(#[from] tokio_postgres::Error),
     /// Eth error
     #[cfg(all(
         feature = "ezkl",
         not(all(target_arch = "wasm32", target_os = "unknown"))
     ))]
     #[error("[eth] {0}")]
+    #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
     EthError(#[from] crate::eth::EthError),
     /// Json error
     #[error("[json] {0}")]
@@ -141,7 +140,9 @@ pub enum GraphError {
     #[error("range check {0} is too large")]
     RangeCheckTooLarge(usize),
     ///Cannot use on-chain data source as private data
-    #[error("cannot use on-chain data source as 1) output for on-chain test 2) as private data 3) as input when using wasm.")]
+    #[error(
+        "cannot use on-chain data source as 1) output for on-chain test 2) as private data 3) as input when using wasm."
+    )]
     OnChainDataSource,
     /// Missing data source
     #[error("missing data source")]

src/graph/input.rs

@@ -2,10 +2,6 @@ use super::errors::GraphError;
 use super::quantize_float;
 use crate::circuit::InputType;
 use crate::fieldutils::integer_rep_to_felt;
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-use crate::graph::postgres::Client;
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-use crate::tensor::Tensor;
 use crate::EZKL_BUF_CAPACITY;
 use halo2curves::bn256::Fr as Fp;
 #[cfg(feature = "python-bindings")]
@@ -25,9 +21,6 @@ use tract_onnx::tract_core::{
     value::TValue,
 };
 
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-use tract_onnx::tract_hir::tract_num_traits::ToPrimitive;
-
 type Decimals = u8;
 type Call = String;
 type RPCUrl = String;
@@ -168,159 +161,26 @@ impl<'de> Deserialize<'de> for FileSourceInner {
 /// Organized as a vector of vectors where each inner vector represents a row/entry
 pub type FileSource = Vec<Vec<FileSourceInner>>;
 
-/// Represents different types of calls for fetching on-chain data
-#[derive(Clone, Debug, PartialOrd, PartialEq)]
-pub enum Calls {
-    /// Multiple calls to different accounts, each returning individual values
-    Multiple(Vec<CallsToAccount>),
-    /// Single call returning an array of values
-    Single(CallToAccount),
-}
+/// Represents which parts of the model (input/output) are attested to on-chain
+pub type InputOutput = (bool, bool);
 
-impl Default for Calls {
-    fn default() -> Self {
-        Calls::Multiple(Vec::new())
-    }
-}
-
-impl Serialize for Calls {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match self {
-            Calls::Single(data) => data.serialize(serializer),
-            Calls::Multiple(data) => data.serialize(serializer),
-        }
-    }
-}
-
-// !!! ALWAYS USE JSON SERIALIZATION FOR GRAPH INPUT
-// UNTAGGED ENUMS WONT WORK :( as highlighted here:
-impl<'de> Deserialize<'de> for Calls {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let this_json: Box<serde_json::value::RawValue> = Deserialize::deserialize(deserializer)?;
-        let multiple_try: Result<Vec<CallsToAccount>, _> = serde_json::from_str(this_json.get());
-        if let Ok(t) = multiple_try {
-            return Ok(Calls::Multiple(t));
-        }
-        let single_try: Result<CallToAccount, _> = serde_json::from_str(this_json.get());
-        if let Ok(t) = single_try {
-            return Ok(Calls::Single(t));
-        }
-
-        Err(serde::de::Error::custom("failed to deserialize Calls"))
-    }
-}
 /// Configuration for accessing on-chain data sources
 #[derive(Clone, Debug, Deserialize, Serialize, Default, PartialOrd, PartialEq)]
 pub struct OnChainSource {
     /// Call specifications for fetching data
-    pub calls: Calls,
+    pub call: CallToAccount,
     /// RPC endpoint URL for accessing the chain
     pub rpc: RPCUrl,
 }
 
 impl OnChainSource {
-    /// Creates a new OnChainSource with multiple calls
-    ///
-    /// # Arguments
-    /// * `calls` - Vector of call specifications
-    /// * `rpc` - RPC endpoint URL
-    pub fn new_multiple(calls: Vec<CallsToAccount>, rpc: RPCUrl) -> Self {
-        OnChainSource {
-            calls: Calls::Multiple(calls),
-            rpc,
-        }
-    }
-
-    /// Creates a new OnChainSource with a single call
+    /// Creates a new OnChainSource
     ///
     /// # Arguments
     /// * `call` - Call specification
     /// * `rpc` - RPC endpoint URL
-    pub fn new_single(call: CallToAccount, rpc: RPCUrl) -> Self {
-        OnChainSource {
-            calls: Calls::Single(call),
-            rpc,
-        }
-    }
-
-    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-    /// Creates test data for the OnChain data source
-    /// Used for testing and development purposes
-    ///
-    /// # Arguments
-    /// * `data` - Sample file data to use
-    /// * `scales` - Scaling factors for each input
-    /// * `shapes` - Shapes of the input tensors
-    /// * `rpc` - Optional RPC endpoint override
-    pub async fn test_from_file_data(
-        data: &FileSource,
-        scales: Vec<crate::Scale>,
-        mut shapes: Vec<Vec<usize>>,
-        rpc: Option<&str>,
-    ) -> Result<(Vec<Tensor<Fp>>, Self), GraphError> {
-        use crate::eth::{
-            evm_quantize_multi, read_on_chain_inputs_multi, test_on_chain_data,
-            DEFAULT_ANVIL_ENDPOINT,
-        };
-        use log::debug;
-
-        // Set up local anvil instance for reading on-chain data
-        let (client, client_address) = crate::eth::setup_eth_backend(rpc, None).await?;
-
-        let mut scales = scales;
-        // set scales to 1 where data is a field element
-        for (idx, i) in data.iter().enumerate() {
-            if i.iter().all(|e| e.is_field()) {
-                scales[idx] = 0;
-                shapes[idx] = vec![i.len()];
-            }
-        }
-
-        let calls_to_accounts = test_on_chain_data(client.clone(), data).await?;
-        debug!("Calls to accounts: {:?}", calls_to_accounts);
-        let inputs =
-            read_on_chain_inputs_multi(client.clone(), client_address, &calls_to_accounts).await?;
-        debug!("Inputs: {:?}", inputs);
-
-        let mut quantized_evm_inputs = vec![];
-
-        let mut prev = 0;
-        for (idx, i) in data.iter().enumerate() {
-            quantized_evm_inputs.extend(
-                evm_quantize_multi(
-                    client.clone(),
-                    vec![scales[idx]; i.len()],
-                    &(
-                        inputs.0[prev..i.len()].to_vec(),
-                        inputs.1[prev..i.len()].to_vec(),
-                    ),
-                )
-                .await?,
-            );
-            prev += i.len();
-        }
-
-        // on-chain data has already been quantized at this point. Just need to reshape it and push into tensor vector
-        let mut inputs: Vec<Tensor<Fp>> = vec![];
-        for (input, shape) in [quantized_evm_inputs].iter().zip(shapes) {
-            let mut t: Tensor<Fp> = input.iter().cloned().collect();
-            t.reshape(&shape)?;
-            inputs.push(t);
-        }
-
-        let used_rpc = rpc.unwrap_or(DEFAULT_ANVIL_ENDPOINT).to_string();
-
-        // Fill the input_data field of the GraphData struct
-        Ok((
-            inputs,
-            OnChainSource::new_multiple(calls_to_accounts.clone(), used_rpc),
-        ))
+    pub fn new(call: CallToAccount, rpc: RPCUrl) -> Self {
+        OnChainSource { call, rpc }
     }
 }
 
@@ -342,41 +202,37 @@ pub struct CallToAccount {
     /// ABI-encoded function call data
     pub call_data: Call,
     /// Number of decimal places for float conversion
-    pub decimals: Decimals,
+    pub decimals: Vec<Decimals>,
     /// Contract address to call
     pub address: String,
-    /// Expected length of returned array
-    pub len: usize,
 }
 
 /// Represents different sources of input/output data for the EZKL model
 #[derive(Clone, Debug, Serialize, PartialOrd, PartialEq)]
-#[serde(untagged)]
-pub enum DataSource {
-    /// Data from a JSON file containing arrays of values
-    File(FileSource),
-    /// Data fetched from blockchain contracts
-    OnChain(OnChainSource),
-    /// Data from a PostgreSQL database
-    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-    DB(PostgresSource),
+pub struct DataSource(FileSource);
+
+impl DataSource {
+    /// Gets the underlying file source data
+    pub fn values(&self) -> &FileSource {
+        &self.0
+    }
 }
 
 impl Default for DataSource {
     fn default() -> Self {
-        DataSource::File(vec![vec![]])
+        DataSource(vec![vec![]])
     }
 }
 
 impl From<FileSource> for DataSource {
     fn from(data: FileSource) -> Self {
-        DataSource::File(data)
+        DataSource(data)
     }
 }
 
 impl From<Vec<Vec<Fp>>> for DataSource {
     fn from(data: Vec<Vec<Fp>>) -> Self {
-        DataSource::File(
+        DataSource(
             data.iter()
                 .map(|e| e.iter().map(|e| FileSourceInner::Field(*e)).collect())
                 .collect(),
@@ -386,7 +242,7 @@ impl From<Vec<Vec<Fp>>> for DataSource {
 
 impl From<Vec<Vec<f64>>> for DataSource {
     fn from(data: Vec<Vec<f64>>) -> Self {
-        DataSource::File(
+        DataSource(
             data.iter()
                 .map(|e| e.iter().map(|e| FileSourceInner::Float(*e)).collect())
                 .collect(),
@@ -394,12 +250,6 @@ impl From<Vec<Vec<f64>>> for DataSource {
     }
 }
 
-impl From<OnChainSource> for DataSource {
-    fn from(data: OnChainSource) -> Self {
-        DataSource::OnChain(data)
-    }
-}
-
 // Note: Always use JSON serialization for untagged enums
 impl<'de> Deserialize<'de> for DataSource {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -411,22 +261,7 @@ impl<'de> Deserialize<'de> for DataSource {
         // Try deserializing as FileSource first
         let first_try: Result<FileSource, _> = serde_json::from_str(this_json.get());
         if let Ok(t) = first_try {
-            return Ok(DataSource::File(t));
-        }
-
-        // Try deserializing as OnChainSource
-        let second_try: Result<OnChainSource, _> = serde_json::from_str(this_json.get());
-        if let Ok(t) = second_try {
-            return Ok(DataSource::OnChain(t));
-        }
-
-        // Try deserializing as PostgresSource if feature enabled
-        #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-        {
-            let third_try: Result<PostgresSource, _> = serde_json::from_str(this_json.get());
-            if let Ok(t) = third_try {
-                return Ok(DataSource::DB(t));
-            }
+            return Ok(DataSource(t));
         }
 
         Err(serde::de::Error::custom("failed to deserialize DataSource"))
@@ -462,25 +297,16 @@ impl GraphData {
         datum_types: &[tract_onnx::prelude::DatumType],
     ) -> Result<TVec<TValue>, GraphError> {
         let mut inputs = TVec::new();
-        match &self.input_data {
-            DataSource::File(data) => {
-                for (i, input) in data.iter().enumerate() {
-                    if !input.is_empty() {
-                        let dt = datum_types[i];
-                        let input = input.iter().map(|e| e.to_float()).collect::<Vec<f64>>();
-                        let tt = TractTensor::from_shape(&shapes[i], &input)?;
-                        let tt = tt.cast_to_dt(dt)?;
-                        inputs.push(tt.into_owned().into());
-                    }
-                }
-            }
-            _ => {
-                return Err(GraphError::InvalidDims(
-                    0,
-                    "non file data cannot be split into batches".to_string(),
-                ))
+        for (i, input) in self.input_data.values().iter().enumerate() {
+            if !input.is_empty() {
+                let dt = datum_types[i];
+                let input = input.iter().map(|e| e.to_float()).collect::<Vec<f64>>();
+                let tt = TractTensor::from_shape(&shapes[i], &input)?;
+                let tt = tt.cast_to_dt(dt)?;
+                inputs.push(tt.into_owned().into());
             }
         }
+
         Ok(inputs)
     }
 
@@ -512,7 +338,7 @@ impl GraphData {
             }
         }
         Ok(GraphData {
-            input_data: DataSource::File(input_data),
+            input_data: DataSource(input_data),
             output_data: None,
         })
     }
@@ -531,13 +357,13 @@ impl GraphData {
     /// Loads graph input data from a string, first seeing if it is a file path or JSON data
     /// If it is a file path, it will load the data from the file
     /// Otherwise, it will attempt to parse the string as JSON data
-    /// 
+    ///
     /// # Arguments
     /// * `data` - String containing the input data
     /// # Returns
     /// A new GraphData instance containing the loaded data
     pub fn from_str(data: &str) -> Result<Self, GraphError> {
-        let graph_input = serde_json::from_str(data); 
+        let graph_input = serde_json::from_str(data);
         match graph_input {
             Ok(graph_input) => {
                 return Ok(graph_input);
@@ -594,7 +420,7 @@ impl GraphData {
     /// Returns error if:
     /// - Data is from on-chain source
     /// - Input size is not evenly divisible by batch size
-    pub async fn split_into_batches(
+    pub fn split_into_batches(
         &self,
         input_shapes: Vec<Vec<usize>>,
     ) -> Result<Vec<Self>, GraphError> {
@@ -602,23 +428,9 @@ impl GraphData {
 
         let iterable = match self {
             GraphData {
-                input_data: DataSource::File(data),
+                input_data: DataSource(data),
                 output_data: _,
             } => data.clone(),
-            GraphData {
-                input_data: DataSource::OnChain(_),
-                output_data: _,
-            } => {
-                return Err(GraphError::InvalidDims(
-                    0,
-                    "on-chain data cannot be split into batches".to_string(),
-                ))
-            }
-            #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-            GraphData {
-                input_data: DataSource::DB(data),
-                output_data: _,
-            } => data.fetch_and_format_as_file().await?,
         };
 
         // Process each input tensor according to its shape
@@ -635,7 +447,6 @@ impl GraphData {
                         input.len(),
                         input_size
                     ),
-                    
                 ));
             }
 
@@ -665,12 +476,12 @@ impl GraphData {
             for input in batched_inputs.iter() {
                 batch.push(input[i].clone());
             }
-            input_batches.push(DataSource::File(batch));
+            input_batches.push(DataSource(batch));
         }
 
         // Ensure at least one batch exists
         if input_batches.is_empty() {
-            input_batches.push(DataSource::File(vec![vec![]]));
+            input_batches.push(DataSource(vec![vec![]]));
         }
 
         // Create GraphData instance for each batch
@@ -683,45 +494,12 @@ impl GraphData {
     }
 }
 
-#[cfg(feature = "python-bindings")]
-impl ToPyObject for CallsToAccount {
-    /// Converts CallsToAccount to Python object
-    fn to_object(&self, py: Python) -> PyObject {
-        let dict = PyDict::new(py);
-        dict.set_item("account", &self.address).unwrap();
-        dict.set_item("call_data", &self.call_data).unwrap();
-        dict.to_object(py)
-    }
-}
-
 // Additional Python bindings for various types...
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn test_postgres_source_new() {
-        #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-        {
-            let source = PostgresSource::new(
-                "localhost".to_string(),
-                "5432".to_string(),
-                "user".to_string(),
-                "SELECT * FROM table".to_string(),
-                "database".to_string(),
-                "password".to_string(),
-            );
-
-            assert_eq!(source.host, "localhost");
-            assert_eq!(source.port, "5432");
-            assert_eq!(source.user, "user");
-            assert_eq!(source.query, "SELECT * FROM table");
-            assert_eq!(source.dbname, "database");
-            assert_eq!(source.password, "password");
-        }
-    }
-
     #[test]
     fn test_data_source_serialization_round_trip() {
         // Test backwards compatibility with old format
@@ -764,95 +542,6 @@ mod tests {
     }
 }
 
-/// Source data from a PostgreSQL database
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-#[derive(Clone, Debug, Deserialize, Serialize, Default, PartialOrd, PartialEq)]
-pub struct PostgresSource {
-    /// Database host address
-    pub host: RPCUrl,
-    /// Database user name
-    pub user: String,
-    /// Database password
-    pub password: String,
-    /// SQL query to execute
-    pub query: String,
-    /// Database name
-    pub dbname: String,
-    /// Database port
-    pub port: String,
-}
-
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-impl PostgresSource {
-    /// Creates a new PostgreSQL data source
-    pub fn new(
-        host: RPCUrl,
-        port: String,
-        user: String,
-        query: String,
-        dbname: String,
-        password: String,
-    ) -> Self {
-        PostgresSource {
-            host,
-            user,
-            password,
-            query,
-            dbname,
-            port,
-        }
-    }
-
-    /// Fetches data from the PostgreSQL database
-    pub async fn fetch(&self) -> Result<Vec<Vec<pg_bigdecimal::PgNumeric>>, GraphError> {
-        // Configuration string
-        let config = if self.password.is_empty() {
-            format!(
-                "host={} user={} dbname={} port={}",
-                self.host, self.user, self.dbname, self.port
-            )
-        } else {
-            format!(
-                "host={} user={} dbname={} port={} password={}",
-                self.host, self.user, self.dbname, self.port, self.password
-            )
-        };
-
-        let mut client = Client::connect(&config).await?;
-        let mut res: Vec<pg_bigdecimal::PgNumeric> = Vec::new();
-
-        // Extract rows from query
-        for row in client.query(&self.query, &[]).await? {
-            for i in 0..row.len() {
-                res.push(row.get(i));
-            }
-        }
-        Ok(vec![res])
-    }
-
-    /// Fetches and formats data as FileSource
-    pub async fn fetch_and_format_as_file(&self) -> Result<Vec<Vec<FileSourceInner>>, GraphError> {
-        Ok(self
-            .fetch()
-            .await?
-            .iter()
-            .map(|d| {
-                d.iter()
-                    .map(|d| {
-                        FileSourceInner::Float(
-                            d.n.as_ref()
-                                .unwrap()
-                                .to_f64()
-                                .ok_or("could not convert decimal to f64")
-                                .unwrap(),
-                        )
-                    })
-                    .collect()
-            })
-            .collect())
-    }
-}
-
 #[cfg(feature = "python-bindings")]
 impl ToPyObject for CallToAccount {
     fn to_object(&self, py: Python) -> PyObject {
@@ -860,42 +549,14 @@ impl ToPyObject for CallToAccount {
         dict.set_item("account", &self.address).unwrap();
         dict.set_item("call_data", &self.call_data).unwrap();
         dict.set_item("decimals", &self.decimals).unwrap();
-        dict.set_item("len", &self.len).unwrap();
         dict.to_object(py)
     }
 }
 
-#[cfg(feature = "python-bindings")]
-impl ToPyObject for Calls {
-    fn to_object(&self, py: Python) -> PyObject {
-        match self {
-            Calls::Multiple(calls) => calls.to_object(py),
-            Calls::Single(call) => call.to_object(py),
-        }
-    }
-}
-
 #[cfg(feature = "python-bindings")]
 impl ToPyObject for DataSource {
     fn to_object(&self, py: Python) -> PyObject {
-        match self {
-            DataSource::File(data) => data.to_object(py),
-            DataSource::OnChain(source) => {
-                let dict = PyDict::new(py);
-                dict.set_item("rpc_url", &source.rpc).unwrap();
-                dict.set_item("calls_to_accounts", &source.calls.to_object(py))
-                    .unwrap();
-                dict.to_object(py)
-            }
-            #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-            DataSource::DB(source) => {
-                let dict = PyDict::new(py);
-                dict.set_item("host", &source.host).unwrap();
-                dict.set_item("user", &source.user).unwrap();
-                dict.set_item("query", &source.query).unwrap();
-                dict.to_object(py)
-            }
-        }
+        self.0.to_object(py)
     }
 }
 

src/graph/mod.rs

@@ -6,9 +6,6 @@ pub mod model;
 pub mod modules;
 /// Inner elements of a computational graph that represent a single operation / constraints.
 pub mod node;
-/// postgres helper functions
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-pub mod postgres;
 /// Helper functions
 pub mod utilities;
 /// Representations of a computational graph's variables.
@@ -28,9 +25,11 @@ use itertools::Itertools;
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tosubcommand::ToFlags;
 
+#[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
+use self::input::{FileSource, GraphData};
+
 use self::errors::GraphError;
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-use self::input::OnChainSource;
 use self::input::{FileSource, GraphData};
 use self::modules::{GraphModules, ModuleConfigs, ModuleForwardResult, ModuleSizes};
 use crate::circuit::lookup::LookupOp;
@@ -541,16 +540,38 @@ impl GraphSettings {
 
     /// calculate the total number of instances
     pub fn total_instances(&self) -> Vec<usize> {
-        let mut instances: Vec<usize> = self
-            .model_instance_shapes
-            .iter()
-            .map(|x| x.iter().product())
-            .collect();
-        instances.extend(self.module_sizes.num_instances());
+        let mut instances: Vec<usize> = self.module_sizes.num_instances();
+        instances.extend(
+            self.model_instance_shapes
+                .iter()
+                .map(|x| x.iter().product::<usize>()),
+        );
 
         instances
     }
 
+    /// get the scale data for instances
+    pub fn get_model_instance_scales(&self) -> Vec<crate::Scale> {
+        let mut scales = vec![];
+        if self.run_args.input_visibility.is_public() {
+            scales.extend(
+                self.model_input_scales
+                    .iter()
+                    .map(|x| x.clone())
+                    .collect::<Vec<crate::Scale>>(),
+            );
+        };
+        if self.run_args.output_visibility.is_public() {
+            scales.extend(
+                self.model_output_scales
+                    .iter()
+                    .map(|x| x.clone())
+                    .collect::<Vec<crate::Scale>>(),
+            );
+        };
+        scales
+    }
+
     /// calculate the log2 of the total number of instances
     pub fn log2_total_instances(&self) -> u32 {
         let sum = self.total_instances().iter().sum::<usize>();
@@ -764,7 +785,7 @@ pub struct TestOnChainData {
     /// The path to the test witness
     pub data: std::path::PathBuf,
     /// rpc endpoint
-    pub rpc: Option<String>,
+    pub rpc: String,
     /// data sources for the on chain data
     pub data_sources: TestSources,
 }
@@ -931,128 +952,11 @@ impl GraphCircuit {
     }
 
     ///
-    #[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
     pub fn load_graph_input(&mut self, data: &GraphData) -> Result<Vec<Tensor<Fp>>, GraphError> {
         let shapes = self.model().graph.input_shapes()?;
         let scales = self.model().graph.get_input_scales();
         let input_types = self.model().graph.get_input_types()?;
-        self.process_data_source(&data.input_data, shapes, scales, input_types)
-    }
-
-    ///
-    pub fn load_graph_from_file_exclusively(
-        &mut self,
-        data: &GraphData,
-    ) -> Result<Vec<Tensor<Fp>>, GraphError> {
-        let shapes = self.model().graph.input_shapes()?;
-        let scales = self.model().graph.get_input_scales();
-        let input_types = self.model().graph.get_input_types()?;
-        debug!("input scales: {:?}", scales);
-
-        match &data.input_data {
-            DataSource::File(file_data) => {
-                self.load_file_data(file_data, &shapes, scales, input_types)
-            }
-            _ => Err(GraphError::OnChainDataSource),
-        }
-    }
-
-    ///
-    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-    pub async fn load_graph_input(
-        &mut self,
-        data: &GraphData,
-    ) -> Result<Vec<Tensor<Fp>>, GraphError> {
-        let shapes = self.model().graph.input_shapes()?;
-        let scales = self.model().graph.get_input_scales();
-        let input_types = self.model().graph.get_input_types()?;
-        debug!("input scales: {:?}", scales);
-
-        self.process_data_source(&data.input_data, shapes, scales, input_types)
-            .await
-    }
-
-    #[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
-    /// Process the data source for the model
-    fn process_data_source(
-        &mut self,
-        data: &DataSource,
-        shapes: Vec<Vec<usize>>,
-        scales: Vec<crate::Scale>,
-        input_types: Vec<InputType>,
-    ) -> Result<Vec<Tensor<Fp>>, GraphError> {
-        match &data {
-            DataSource::File(file_data) => {
-                self.load_file_data(file_data, &shapes, scales, input_types)
-            }
-            DataSource::OnChain(_) => Err(GraphError::OnChainDataSource),
-        }
-    }
-
-    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-    /// Process the data source for the model
-    async fn process_data_source(
-        &mut self,
-        data: &DataSource,
-        shapes: Vec<Vec<usize>>,
-        scales: Vec<crate::Scale>,
-        input_types: Vec<InputType>,
-    ) -> Result<Vec<Tensor<Fp>>, GraphError> {
-        match &data {
-            DataSource::OnChain(source) => {
-                let mut per_item_scale = vec![];
-                for (i, shape) in shapes.iter().enumerate() {
-                    per_item_scale.extend(vec![scales[i]; shape.iter().product::<usize>()]);
-                }
-
-                self.load_on_chain_data(source.clone(), &shapes, per_item_scale)
-                    .await
-            }
-            DataSource::File(file_data) => {
-                self.load_file_data(file_data, &shapes, scales, input_types)
-            }
-            DataSource::DB(pg) => {
-                let data = pg.fetch_and_format_as_file().await?;
-                self.load_file_data(&data, &shapes, scales, input_types)
-            }
-        }
-    }
-
-    /// Prepare on chain test data
-    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-    pub async fn load_on_chain_data(
-        &mut self,
-        source: OnChainSource,
-        shapes: &Vec<Vec<usize>>,
-        scales: Vec<crate::Scale>,
-    ) -> Result<Vec<Tensor<Fp>>, GraphError> {
-        use crate::eth::{
-            evm_quantize_multi, evm_quantize_single, read_on_chain_inputs_multi,
-            read_on_chain_inputs_single, setup_eth_backend,
-        };
-        let (client, client_address) = setup_eth_backend(Some(&source.rpc), None).await?;
-        let quantized_evm_inputs = match source.calls {
-            input::Calls::Single(call) => {
-                let (inputs, decimals) =
-                    read_on_chain_inputs_single(client.clone(), client_address, call).await?;
-
-                evm_quantize_single(client, scales, &inputs, decimals).await?
-            }
-            input::Calls::Multiple(calls) => {
-                let inputs =
-                    read_on_chain_inputs_multi(client.clone(), client_address, &calls).await?;
-                evm_quantize_multi(client, scales, &inputs).await?
-            }
-        };
-        // on-chain data has already been quantized at this point. Just need to reshape it and push into tensor vector
-        let mut inputs: Vec<Tensor<Fp>> = vec![];
-        for (input, shape) in [quantized_evm_inputs].iter().zip(shapes) {
-            let mut t: Tensor<Fp> = input.iter().cloned().collect();
-            t.reshape(shape)?;
-            inputs.push(t);
-        }
-
-        Ok(inputs)
+        self.load_file_data(data.input_data.values(), &shapes, scales, input_types)
     }
 
     ///
@@ -1430,75 +1334,6 @@ impl GraphCircuit {
         let model = Model::from_run_args(&params.run_args, model_path)?;
         Self::new_from_settings(model, params.clone(), check_mode)
     }
-
-    ///
-    #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-    pub async fn populate_on_chain_test_data(
-        &mut self,
-        data: &mut GraphData,
-        test_on_chain_data: TestOnChainData,
-    ) -> Result<(), GraphError> {
-        // Set up local anvil instance for reading on-chain data
-
-        let input_scales = self.model().graph.get_input_scales();
-        let output_scales = self.model().graph.get_output_scales()?;
-        let input_shapes = self.model().graph.input_shapes()?;
-        let output_shapes = self.model().graph.output_shapes()?;
-
-        if matches!(
-            test_on_chain_data.data_sources.input,
-            TestDataSource::OnChain
-        ) {
-            // if not public then fail
-            if self.settings().run_args.input_visibility.is_private() {
-                return Err(GraphError::OnChainDataSource);
-            }
-
-            let input_data = match &data.input_data {
-                DataSource::File(input_data) => input_data,
-                _ => {
-                    return Err(GraphError::OnChainDataSource);
-                }
-            };
-            // Get the flatten length of input_data
-            // if the input source is a field then set scale to 0
-
-            let datam: (Vec<Tensor<Fp>>, OnChainSource) = OnChainSource::test_from_file_data(
-                input_data,
-                input_scales,
-                input_shapes,
-                test_on_chain_data.rpc.as_deref(),
-            )
-            .await?;
-            data.input_data = datam.1.into();
-        }
-        if matches!(
-            test_on_chain_data.data_sources.output,
-            TestDataSource::OnChain
-        ) {
-            // if not public then fail
-            if self.settings().run_args.output_visibility.is_private() {
-                return Err(GraphError::OnChainDataSource);
-            }
-
-            let output_data = match &data.output_data {
-                Some(DataSource::File(output_data)) => output_data,
-                Some(DataSource::OnChain(_)) => return Err(GraphError::OnChainDataSource),
-                _ => return Err(GraphError::MissingDataSource),
-            };
-            let datum: (Vec<Tensor<Fp>>, OnChainSource) = OnChainSource::test_from_file_data(
-                output_data,
-                output_scales,
-                output_shapes,
-                test_on_chain_data.rpc.as_deref(),
-            )
-            .await?;
-            data.output_data = Some(datum.1.into());
-        }
-        // Save the updated GraphData struct to the data_path
-        data.save(test_on_chain_data.data)?;
-        Ok(())
-    }
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]

src/graph/postgres.rs

@@ -1,493 +0,0 @@
-use log::{debug, error, info};
-use std::fmt::Debug;
-use std::net::IpAddr;
-#[cfg(all(not(not(feature = "ezkl")), unix))]
-use std::path::Path;
-use std::str::FromStr;
-use std::sync::Arc;
-use std::time::Duration;
-use std::{fmt, pin::Pin};
-use tokio::task::JoinHandle;
-#[doc(inline)]
-pub use tokio_postgres::config::{
-    ChannelBinding, Host, LoadBalanceHosts, SslMode, TargetSessionAttrs,
-};
-use tokio_postgres::tls::NoTlsStream;
-use tokio_postgres::NoTls;
-use tokio_postgres::{error::DbError, types::ToSql, Error, Row, Socket, ToStatement};
-
-/// Connection configuration.
-///
-/// Configuration can be parsed from libpq-style connection strings. These strings come in two formats:
-///
-///
-#[derive(Clone)]
-pub struct Config {
-    config: tokio_postgres::Config,
-    notice_callback: Arc<dyn Fn(DbError) + Send + Sync>,
-}
-
-impl fmt::Debug for Config {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt.debug_struct("Config")
-            .field("config", &self.config)
-            .finish()
-    }
-}
-
-impl Default for Config {
-    fn default() -> Config {
-        Config::new()
-    }
-}
-
-impl Config {
-    /// Creates a new configuration.
-    pub fn new() -> Config {
-        tokio_postgres::Config::new().into()
-    }
-
-    /// Sets the user to authenticate with.
-    ///
-    /// If the user is not set, then this defaults to the user executing this process.
-    pub fn user(&mut self, user: &str) -> &mut Config {
-        self.config.user(user);
-        self
-    }
-
-    /// Gets the user to authenticate with, if one has been configured with
-    /// the `user` method.
-    pub fn get_user(&self) -> Option<&str> {
-        self.config.get_user()
-    }
-
-    /// Sets the password to authenticate with.
-    pub fn password<T>(&mut self, password: T) -> &mut Config
-    where
-        T: AsRef<[u8]>,
-    {
-        self.config.password(password);
-        self
-    }
-
-    /// Gets the password to authenticate with, if one has been configured with
-    /// the `password` method.
-    pub fn get_password(&self) -> Option<&[u8]> {
-        self.config.get_password()
-    }
-
-    /// Sets the name of the database to connect to.
-    ///
-    /// Defaults to the user.
-    pub fn dbname(&mut self, dbname: &str) -> &mut Config {
-        self.config.dbname(dbname);
-        self
-    }
-
-    /// Gets the name of the database to connect to, if one has been configured
-    /// with the `dbname` method.
-    pub fn get_dbname(&self) -> Option<&str> {
-        self.config.get_dbname()
-    }
-
-    /// Sets command line options used to configure the server.
-    pub fn options(&mut self, options: &str) -> &mut Config {
-        self.config.options(options);
-        self
-    }
-
-    /// Gets the command line options used to configure the server, if the
-    /// options have been set with the `options` method.
-    pub fn get_options(&self) -> Option<&str> {
-        self.config.get_options()
-    }
-
-    /// Sets the value of the `application_name` runtime parameter.
-    pub fn application_name(&mut self, application_name: &str) -> &mut Config {
-        self.config.application_name(application_name);
-        self
-    }
-
-    /// Gets the value of the `application_name` runtime parameter, if it has
-    /// been set with the `application_name` method.
-    pub fn get_application_name(&self) -> Option<&str> {
-        self.config.get_application_name()
-    }
-
-    /// Sets the SSL configuration.
-    ///
-    /// Defaults to `prefer`.
-    pub fn ssl_mode(&mut self, ssl_mode: SslMode) -> &mut Config {
-        self.config.ssl_mode(ssl_mode);
-        self
-    }
-
-    /// Gets the SSL configuration.
-    pub fn get_ssl_mode(&self) -> SslMode {
-        self.config.get_ssl_mode()
-    }
-
-    /// Adds a host to the configuration.
-    ///
-    /// Multiple hosts can be specified by calling this method multiple times, and each will be tried in order. On Unix
-    /// systems, a host starting with a `/` is interpreted as a path to a directory containing Unix domain sockets.
-    /// There must be either no hosts, or the same number of hosts as hostaddrs.
-    pub fn host(&mut self, host: &str) -> &mut Config {
-        self.config.host(host);
-        self
-    }
-
-    /// Gets the hosts that have been added to the configuration with `host`.
-    pub fn get_hosts(&self) -> &[Host] {
-        self.config.get_hosts()
-    }
-
-    /// Gets the hostaddrs that have been added to the configuration with `hostaddr`.
-    pub fn get_hostaddrs(&self) -> &[IpAddr] {
-        self.config.get_hostaddrs()
-    }
-
-    /// Adds a Unix socket host to the configuration.
-    ///
-    /// Unlike `host`, this method allows non-UTF8 paths.
-    #[cfg(all(not(not(feature = "ezkl")), unix))]
-    pub fn host_path<T>(&mut self, host: T) -> &mut Config
-    where
-        T: AsRef<Path>,
-    {
-        self.config.host_path(host);
-        self
-    }
-
-    /// Adds a hostaddr to the configuration.
-    ///
-    /// Multiple hostaddrs can be specified by calling this method multiple times, and each will be tried in order.
-    /// There must be either no hostaddrs, or the same number of hostaddrs as hosts.
-    pub fn hostaddr(&mut self, hostaddr: IpAddr) -> &mut Config {
-        self.config.hostaddr(hostaddr);
-        self
-    }
-
-    /// Adds a port to the configuration.
-    ///
-    /// Multiple ports can be specified by calling this method multiple times. There must either be no ports, in which
-    /// case the default of 5432 is used, a single port, in which it is used for all hosts, or the same number of ports
-    /// as hosts.
-    pub fn port(&mut self, port: u16) -> &mut Config {
-        self.config.port(port);
-        self
-    }
-
-    /// Gets the ports that have been added to the configuration with `port`.
-    pub fn get_ports(&self) -> &[u16] {
-        self.config.get_ports()
-    }
-
-    /// Sets the timeout applied to socket-level connection attempts.
-    ///
-    /// Note that hostnames can resolve to multiple IP addresses, and this timeout will apply to each address of each
-    /// host separately. Defaults to no limit.
-    pub fn connect_timeout(&mut self, connect_timeout: Duration) -> &mut Config {
-        self.config.connect_timeout(connect_timeout);
-        self
-    }
-
-    /// Gets the connection timeout, if one has been set with the
-    /// `connect_timeout` method.
-    pub fn get_connect_timeout(&self) -> Option<&Duration> {
-        self.config.get_connect_timeout()
-    }
-
-    /// Sets the TCP user timeout.
-    ///
-    /// This is ignored for Unix domain socket connections. It is only supported on systems where
-    /// TCP_USER_TIMEOUT is available and will default to the system default if omitted or set to 0;
-    /// on other systems, it has no effect.
-    pub fn tcp_user_timeout(&mut self, tcp_user_timeout: Duration) -> &mut Config {
-        self.config.tcp_user_timeout(tcp_user_timeout);
-        self
-    }
-
-    /// Gets the TCP user timeout, if one has been set with the
-    /// `user_timeout` method.
-    pub fn get_tcp_user_timeout(&self) -> Option<&Duration> {
-        self.config.get_tcp_user_timeout()
-    }
-
-    /// Controls the use of TCP keepalive.
-    ///
-    /// This is ignored for Unix domain socket connections. Defaults to `true`.
-    pub fn keepalives(&mut self, keepalives: bool) -> &mut Config {
-        self.config.keepalives(keepalives);
-        self
-    }
-
-    /// Reports whether TCP keepalives will be used.
-    pub fn get_keepalives(&self) -> bool {
-        self.config.get_keepalives()
-    }
-
-    /// Sets the amount of idle time before a keepalive packet is sent on the connection.
-    ///
-    /// This is ignored for Unix domain sockets, or if the `keepalives` option is disabled. Defaults to 2 hours.
-    pub fn keepalives_idle(&mut self, keepalives_idle: Duration) -> &mut Config {
-        self.config.keepalives_idle(keepalives_idle);
-        self
-    }
-
-    /// Gets the configured amount of idle time before a keepalive packet will
-    /// be sent on the connection.
-    pub fn get_keepalives_idle(&self) -> Duration {
-        self.config.get_keepalives_idle()
-    }
-
-    /// Sets the time interval between TCP keepalive probes.
-    /// On Windows, this sets the value of the tcp_keepalive struct’s keepaliveinterval field.
-    ///
-    /// This is ignored for Unix domain sockets, or if the `keepalives` option is disabled.
-    pub fn keepalives_interval(&mut self, keepalives_interval: Duration) -> &mut Config {
-        self.config.keepalives_interval(keepalives_interval);
-        self
-    }
-
-    /// Gets the time interval between TCP keepalive probes.
-    pub fn get_keepalives_interval(&self) -> Option<Duration> {
-        self.config.get_keepalives_interval()
-    }
-
-    /// Sets the maximum number of TCP keepalive probes that will be sent before dropping a connection.
-    ///
-    /// This is ignored for Unix domain sockets, or if the `keepalives` option is disabled.
-    pub fn keepalives_retries(&mut self, keepalives_retries: u32) -> &mut Config {
-        self.config.keepalives_retries(keepalives_retries);
-        self
-    }
-
-    /// Gets the maximum number of TCP keepalive probes that will be sent before dropping a connection.
-    pub fn get_keepalives_retries(&self) -> Option<u32> {
-        self.config.get_keepalives_retries()
-    }
-
-    /// Sets the requirements of the session.
-    ///
-    /// This can be used to connect to the primary server in a clustered database rather than one of the read-only
-    /// secondary servers. Defaults to `Any`.
-    pub fn target_session_attrs(
-        &mut self,
-        target_session_attrs: TargetSessionAttrs,
-    ) -> &mut Config {
-        self.config.target_session_attrs(target_session_attrs);
-        self
-    }
-
-    /// Gets the requirements of the session.
-    pub fn get_target_session_attrs(&self) -> TargetSessionAttrs {
-        self.config.get_target_session_attrs()
-    }
-
-    /// Sets the channel binding behavior.
-    ///
-    /// Defaults to `prefer`.
-    pub fn channel_binding(&mut self, channel_binding: ChannelBinding) -> &mut Config {
-        self.config.channel_binding(channel_binding);
-        self
-    }
-
-    /// Gets the channel binding behavior.
-    pub fn get_channel_binding(&self) -> ChannelBinding {
-        self.config.get_channel_binding()
-    }
-
-    /// Sets the host load balancing behavior.
-    ///
-    /// Defaults to `disable`.
-    pub fn load_balance_hosts(&mut self, load_balance_hosts: LoadBalanceHosts) -> &mut Config {
-        self.config.load_balance_hosts(load_balance_hosts);
-        self
-    }
-
-    /// Gets the host load balancing behavior.
-    pub fn get_load_balance_hosts(&self) -> LoadBalanceHosts {
-        self.config.get_load_balance_hosts()
-    }
-
-    /// Sets the notice callback.
-    ///
-    /// This callback will be invoked with the contents of every
-    /// [`AsyncMessage::Notice`] that is received by the connection. Notices use
-    /// the same structure as errors, but they are not "errors" per-se.
-    ///
-    /// Notices are distinct from notifications, which are instead accessible
-    /// via the [`Notifications`] API.
-    ///
-    /// [`AsyncMessage::Notice`]: tokio_postgres::AsyncMessage::Notice
-    /// [`Notifications`]: crate::Notifications
-    pub fn notice_callback<F>(&mut self, f: F) -> &mut Config
-    where
-        F: Fn(DbError) + Send + Sync + 'static,
-    {
-        self.notice_callback = Arc::new(f);
-        self
-    }
-
-    /// Opens a connection to a PostgreSQL database.
-    pub async fn connect(&self) -> Result<Client, Error> {
-        let (client, connection) = self.config.connect(NoTls).await?;
-
-        let connection = Connection::new(connection);
-
-        Ok(Client::new(client, connection))
-    }
-}
-
-impl FromStr for Config {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Config, Error> {
-        s.parse::<tokio_postgres::Config>().map(Config::from)
-    }
-}
-
-impl From<tokio_postgres::Config> for Config {
-    fn from(config: tokio_postgres::Config) -> Config {
-        Config {
-            config,
-            notice_callback: Arc::new(|notice| {
-                info!("{}: {}", notice.severity(), notice.message())
-            }),
-        }
-    }
-}
-
-#[allow(missing_debug_implementations, dead_code)]
-/// An asynchronous PostgreSQL connection. We use this to keep the connection alive / keep it pinned so that it doesn't
-/// get dropped.
-pub struct Connection {
-    /// The underlying connection stream.
-    connection: Pin<Box<tokio_postgres::Connection<Socket, NoTlsStream>>>,
-}
-
-impl Connection {
-    /// Creates a new connection.
-    pub fn new(connection: tokio_postgres::Connection<Socket, NoTlsStream>) -> Self {
-        Connection {
-            connection: Box::pin(connection),
-        }
-    }
-
-    /// start the connection
-    pub async fn start(self) {
-        if let Err(e) = self.connection.await {
-            error!("connection error: {}", e);
-        }
-    }
-}
-
-#[allow(missing_debug_implementations, dead_code)]
-/// An asynchronous PostgreSQL client.
-pub struct Client {
-    connection: JoinHandle<()>,
-    client: tokio_postgres::Client,
-}
-
-impl Drop for Client {
-    fn drop(&mut self) {
-        let _ = self.close_inner();
-    }
-}
-
-impl Client {
-    pub(crate) fn new(client: tokio_postgres::Client, connection: Connection) -> Client {
-        // The connection object performs the actual communication with the database,
-        // so spawn it off to run on its own.
-        let thread = tokio::spawn(async move {
-            connection.start().await;
-        });
-
-        Client {
-            client,
-            connection: thread,
-        }
-    }
-
-    /// A convenience function which parses a configuration string into a `Config` and then connects to the database.
-    ///
-    /// See the documentation for [`Config`] for information about the connection syntax.
-    ///
-    /// [`Config`]: config/struct.Config.html
-    pub async fn connect(params: &str) -> Result<Client, Error> {
-        debug!("Connecting to database with params: {}", params);
-        params.parse::<Config>()?.connect().await
-    }
-
-    /// Returns a new `Config` object which can be used to configure and connect to a database.
-    pub fn configure() -> Config {
-        Config::new()
-    }
-
-    /// Executes a statement, returning the number of rows modified.
-    ///
-    /// A statement may contain parameters, specified by `$n`, where `n` is the index of the parameter of the list
-    /// provided, 1-indexed.
-    ///
-    /// If the statement does not modify any rows (e.g. `SELECT`), 0 is returned.
-    ///
-    /// The `query` argument can either be a `Statement`, or a raw query string. If the same statement will be
-    /// repeatedly executed (perhaps with different query parameters), consider preparing the statement up front
-    /// with the `prepare` method.
-    ///
-    pub async fn execute<T>(
-        &mut self,
-        query: &T,
-        params: &[&(dyn ToSql + Sync)],
-    ) -> Result<u64, Error>
-    where
-        T: ?Sized + ToStatement + Debug,
-    {
-        debug!("Executing query: {:?}", query);
-        self.client.execute(query, params).await
-    }
-
-    /// Executes a statement, returning the resulting rows.
-    ///
-    /// A statement may contain parameters, specified by `$n`, where `n` is the index of the parameter of the list
-    /// provided, 1-indexed.
-    ///
-    /// The `query` argument can either be a `Statement`, or a raw query string. If the same statement will be
-    /// repeatedly executed (perhaps with different query parameters), consider preparing the statement up front
-    /// with the `prepare` method.
-    ///
-    /// # Examples
-    ///
-    pub async fn query<T>(
-        &mut self,
-        query: &T,
-        params: &[&(dyn ToSql + Sync)],
-    ) -> Result<Vec<Row>, Error>
-    where
-        T: ?Sized + ToStatement + Debug,
-    {
-        debug!("Executing query: {:?}", query);
-        self.client.query(query, params).await
-    }
-
-    /// Determines if the client's connection has already closed.
-    ///
-    /// If this returns `true`, the client is no longer usable.
-    pub fn is_closed(&self) -> bool {
-        self.client.is_closed()
-    }
-
-    /// Closes the client's connection to the server.
-    ///
-    /// This is equivalent to `Client`'s `Drop` implementation, except that it returns any error encountered to the
-    /// caller.
-    pub fn close(mut self) -> Result<(), Error> {
-        self.close_inner()
-    }
-
-    fn close_inner(&mut self) -> Result<(), Error> {
-        self.client.__private_api_close();
-        Ok(())
-    }
-}

src/graph/utilities.rs

@@ -1,14 +1,14 @@
-use super::errors::GraphError;
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use super::VarScales;
+use super::errors::GraphError;
 use super::{Rescaled, SupportedOp, Visibility};
+use crate::circuit::Op;
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::circuit::hybrid::HybridOp;
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::circuit::lookup::LookupOp;
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use crate::circuit::poly::PolyOp;
-use crate::circuit::Op;
 use crate::fieldutils::IntegerRep;
 use crate::tensor::{Tensor, TensorError, TensorType};
 use halo2curves::bn256::Fr as Fp;
@@ -22,6 +22,7 @@ use std::sync::Arc;
 use tract_onnx::prelude::{DatumType, Node as OnnxNode, TypedFact, TypedOp};
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::tract_core::ops::{
+    Downsample,
     array::{
         Gather, GatherElements, GatherNd, MultiBroadcastTo, OneHot, ScatterElements, ScatterNd,
         Slice, Topk,
@@ -31,7 +32,6 @@ use tract_onnx::tract_core::ops::{
     einsum::EinSum,
     element_wise::ElementWiseOp,
     nn::{LeakyRelu, Reduce, Softmax},
-    Downsample,
 };
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use tract_onnx::tract_hir::{
@@ -858,6 +858,7 @@ pub fn new_op_from_onnx(
             SupportedOp::Hybrid(HybridOp::Recip {
                 input_scale: (scale_to_multiplier(in_scale) as f32).into(),
                 output_scale: (scale_to_multiplier(max_scale) as f32).into(),
+                eps: run_args.get_epsilon(),
             })
         }
 
@@ -903,6 +904,7 @@ pub fn new_op_from_onnx(
             SupportedOp::Hybrid(HybridOp::Rsqrt {
                 input_scale: (scale_to_multiplier(in_scale) as f32).into(),
                 output_scale: (scale_to_multiplier(max_scale) as f32).into(),
+                eps: run_args.get_epsilon(),
             })
         }
         "Exp" => SupportedOp::Nonlinear(LookupOp::Exp {
@@ -913,6 +915,7 @@ pub fn new_op_from_onnx(
             if run_args.bounded_log_lookup {
                 SupportedOp::Hybrid(HybridOp::Ln {
                     scale: scale_to_multiplier(input_scales[0]).into(),
+                    eps: run_args.get_epsilon(),
                 })
             } else {
                 SupportedOp::Nonlinear(LookupOp::Ln {
@@ -1131,6 +1134,7 @@ pub fn new_op_from_onnx(
                 input_scale: scale_to_multiplier(in_scale).into(),
                 output_scale: scale_to_multiplier(max_scale).into(),
                 axes: softmax_op.axes.to_vec(),
+                eps: run_args.get_epsilon(),
             })
         }
         "MaxPool" => {
@@ -1398,7 +1402,7 @@ pub fn new_op_from_onnx(
 
             SupportedOp::Linear(PolyOp::Downsample {
                 axis: downsample_node.axis,
-                stride: downsample_node.stride as usize,
+                stride: downsample_node.stride,
                 modulo: downsample_node.modulo,
             })
         }

src/lib.rs

@@ -44,6 +44,7 @@ pub enum EZKLError {
         not(all(target_arch = "wasm32", target_os = "unknown"))
     ))]
     #[error("[eth] {0}")]
+    #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
     EthError(#[from] eth::EthError),
     #[error("[graph] {0}")]
     GraphError(#[from] graph::errors::GraphError),
@@ -134,7 +135,7 @@ pub mod circuit;
 /// CLI commands.
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 pub mod commands;
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
+#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 // abigen doesn't generate docs for this module
 #[allow(missing_docs)]
 /// Utility functions for contracts
@@ -350,6 +351,16 @@ pub struct RunArgs {
         arg(long, default_value = "false")
     )]
     pub ignore_range_check_inputs_outputs: bool,
+    /// Optional override for epsilon value
+    #[cfg_attr(all(feature = "ezkl", not(target_arch = "wasm32")), arg(long))]
+    pub epsilon: Option<f64>,
+}
+
+impl RunArgs {
+    /// Returns the epsilon value
+    pub fn get_epsilon(&self) -> f64 {
+        self.epsilon.unwrap_or(f64::EPSILON)
+    }
 }
 
 impl Default for RunArgs {
@@ -376,6 +387,7 @@ impl Default for RunArgs {
             decomp_base: 16384,
             decomp_legs: 2,
             ignore_range_check_inputs_outputs: false,
+            epsilon: None,
         }
     }
 }

src/pfsys/mod.rs

@@ -17,16 +17,16 @@ use crate::{Commitments, EZKL_BUF_CAPACITY, EZKL_KEY_FORMAT};
 use clap::ValueEnum;
 use halo2_proofs::circuit::Value;
 use halo2_proofs::plonk::{
-    create_proof, keygen_pk, keygen_vk_custom, verify_proof, Circuit, ProvingKey, VerifyingKey,
+    Circuit, ProvingKey, VerifyingKey, create_proof, keygen_pk, keygen_vk_custom, verify_proof,
 };
+use halo2_proofs::poly::VerificationStrategy;
 use halo2_proofs::poly::commitment::{CommitmentScheme, Params, ParamsProver, Prover, Verifier};
 use halo2_proofs::poly::ipa::commitment::IPACommitmentScheme;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-use halo2_proofs::poly::VerificationStrategy;
 use halo2_proofs::transcript::{EncodedChallenge, TranscriptReadBuffer, TranscriptWriterBuffer};
+use halo2curves::CurveAffine;
 use halo2curves::ff::{FromUniformBytes, PrimeField, WithSmallOrderMulGroup};
 use halo2curves::serde::SerdeObject;
-use halo2curves::CurveAffine;
 use instant::Instant;
 use log::{debug, info, trace};
 #[cfg(not(feature = "det-prove"))]
@@ -51,6 +51,9 @@ use pyo3::types::PyDictMethods;
 
 use halo2curves::bn256::{Bn256, Fr, G1Affine};
 
+/// Converts a string to a `SerdeFormat`.
+/// # Panics
+/// Panics if the provided `s` is not a valid `SerdeFormat` (i.e. not one of "processed", "raw-bytes-unchecked", or "raw-bytes").
 fn serde_format_from_str(s: &str) -> halo2_proofs::SerdeFormat {
     match s {
         "processed" => halo2_proofs::SerdeFormat::Processed,
@@ -321,7 +324,7 @@ where
 }
 
 #[cfg(feature = "python-bindings")]
-use pyo3::{types::PyDict, PyObject, Python, ToPyObject};
+use pyo3::{PyObject, Python, ToPyObject, types::PyDict};
 #[cfg(feature = "python-bindings")]
 impl<F: PrimeField + SerdeObject + Serialize, C: CurveAffine + Serialize> ToPyObject for Snark<F, C>
 where
@@ -345,9 +348,9 @@ where
 }
 
 impl<
-        F: PrimeField + SerdeObject + Serialize + FromUniformBytes<64> + DeserializeOwned,
-        C: CurveAffine + Serialize + DeserializeOwned,
-    > Snark<F, C>
+    F: PrimeField + SerdeObject + Serialize + FromUniformBytes<64> + DeserializeOwned,
+    C: CurveAffine + Serialize + DeserializeOwned,
+> Snark<F, C>
 where
     C::Scalar: Serialize + DeserializeOwned,
     C::ScalarExt: Serialize + DeserializeOwned,

src/tensor/mod.rs

@@ -27,7 +27,7 @@ pub use var::*;
 
 use crate::{
     circuit::utils,
-    fieldutils::{integer_rep_to_felt, IntegerRep},
+    fieldutils::{IntegerRep, integer_rep_to_felt},
     graph::Visibility,
 };
 
@@ -415,7 +415,7 @@ impl<T: Clone + TensorType + PrimeField> Tensor<T> {
                 Err(_) => {
                     return Err(TensorError::FileLoadError(
                         "Failed to read tensor".to_string(),
-                    ))
+                    ));
                 }
             }
         }
@@ -926,6 +926,9 @@ impl<T: Clone + TensorType> Tensor<T> {
                 ));
             }
             self.dims = vec![];
+        }
+        if self.dims() == &[0] && new_dims.iter().product::<usize>() == 1 {
+            self.dims = Vec::from(new_dims);
         } else {
             let product = if new_dims != [0] {
                 new_dims.iter().product::<usize>()
@@ -1104,6 +1107,10 @@ impl<T: Clone + TensorType> Tensor<T> {
             let mut output = self.clone();
             output.reshape(shape)?;
             return Ok(output);
+        } else if self.dims() == &[0] && shape.iter().product::<usize>() == 1 {
+            let mut output = self.clone();
+            output.reshape(shape)?;
+            return Ok(output);
         }
 
         if self.dims().len() > shape.len() {
@@ -1254,7 +1261,7 @@ impl<T: Clone + TensorType> Tensor<T> {
             None => {
                 return Err(TensorError::DimError(
                     "Cannot get last element of empty tensor".to_string(),
-                ))
+                ));
             }
         };
 
@@ -1279,7 +1286,7 @@ impl<T: Clone + TensorType> Tensor<T> {
             None => {
                 return Err(TensorError::DimError(
                     "Cannot get first element of empty tensor".to_string(),
-                ))
+                ));
             }
         };
 
@@ -1692,8 +1699,8 @@ impl<T: TensorType + Rem<Output = T> + std::marker::Send + std::marker::Sync + P
 
         lhs.par_iter_mut()
             .zip(rhs)
-            .map(|(o, r)| {
-                match T::zero() { Some(zero) => {
+            .map(|(o, r)| match T::zero() {
+                Some(zero) => {
                     if r != zero {
                         *o = o.clone() % r;
                         Ok(())
@@ -1702,11 +1709,10 @@ impl<T: TensorType + Rem<Output = T> + std::marker::Send + std::marker::Sync + P
                             "Cannot divide by zero in remainder".to_string(),
                         ))
                     }
-                } _ => {
-                    Err(TensorError::InvalidArgument(
-                        "Undefined zero value".to_string(),
-                    ))
-                }}
+                }
+                _ => Err(TensorError::InvalidArgument(
+                    "Undefined zero value".to_string(),
+                )),
             })
             .collect::<Result<Vec<_>, _>>()?;
 

src/tensor/ops.rs

@@ -160,7 +160,7 @@ pub fn decompose(
 ///
 /// let result = trilu(&a, 0, false).unwrap();
 /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 0, 3, 4, 5, 6]), &[1, 3, 2]).unwrap();
-/// assert_eq!(result, expected);  
+/// assert_eq!(result, expected);
 ///
 /// let result = trilu(&a, -1, true).unwrap();
 /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 0, 6]), &[1, 3, 2]).unwrap();
@@ -168,7 +168,7 @@ pub fn decompose(
 ///
 /// let result = trilu(&a, -1, false).unwrap();
 /// let expected = Tensor::<IntegerRep>::new(Some(&[0, 0, 3, 0, 5, 6]), &[1, 3, 2]).unwrap();
-/// assert_eq!(result, expected);  
+/// assert_eq!(result, expected);
 ///
 /// let a = Tensor::<IntegerRep>::new(
 ///   Some(&[1, 2, 3, 4, 5, 6]),
@@ -188,7 +188,7 @@ pub fn decompose(
 ///
 /// let result = trilu(&a, 0, false).unwrap();
 /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 0, 0, 4, 5, 0]), &[1, 2, 3]).unwrap();
-/// assert_eq!(result, expected);  
+/// assert_eq!(result, expected);
 ///
 /// let result = trilu(&a, -1, true).unwrap();
 /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6]), &[1, 2, 3]).unwrap();
@@ -196,7 +196,7 @@ pub fn decompose(
 ///
 /// let result = trilu(&a, -1, false).unwrap();
 /// let expected = Tensor::<IntegerRep>::new(Some(&[0, 0, 0, 4, 0, 0]), &[1, 2, 3]).unwrap();
-/// assert_eq!(result, expected);  
+/// assert_eq!(result, expected);
 ///
 /// let a = Tensor::<IntegerRep>::new(
 ///   Some(&[1, 2, 3, 4, 5, 6, 7, 8, 9]),
@@ -216,7 +216,7 @@ pub fn decompose(
 ///
 /// let result = trilu(&a, 0, false).unwrap();
 /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 0, 0, 4, 5, 0, 7, 8, 9]), &[1, 3, 3]).unwrap();
-/// assert_eq!(result, expected);  
+/// assert_eq!(result, expected);
 ///
 /// let result = trilu(&a, -1, true).unwrap();
 /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6, 0, 8, 9]), &[1, 3, 3]).unwrap();
@@ -224,7 +224,7 @@ pub fn decompose(
 ///
 /// let result = trilu(&a, -1, false).unwrap();
 /// let expected = Tensor::<IntegerRep>::new(Some(&[0, 0, 0, 4, 0, 0, 7, 8, 0]), &[1, 3, 3]).unwrap();
-/// assert_eq!(result, expected);  
+/// assert_eq!(result, expected);
 /// ```
 pub fn trilu<T: TensorType + std::marker::Send + std::marker::Sync>(
     a: &Tensor<T>,
@@ -535,30 +535,101 @@ pub fn mult<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::S
 /// let result = downsample(&x, 1, 2, 2).unwrap();
 /// let expected = Tensor::<IntegerRep>::new(Some(&[3, 6]), &[2, 1]).unwrap();
 /// assert_eq!(result, expected);
+/// let x = Tensor::<IntegerRep>::new(
+///     Some(&[1, 2, 3, 4, 5, 6]),
+///     &[2, 3],
+/// ).unwrap();
+///
+/// // Test case 1: Negative stride along dimension 0
+/// // This should flip the order along dimension 0
+/// let result = downsample(&x, 0, -1, 0).unwrap();
+/// let expected = Tensor::<IntegerRep>::new(
+///     Some(&[4, 5, 6, 1, 2, 3]), // Flipped order of rows
+///     &[2, 3]
+/// ).unwrap();
+/// assert_eq!(result, expected);
+///
+/// // Test case 2: Negative stride along dimension 1
+/// // This should flip the order along dimension 1
+/// let result = downsample(&x, 1, -1, 0).unwrap();
+/// let expected = Tensor::<IntegerRep>::new(
+///     Some(&[3, 2, 1, 6, 5, 4]), // Flipped order of columns
+///     &[2, 3]
+/// ).unwrap();
+/// assert_eq!(result, expected);
+///
+/// // Test case 3: Negative stride with stride magnitude > 1
+/// // This should both skip and flip
+/// let result = downsample(&x, 1, -2, 0).unwrap();
+/// let expected = Tensor::<IntegerRep>::new(
+///     Some(&[3, 1, 6, 4]), // Take every 2nd element in reverse
+///     &[2, 2]
+/// ).unwrap();
+/// assert_eq!(result, expected);
+///
+/// // Test case 4: Negative stride with non-zero modulo
+/// // This should start at (size - 1 - modulo) and reverse
+/// let result = downsample(&x, 1, -2, 1).unwrap();
+/// let expected = Tensor::<IntegerRep>::new(
+///     Some(&[2, 5]), // Start at second element from end, take every 2nd in reverse
+///     &[2, 1]
+/// ).unwrap();
+/// assert_eq!(result, expected);
+///
+/// // Create a larger test case for more complex downsampling
+/// let y = Tensor::<IntegerRep>::new(
+///     Some(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]),
+///     &[3, 4],
+/// ).unwrap();
+///
+/// // Test case 5: Negative stride with modulo on larger tensor
+/// let result = downsample(&y, 1, -2, 1).unwrap();
+/// let expected = Tensor::<IntegerRep>::new(
+///     Some(&[3, 1, 7, 5, 11, 9]), // Start at one after reverse, take every 2nd
+///     &[3, 2]
+/// ).unwrap();
+/// assert_eq!(result, expected);
+/// ```
 pub fn downsample<T: TensorType + Send + Sync>(
     input: &Tensor<T>,
     dim: usize,
-    stride: usize,
+    stride: isize, // Changed from usize to isize to support negative strides
     modulo: usize,
 ) -> Result<Tensor<T>, TensorError> {
-    let mut output_shape = input.dims().to_vec();
-    // now downsample along axis dim offset by modulo, rounding up (+1 if remaidner is non-zero)
-    let remainder = (input.dims()[dim] - modulo) % stride;
-    let div = (input.dims()[dim] - modulo) / stride;
-    output_shape[dim] = div + (remainder > 0) as usize;
-    let mut output = Tensor::<T>::new(None, &output_shape)?;
+    // Handle negative stride case
+    if stride == 0 {
+        return Err(TensorError::DimMismatch(
+            "downsample stride cannot be zero".to_string(),
+        ));
+    }
 
-    if modulo > input.dims()[dim] {
+    let stride_abs = stride.unsigned_abs();
+    let mut output_shape = input.dims().to_vec();
+
+    if modulo >= input.dims()[dim] {
         return Err(TensorError::DimMismatch("downsample".to_string()));
     }
 
-    // now downsample along axis dim offset by modulo
+    // Calculate output shape based on the absolute value of stride
+    let remainder = (input.dims()[dim] - modulo) % stride_abs;
+    let div = (input.dims()[dim] - modulo) / stride_abs;
+    output_shape[dim] = div + (remainder > 0) as usize;
+
+    let mut output = Tensor::<T>::new(None, &output_shape)?;
+
+    // Calculate indices based on stride direction
     let indices = (0..output_shape.len())
         .map(|i| {
             if i == dim {
                 let mut index = vec![0; output_shape[i]];
-                for (i, idx) in index.iter_mut().enumerate() {
-                    *idx = i * stride + modulo;
+                for (j, idx) in index.iter_mut().enumerate() {
+                    if stride > 0 {
+                        // Positive stride: move forward from modulo
+                        *idx = j * stride_abs + modulo;
+                    } else {
+                        // Negative stride: move backward from (size - 1 - modulo)
+                        *idx = (input.dims()[dim] - 1 - modulo) - j * stride_abs;
+                    }
                 }
                 index
             } else {
@@ -1788,14 +1859,14 @@ pub mod nonlinearities {
     ///     Some(&[4, 25, 8, 1, 1, 1]),
     ///     &[2, 3],
     /// ).unwrap();
-    /// let result = rsqrt(&x, 1.0);
+    /// let result = rsqrt(&x, 1.0, f64::EPSILON);
     /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 0, 0, 1, 1, 1]), &[2, 3]).unwrap();
     /// assert_eq!(result, expected);
     /// ```
-    pub fn rsqrt(a: &Tensor<IntegerRep>, scale_input: f64) -> Tensor<IntegerRep> {
+    pub fn rsqrt(a: &Tensor<IntegerRep>, scale_input: f64, eps: f64) -> Tensor<IntegerRep> {
         a.par_enum_map(|_, a_i| {
             let kix = (a_i as f64) / scale_input;
-            let fout = scale_input / (kix.sqrt() + f64::EPSILON);
+            let fout = scale_input / (kix.sqrt() + eps);
             let rounded = fout.round();
             Ok::<_, TensorError>(rounded as IntegerRep)
         })
@@ -2268,14 +2339,23 @@ pub mod nonlinearities {
     ///     &[2, 3],
     /// ).unwrap();
     /// let k = 2_f64;
-    /// let result = recip(&x, 1.0, k);
+    /// let result = recip(&x, 1.0, k, f64::EPSILON);
     /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 2, 1, 0, 2, 2]), &[2, 3]).unwrap();
     /// assert_eq!(result, expected);
     /// ```
-    pub fn recip(a: &Tensor<IntegerRep>, input_scale: f64, out_scale: f64) -> Tensor<IntegerRep> {
+    pub fn recip(
+        a: &Tensor<IntegerRep>,
+        input_scale: f64,
+        out_scale: f64,
+        eps: f64,
+    ) -> Tensor<IntegerRep> {
         a.par_enum_map(|_, a_i| {
             let rescaled = (a_i as f64) / input_scale;
-            let denom = (1_f64) / (rescaled + f64::EPSILON);
+            let denom = if rescaled == 0_f64 {
+                (1_f64) / (rescaled + eps)
+            } else {
+                (1_f64) / (rescaled)
+            };
             let d_inv_x = out_scale * denom;
             Ok::<_, TensorError>(d_inv_x.round() as IntegerRep)
         })
@@ -2291,16 +2371,16 @@ pub mod nonlinearities {
     /// use ezkl::fieldutils::IntegerRep;
     /// use ezkl::tensor::ops::nonlinearities::zero_recip;
     /// let k = 2_f64;
-    /// let result = zero_recip(1.0);
+    /// let result = zero_recip(1.0, f64::EPSILON);
     /// let expected = Tensor::<IntegerRep>::new(Some(&[4503599627370496]), &[1]).unwrap();
     /// assert_eq!(result, expected);
     /// ```
-    pub fn zero_recip(out_scale: f64) -> Tensor<IntegerRep> {
+    pub fn zero_recip(out_scale: f64, eps: f64) -> Tensor<IntegerRep> {
         let a = Tensor::<IntegerRep>::new(Some(&[0]), &[1]).unwrap();
 
         a.par_enum_map(|_, a_i| {
             let rescaled = a_i as f64;
-            let denom = (1_f64) / (rescaled + f64::EPSILON);
+            let denom = (1_f64) / (rescaled + eps);
             let d_inv_x = out_scale * denom;
             Ok::<_, TensorError>(d_inv_x.round() as IntegerRep)
         })

src/tensor/var.rs

@@ -2,7 +2,7 @@ use std::collections::HashSet;
 
 use log::{debug, error, warn};
 
-use crate::circuit::{region::ConstantsMap, CheckMode};
+use crate::circuit::{CheckMode, region::ConstantsMap};
 
 use super::*;
 /// A wrapper around Halo2's Column types that represents a tensor of variables in the circuit.
@@ -403,7 +403,10 @@ impl VarTensor {
         let mut assigned_coord = 0;
         let mut res: ValTensor<F> = match values {
             ValTensor::Instance { .. } => {
-                unimplemented!("cannot assign instance to advice columns with omissions")
+                error!(
+                    "assignment with omissions is not supported on instance columns. increase K if you require more rows."
+                );
+                Err(halo2_proofs::plonk::Error::Synthesis)
             }
             ValTensor::Value { inner: v, .. } => Ok::<ValTensor<F>, halo2_proofs::plonk::Error>(
                 v.enum_map(|coord, k| {
@@ -569,8 +572,13 @@ impl VarTensor {
         constants: &mut ConstantsMap<F>,
     ) -> Result<(ValTensor<F>, usize), halo2_proofs::plonk::Error> {
         match values {
-            ValTensor::Instance { .. } => unimplemented!("duplication is not supported on instance columns. increase K if you require more rows."),
-            ValTensor::Value { inner: v, dims , ..} => {
+            ValTensor::Instance { .. } => {
+                error!(
+                    "duplication is not supported on instance columns. increase K if you require more rows."
+                );
+                Err(halo2_proofs::plonk::Error::Synthesis)
+            }
+            ValTensor::Value { inner: v, dims, .. } => {
                 let duplication_freq = if single_inner_col {
                     self.col_size()
                 } else {
@@ -583,21 +591,20 @@ impl VarTensor {
                     self.num_inner_cols()
                 };
 
-                let duplication_offset = if single_inner_col {
-                    row
-                } else {
-                    offset
-                };
-
+                let duplication_offset = if single_inner_col { row } else { offset };
 
                 // duplicates every nth element to adjust for column overflow
-                let mut res: ValTensor<F> = v.duplicate_every_n(duplication_freq, num_repeats, duplication_offset).unwrap().into();
+                let mut res: ValTensor<F> = v
+                    .duplicate_every_n(duplication_freq, num_repeats, duplication_offset)
+                    .unwrap()
+                    .into();
 
                 let constants_map = res.create_constants_map();
                 constants.extend(constants_map);
 
                 let total_used_len = res.len();
-                res.remove_every_n(duplication_freq, num_repeats, duplication_offset).unwrap();
+                res.remove_every_n(duplication_freq, num_repeats, duplication_offset)
+                    .unwrap();
 
                 res.reshape(dims).unwrap();
                 res.set_scale(values.scale());
@@ -627,9 +634,13 @@ impl VarTensor {
         constants: &mut ConstantsMap<F>,
     ) -> Result<(ValTensor<F>, usize), halo2_proofs::plonk::Error> {
         match values {
-            ValTensor::Instance { .. } => unimplemented!("duplication is not supported on instance columns. increase K if you require more rows."),
-            ValTensor::Value { inner: v, dims , ..} => {
-
+            ValTensor::Instance { .. } => {
+                error!(
+                    "duplication is not supported on instance columns. increase K if you require more rows."
+                );
+                Err(halo2_proofs::plonk::Error::Synthesis)
+            }
+            ValTensor::Value { inner: v, dims, .. } => {
                 let duplication_freq = self.block_size();
 
                 let num_repeats = self.num_inner_cols();
@@ -637,17 +648,31 @@ impl VarTensor {
                 let duplication_offset = offset;
 
                 // duplicates every nth element to adjust for column overflow
-                let v = v.duplicate_every_n(duplication_freq, num_repeats, duplication_offset).unwrap();
+                let v = v
+                    .duplicate_every_n(duplication_freq, num_repeats, duplication_offset)
+                    .map_err(|e| {
+                        error!("Error duplicating values: {:?}", e);
+                        halo2_proofs::plonk::Error::Synthesis
+                    })?;
                 let mut res: ValTensor<F> = {
                     v.enum_map(|coord, k| {
-                    let cell = self.assign_value(region, offset, k.clone(), coord, constants)?;
-                    Ok::<_, halo2_proofs::plonk::Error>(cell)
-
-                })?.into()};
+                        let cell =
+                            self.assign_value(region, offset, k.clone(), coord, constants)?;
+                        Ok::<_, halo2_proofs::plonk::Error>(cell)
+                    })?
+                    .into()
+                };
                 let total_used_len = res.len();
-                res.remove_every_n(duplication_freq, num_repeats, duplication_offset).unwrap();
+                res.remove_every_n(duplication_freq, num_repeats, duplication_offset)
+                    .map_err(|e| {
+                        error!("Error duplicating values: {:?}", e);
+                        halo2_proofs::plonk::Error::Synthesis
+                    })?;
 
-                res.reshape(dims).unwrap();
+                res.reshape(dims).map_err(|e| {
+                    error!("Error duplicating values: {:?}", e);
+                    halo2_proofs::plonk::Error::Synthesis
+                })?;
                 res.set_scale(values.scale());
 
                 Ok((res, total_used_len))
@@ -681,61 +706,71 @@ impl VarTensor {
         let mut prev_cell = None;
 
         match values {
-            ValTensor::Instance { .. } => unimplemented!("duplication is not supported on instance columns. increase K if you require more rows."),
-            ValTensor::Value { inner: v, dims , ..} => {
-
+            ValTensor::Instance { .. } => {
+                error!(
+                    "duplication is not supported on instance columns. increase K if you require more rows."
+                );
+                Err(halo2_proofs::plonk::Error::Synthesis)
+            }
+            ValTensor::Value { inner: v, dims, .. } => {
                 let duplication_freq = self.col_size();
                 let num_repeats = 1;
                 let duplication_offset = row;
 
                 // duplicates every nth element to adjust for column overflow
-                let v = v.duplicate_every_n(duplication_freq, num_repeats, duplication_offset).unwrap();
-                let mut res: ValTensor<F> =
-                    v.enum_map(|coord, k| {
+                let v = v
+                    .duplicate_every_n(duplication_freq, num_repeats, duplication_offset)
+                    .unwrap();
+                let mut res: ValTensor<F> = v
+                    .enum_map(|coord, k| {
+                        let step = self.num_inner_cols();
 
-                    let step = self.num_inner_cols();
+                        let (x, y, z) = self.cartesian_coord(offset + coord * step);
+                        if matches!(check_mode, CheckMode::SAFE) && coord > 0 && z == 0 && y == 0 {
+                            // assert that duplication occurred correctly
+                            assert_eq!(
+                                Into::<IntegerRep>::into(k.clone()),
+                                Into::<IntegerRep>::into(v[coord - 1].clone())
+                            );
+                        };
 
-                    let (x, y, z) = self.cartesian_coord(offset + coord * step);
-                    if matches!(check_mode, CheckMode::SAFE) && coord > 0 && z == 0 && y == 0 {
-                        // assert that duplication occurred correctly
-                        assert_eq!(Into::<IntegerRep>::into(k.clone()), Into::<IntegerRep>::into(v[coord - 1].clone()));
-                    };
+                        let cell =
+                            self.assign_value(region, offset, k.clone(), coord * step, constants)?;
 
-                    let cell = self.assign_value(region, offset, k.clone(), coord * step, constants)?;
+                        let at_end_of_column = z == duplication_freq - 1;
+                        let at_beginning_of_column = z == 0;
 
-                    let at_end_of_column = z == duplication_freq - 1;
-                    let at_beginning_of_column = z == 0;
-
-                    if at_end_of_column {
-                        // if we are at the end of the column, we need to copy the cell to the next column
-                        prev_cell = Some(cell.clone());
-                    } else if coord > 0 && at_beginning_of_column  {
-                        if let Some(prev_cell) = prev_cell.as_ref() {
-                            let cell = if let Some(cell) = cell.cell() {
-                                cell
+                        if at_end_of_column {
+                            // if we are at the end of the column, we need to copy the cell to the next column
+                            prev_cell = Some(cell.clone());
+                        } else if coord > 0 && at_beginning_of_column {
+                            if let Some(prev_cell) = prev_cell.as_ref() {
+                                let cell = if let Some(cell) = cell.cell() {
+                                    cell
+                                } else {
+                                    error!("Error getting cell: {:?}", (x, y));
+                                    return Err(halo2_proofs::plonk::Error::Synthesis);
+                                };
+                                let prev_cell = if let Some(prev_cell) = prev_cell.cell() {
+                                    prev_cell
+                                } else {
+                                    error!("Error getting prev cell: {:?}", (x, y));
+                                    return Err(halo2_proofs::plonk::Error::Synthesis);
+                                };
+                                region.constrain_equal(prev_cell, cell)?;
                             } else {
-                                error!("Error getting cell: {:?}", (x,y));
+                                error!("Previous cell was not set");
                                 return Err(halo2_proofs::plonk::Error::Synthesis);
-                            };
-                            let prev_cell = if let Some(prev_cell) = prev_cell.cell() {
-                                prev_cell
-                            } else {
-                                error!("Error getting prev cell: {:?}", (x,y));
-                                return Err(halo2_proofs::plonk::Error::Synthesis);
-                            };
-                            region.constrain_equal(prev_cell,cell)?;
-                        } else {
-                            error!("Previous cell was not set");
-                            return Err(halo2_proofs::plonk::Error::Synthesis);
+                            }
                         }
-                    }
 
-                    Ok(cell)
-
-                })?.into();
+                        Ok(cell)
+                    })?
+                    .into();
 
                 let total_used_len = res.len();
-                res.remove_every_n(duplication_freq, num_repeats, duplication_offset).unwrap();
+                res.remove_every_n(duplication_freq, num_repeats, duplication_offset)
+                    .unwrap();
 
                 res.reshape(dims).unwrap();
                 res.set_scale(values.scale());
@@ -771,21 +806,30 @@ impl VarTensor {
                 VarTensor::Advice { inner: advices, .. } => {
                     ValType::PrevAssigned(region.assign_advice(|| "k", advices[x][y], z, || v)?)
                 }
-                _ => unimplemented!(),
+                _ => {
+                    error!("VarTensor was not initialized");
+                    return Err(halo2_proofs::plonk::Error::Synthesis);
+                }
             },
             // Handle copying previously assigned value
             ValType::PrevAssigned(v) => match &self {
                 VarTensor::Advice { inner: advices, .. } => {
                     ValType::PrevAssigned(v.copy_advice(|| "k", region, advices[x][y], z)?)
                 }
-                _ => unimplemented!(),
+                _ => {
+                    error!("VarTensor was not initialized");
+                    return Err(halo2_proofs::plonk::Error::Synthesis);
+                }
             },
             // Handle copying previously assigned constant
             ValType::AssignedConstant(v, val) => match &self {
                 VarTensor::Advice { inner: advices, .. } => {
                     ValType::AssignedConstant(v.copy_advice(|| "k", region, advices[x][y], z)?, val)
                 }
-                _ => unimplemented!(),
+                _ => {
+                    error!("VarTensor was not initialized");
+                    return Err(halo2_proofs::plonk::Error::Synthesis);
+                }
             },
             // Handle assigning evaluated value
             ValType::AssignedValue(v) => match &self {
@@ -794,7 +838,10 @@ impl VarTensor {
                         .assign_advice(|| "k", advices[x][y], z, || v)?
                         .evaluate(),
                 ),
-                _ => unimplemented!(),
+                _ => {
+                    error!("VarTensor was not initialized");
+                    return Err(halo2_proofs::plonk::Error::Synthesis);
+                }
             },
             // Handle constant value assignment with caching
             ValType::Constant(v) => {

tests/foundry/.gitignore

@@ -0,0 +1,14 @@
+# Compiler files
+cache/
+out/
+
+# Ignores development broadcast logs
+!/broadcast
+/broadcast/*/31337/
+/broadcast/**/dry-run/
+
+# Docs
+docs/
+
+# Dotenv file
+.env

tests/foundry/README.md

@@ -0,0 +1,66 @@
+## Foundry
+
+**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
+
+Foundry consists of:
+
+-   **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
+-   **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
+-   **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
+-   **Chisel**: Fast, utilitarian, and verbose solidity REPL.
+
+## Documentation
+
+https://book.getfoundry.sh/
+
+## Usage
+
+### Build
+
+```shell
+$ forge build
+```
+
+### Test
+
+```shell
+$ forge test
+```
+
+### Format
+
+```shell
+$ forge fmt
+```
+
+### Gas Snapshots
+
+```shell
+$ forge snapshot
+```
+
+### Anvil
+
+```shell
+$ anvil
+```
+
+### Deploy
+
+```shell
+$ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --private-key <your_private_key>
+```
+
+### Cast
+
+```shell
+$ cast <subcommand>
+```
+
+### Help
+
+```shell
+$ forge --help
+$ anvil --help
+$ cast --help
+```

tests/foundry/foundry.toml

@@ -0,0 +1,6 @@
+[profile.default]
+src = "../../contracts"
+out = "out"
+libs = ["lib"]
+
+# See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

tests/foundry/remappings.txt

@@ -0,0 +1 @@
+contracts/=../../contracts/

tests/foundry/test/AttestData.t.sol

@@ -0,0 +1,429 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "forge-std/Test.sol";
+import {console} from "forge-std/console.sol";
+import "contracts/AttestData.sol" as AttestData;
+
+contract MockVKA {
+    constructor() {}
+}
+
+contract MockVerifier {
+    bool public shouldVerify;
+
+    constructor(bool _shouldVerify) {
+        shouldVerify = _shouldVerify;
+    }
+
+    function verifyProof(
+        bytes calldata,
+        uint256[] calldata
+    ) external view returns (bool) {
+        require(shouldVerify, "Verification failed");
+        return shouldVerify;
+    }
+}
+
+contract MockVerifierSeperate {
+    bool public shouldVerify;
+
+    constructor(bool _shouldVerify) {
+        shouldVerify = _shouldVerify;
+    }
+
+    function verifyProof(
+        address,
+        bytes calldata,
+        uint256[] calldata
+    ) external view returns (bool) {
+        require(shouldVerify, "Verification failed");
+        return shouldVerify;
+    }
+}
+
+contract MockTargetContract {
+    int256[] public data;
+
+    constructor(int256[] memory _data) {
+        data = _data;
+    }
+
+    function setData(int256[] memory _data) external {
+        data = _data;
+    }
+
+    function getData() external view returns (int256[] memory) {
+        return data;
+    }
+}
+
+contract DataAttestationTest is Test {
+    AttestData.DataAttestation das;
+    MockVerifier verifier;
+    MockVerifierSeperate verifierSeperate;
+    MockVKA vka;
+    MockTargetContract target;
+    int256[] mockData = [int256(1e18), -int256(5e17)];
+    uint256[] decimals = [18, 18];
+    uint256[] bits = [13, 13];
+    uint8 instanceOffset = 0;
+    bytes callData;
+
+    function setUp() public {
+        target = new MockTargetContract(mockData);
+        verifier = new MockVerifier(true);
+        verifierSeperate = new MockVerifierSeperate(true);
+        vka = new MockVKA();
+
+        callData = abi.encodeWithSignature("getData()");
+
+        das = new AttestData.DataAttestation(
+            address(target),
+            callData,
+            decimals,
+            bits,
+            instanceOffset
+        );
+    }
+
+    // Fork of mulDivRound which doesn't revert on overflow and returns a boolean instead to indicate overflow
+    function mulDivRound(
+        uint256 x,
+        uint256 y,
+        uint256 denominator
+    ) public pure returns (uint256 result, bool overflow) {
+        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))
+            }
+            uint256 remainder = mulmod(x, y, denominator);
+            bool addOne;
+            if (remainder * 2 >= denominator) {
+                addOne = true;
+            }
+
+            if (prod1 == 0) {
+                if (addOne) {
+                    return ((prod0 / denominator) + 1, false);
+                }
+                return (prod0 / denominator, false);
+            }
+
+            if (denominator > prod1) {
+                return (0, true);
+            }
+
+            assembly {
+                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;
+            if (addOne) {
+                result += 1;
+            }
+            return (result, false);
+        }
+    }
+    struct SampleAttestation {
+        int256 mockData;
+        uint8 decimals;
+        uint8 bits;
+    }
+    function test_fuzzAttestedData(
+        SampleAttestation[] memory _attestations
+    ) public {
+        vm.assume(_attestations.length == 1);
+        int256[] memory _mockData = new int256[](1);
+        uint256[] memory _decimals = new uint256[](1);
+        uint256[] memory _bits = new uint256[](1);
+        uint256[] memory _instances = new uint256[](1);
+        for (uint256 i = 0; i < 1; i++) {
+            SampleAttestation memory attestation = _attestations[i];
+            _mockData[i] = attestation.mockData;
+            vm.assume(attestation.mockData != type(int256).min); /// Will overflow int256 during negation op
+            vm.assume(attestation.decimals < 77); /// Else will exceed uint256 bounds
+            vm.assume(attestation.bits < 128); /// Else will exceed EZKL fixed point bounds for int128 type
+            bool neg = attestation.mockData < 0;
+            if (neg) {
+                attestation.mockData = -attestation.mockData;
+            }
+            (uint256 _result, bool overflow) = mulDivRound(
+                uint256(attestation.mockData),
+                uint256(1 << attestation.bits),
+                uint256(10 ** attestation.decimals)
+            );
+            vm.assume(!overflow);
+            vm.assume(_result < das.HALF_ORDER());
+            if (neg) {
+                // No possibility of overflow here since output is less than or equal to HALF_ORDER
+                // and therefore falls within the max range of int256 without overflow
+                vm.assume(-int256(_result) > type(int128).min);
+                _instances[i] =
+                    uint256(int(das.ORDER()) - int256(_result)) %
+                    das.ORDER();
+            } else {
+                vm.assume(_result < uint128(type(int128).max));
+                _instances[i] = _result;
+            }
+            _decimals[i] = attestation.decimals;
+            _bits[i] = attestation.bits;
+        }
+        // Update the attested data
+        target.setData(_mockData);
+        // Deploy the new data attestation contract
+        AttestData.DataAttestation dasNew = new AttestData.DataAttestation(
+            address(target),
+            callData,
+            _decimals,
+            _bits,
+            instanceOffset
+        );
+        bytes memory proof = hex"1234"; // Would normally contain commitments
+        bytes memory encoded = abi.encodeWithSignature(
+            "verifyProof(bytes,uint256[])",
+            proof,
+            _instances
+        );
+
+        AttestData.DataAttestation.Scalars memory _scalars = AttestData
+            .DataAttestation
+            .Scalars(10 ** _decimals[0], 1 << _bits[0]);
+
+        int256 output = dasNew.quantizeData(_mockData[0], _scalars);
+        console.log("output: ", output);
+        uint256 fieldElement = dasNew.toFieldElement(output);
+        // output should equal to _instances[0]
+        assertEq(fieldElement, _instances[0]);
+
+        bool verificationResult = dasNew.verifyWithDataAttestation(
+            address(verifier),
+            encoded
+        );
+        assertTrue(verificationResult);
+    }
+
+    // Test deployment parameters
+    function testDeployment() public view {
+        assertEq(das.contractAddress(), address(target));
+        assertEq(das.callData(), abi.encodeWithSignature("getData()"));
+        assertEq(das.instanceOffset(), instanceOffset);
+
+        AttestData.DataAttestation.Scalars memory scalar = das.getScalars(0);
+        assertEq(scalar.decimals, 1e18);
+        assertEq(scalar.bits, 1 << 13);
+    }
+
+    // Test quantizeData function
+    function testQuantizeData() public view {
+        AttestData.DataAttestation.Scalars memory scalar = das.getScalars(0);
+
+        int256 positive = das.quantizeData(1e18, scalar);
+        assertEq(positive, int256(scalar.bits));
+
+        int256 negative = das.quantizeData(-1e18, scalar);
+        assertEq(negative, -int256(scalar.bits));
+
+        // Test rounding
+        int half = int(0.5e18 / scalar.bits);
+        int256 rounded = das.quantizeData(half, scalar);
+        assertEq(rounded, 1);
+    }
+
+    // Test staticCall functionality
+    function testStaticCall() public view {
+        bytes memory result = das.staticCall(
+            address(target),
+            abi.encodeWithSignature("getData()")
+        );
+        int256[] memory decoded = abi.decode(result, (int256[]));
+        assertEq(decoded[0], mockData[0]);
+        assertEq(decoded[1], mockData[1]);
+    }
+
+    // Test attestData validation
+    function testAttestDataSuccess() public view {
+        uint256[] memory instances = new uint256[](2);
+        AttestData.DataAttestation.Scalars memory scalar = das.getScalars(0);
+        instances[0] = das.toFieldElement(int(scalar.bits));
+        instances[1] = das.toFieldElement(-int(scalar.bits >> 1));
+        das.attestData(instances); // Should not revert
+    }
+
+    function testAttestDataFailure() public {
+        uint256[] memory instances = new uint256[](2);
+        instances[0] = das.toFieldElement(1e18); // Incorrect value
+        instances[1] = das.toFieldElement(5e17);
+
+        vm.expectRevert("Public input does not match");
+        das.attestData(instances);
+    }
+
+    // Test full verification flow
+    function testSuccessfulVerification() public view {
+        // Prepare valid instances
+        uint256[] memory instances = new uint256[](2);
+        AttestData.DataAttestation.Scalars memory scalar = das.getScalars(0);
+        instances[0] = das.toFieldElement(int(scalar.bits));
+        instances[1] = das.toFieldElement(-int(scalar.bits >> 1));
+
+        // Create valid calldata (mock)
+        bytes memory proof = hex"1234"; // Would normally contain commitments
+        bytes memory encoded = abi.encodeWithSignature(
+            "verifyProof(bytes,uint256[])",
+            proof,
+            instances
+        );
+        bytes memory encoded_vka = abi.encodeWithSignature(
+            "verifyProof(address,bytes,uint256[])",
+            address(vka),
+            proof,
+            instances
+        );
+
+        bool result = das.verifyWithDataAttestation(address(verifier), encoded);
+        assertTrue(result);
+        result = das.verifyWithDataAttestation(
+            address(verifierSeperate),
+            encoded_vka
+        );
+        assertTrue(result);
+    }
+
+    function testLoadInstances() public view {
+        uint256[] memory instances = new uint256[](2);
+        AttestData.DataAttestation.Scalars memory scalar = das.getScalars(0);
+        instances[0] = das.toFieldElement(int(scalar.bits));
+        instances[1] = das.toFieldElement(-int(scalar.bits >> 1));
+
+        // Create valid calldata (mock)
+        bytes memory proof = hex"1234"; // Would normally contain commitments
+        bytes memory encoded = abi.encodeWithSignature(
+            "verifyProof(bytes,uint256[])",
+            proof,
+            instances
+        );
+        bytes memory encoded_vka = abi.encodeWithSignature(
+            "verifyProof(address,bytes,uint256[])",
+            address(vka),
+            proof,
+            instances
+        );
+
+        // Load encoded instances from calldata
+        uint256[] memory extracted_instances_calldata = das
+            .getInstancesCalldata(encoded);
+        assertEq(extracted_instances_calldata[0], instances[0]);
+        assertEq(extracted_instances_calldata[1], instances[1]);
+        // Load encoded instances from memory
+        uint256[] memory extracted_instances_memory = das.getInstancesMemory(
+            encoded
+        );
+        assertEq(extracted_instances_memory[0], instances[0]);
+        assertEq(extracted_instances_memory[1], instances[1]);
+        // Load encoded with vk instances from calldata
+        uint256[] memory extracted_instances_calldata_vk = das
+            .getInstancesCalldata(encoded_vka);
+        assertEq(extracted_instances_calldata_vk[0], instances[0]);
+        assertEq(extracted_instances_calldata_vk[1], instances[1]);
+        // Load encoded with vk instances from memory
+        uint256[] memory extracted_instances_memory_vk = das.getInstancesMemory(
+            encoded_vka
+        );
+        assertEq(extracted_instances_memory_vk[0], instances[0]);
+        assertEq(extracted_instances_memory_vk[1], instances[1]);
+    }
+
+    function testInvalidCommitments() public {
+        // Create calldata with invalid commitments
+        bytes memory invalidProof = hex"5678";
+        uint256[] memory instances = new uint256[](2);
+        AttestData.DataAttestation.Scalars memory scalar = das.getScalars(0);
+        instances[0] = das.toFieldElement(int(scalar.bits));
+        instances[1] = das.toFieldElement(-int(scalar.bits >> 1));
+        bytes memory encoded = abi.encodeWithSignature(
+            "verifyProof(bytes,uint256[])",
+            invalidProof,
+            instances
+        );
+
+        vm.expectRevert("Invalid KZG commitments");
+        das.verifyWithDataAttestation(address(verifier), encoded);
+    }
+
+    function testInvalidVerifier() public {
+        MockVerifier invalidVerifier = new MockVerifier(false);
+        uint256[] memory instances = new uint256[](2);
+        AttestData.DataAttestation.Scalars memory scalar = das.getScalars(0);
+        instances[0] = das.toFieldElement(int(scalar.bits));
+        instances[1] = das.toFieldElement(-int(scalar.bits >> 1));
+        bytes memory encoded = abi.encodeWithSignature(
+            "verifyProof(bytes,uint256[])",
+            hex"1234",
+            instances
+        );
+
+        vm.expectRevert("low-level call to verifier failed");
+        das.verifyWithDataAttestation(address(invalidVerifier), encoded);
+    }
+
+    // Test edge cases
+    function testZeroValueQuantization() public view {
+        AttestData.DataAttestation.Scalars memory scalar = das.getScalars(0);
+        int256 zero = das.quantizeData(0, scalar);
+        assertEq(zero, 0);
+    }
+
+    function testOverflowProtection() public {
+        int256 order = int(
+            uint256(
+                0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
+            )
+        );
+        // int256 half_order = int(order >> 1);
+        AttestData.DataAttestation.Scalars memory scalar = AttestData
+            .DataAttestation
+            .Scalars(1, 1 << 2);
+
+        vm.expectRevert("Overflow field modulus");
+        das.quantizeData(order, scalar); // Value that would overflow
+    }
+
+    function testInvalidFunctionSignature() public {
+        uint256[] memory instances = new uint256[](2);
+        AttestData.DataAttestation.Scalars memory scalar = das.getScalars(0);
+        instances[0] = das.toFieldElement(int(scalar.bits));
+        instances[1] = das.toFieldElement(-int(scalar.bits >> 1));
+        bytes memory encoded_invalid_sig = abi.encodeWithSignature(
+            "verifyProofff(bytes,uint256[])",
+            hex"1234",
+            instances
+        );
+
+        vm.expectRevert("Invalid function signature");
+        das.verifyWithDataAttestation(address(verifier), encoded_invalid_sig);
+    }
+}

tests/integration_tests.rs

@@ -1,10 +1,10 @@
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 #[cfg(test)]
 mod native_tests {
-    
+
     // use ezkl::circuit::table::RESERVED_BLINDING_ROWS_PAD;
-    use ezkl::graph::input::{FileSource, FileSourceInner, GraphData};
-    use ezkl::graph::{DataSource, GraphSettings, GraphWitness};
+    use ezkl::graph::input::{FileSource, GraphData};
+    use ezkl::graph::GraphSettings;
     use ezkl::pfsys::Snark;
     use ezkl::Commitments;
     use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
@@ -163,17 +163,14 @@ mod native_tests {
             let data = GraphData::from_path(format!("{}/{}/input.json", test_dir, test).into())
                 .expect("failed to load input data");
 
-            let input_data = match data.input_data {
-                DataSource::File(data) => data,
-                _ => panic!("Only File data sources support batching"),
-            };
-
-            let duplicated_input_data: FileSource = input_data
+            let duplicated_input_data: FileSource = data
+                .input_data
+                .values()
                 .iter()
                 .map(|data| (0..num_batches).flat_map(|_| data.clone()).collect())
                 .collect();
 
-            let duplicated_data = GraphData::new(DataSource::File(duplicated_input_data));
+            let duplicated_data = GraphData::new(duplicated_input_data.into());
 
             let res =
                 duplicated_data.save(format!("{}/{}/input.json", test_dir, output_dir).into());
@@ -522,7 +519,7 @@ mod native_tests {
             use crate::native_tests::run_js_tests;
             use crate::native_tests::render_circuit;
             use crate::native_tests::model_serialization_different_binaries;
-            
+
             use tempdir::TempDir;
             use ezkl::Commitments;
 
@@ -991,7 +988,6 @@ mod native_tests {
             use crate::native_tests::kzg_evm_prove_and_verify;
             use crate::native_tests::kzg_evm_prove_and_verify_reusable_verifier;
 
-            use crate::native_tests::kzg_evm_on_chain_input_prove_and_verify;
             use crate::native_tests::kzg_evm_aggr_prove_and_verify;
             use tempdir::TempDir;
             use crate::native_tests::Hardfork;
@@ -1006,101 +1002,6 @@ mod native_tests {
             }
 
 
-            /// Currently only on chain inputs that return a non-negative value are supported.
-            const TESTS_ON_CHAIN_INPUT: [&str; 17] = [
-                "1l_mlp",
-                "1l_average",
-                "1l_reshape",
-                "1l_sigmoid",
-                "1l_div",
-                "1l_sqrt",
-                "1l_prelu",
-                "1l_var",
-                "1l_leakyrelu",
-                "1l_gelu_noappx",
-                "1l_relu",
-                "1l_tanh",
-                "2l_relu_sigmoid_small",
-                "2l_relu_small",
-                "2l_relu_fc",
-                "min",
-                "max"
-            ];
-
-            seq!(N in 0..=16 {
-                #(#[test_case((TESTS_ON_CHAIN_INPUT[N],Hardfork::Latest))])*
-                #(#[test_case((TESTS_ON_CHAIN_INPUT[N],Hardfork::Paris))])*
-                #(#[test_case((TESTS_ON_CHAIN_INPUT[N],Hardfork::London))])*
-                #(#[test_case((TESTS_ON_CHAIN_INPUT[N],Hardfork::Shanghai))])*
-                fn kzg_evm_on_chain_input_prove_and_verify_(test: (&str,Hardfork)) {
-                    let (test,hardfork) = test;
-                    crate::native_tests::init_binary();
-                    let test_dir = TempDir::new(test).unwrap();
-                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                    let _anvil_child = crate::native_tests::start_anvil(true, hardfork);
-                    kzg_evm_on_chain_input_prove_and_verify(path, test.to_string(), "on-chain", "file", "public", "private", "private");
-                    // test_dir.close().unwrap();
-                }
-
-                #(#[test_case(TESTS_ON_CHAIN_INPUT[N])])*
-                fn kzg_evm_on_chain_output_prove_and_verify_(test: &str) {
-                    crate::native_tests::init_binary();
-                    let test_dir = TempDir::new(test).unwrap();
-                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                    let _anvil_child = crate::native_tests::start_anvil(true, Hardfork::Latest);
-                    kzg_evm_on_chain_input_prove_and_verify(path, test.to_string(), "file", "on-chain", "private", "public", "private");
-                    // test_dir.close().unwrap();
-                }
-
-                #(#[test_case(TESTS_ON_CHAIN_INPUT[N])])*
-                fn kzg_evm_on_chain_input_output_prove_and_verify_(test: &str) {
-                    crate::native_tests::init_binary();
-                    let test_dir = TempDir::new(test).unwrap();
-                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                    let _anvil_child = crate::native_tests::start_anvil(true, Hardfork::Latest);
-                    kzg_evm_on_chain_input_prove_and_verify(path, test.to_string(), "on-chain", "on-chain", "public", "public", "private");
-                    test_dir.close().unwrap();
-                }
-
-                #(#[test_case(TESTS_ON_CHAIN_INPUT[N])])*
-                fn kzg_evm_on_chain_input_output_hashed_prove_and_verify_(test: &str) {
-                    crate::native_tests::init_binary();
-                    let test_dir = TempDir::new(test).unwrap();
-                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                    let _anvil_child = crate::native_tests::start_anvil(true, Hardfork::Latest);
-                    kzg_evm_on_chain_input_prove_and_verify(path, test.to_string(), "on-chain", "on-chain", "hashed", "hashed", "private");
-                    test_dir.close().unwrap();
-                }
-                #(#[test_case(TESTS_ON_CHAIN_INPUT[N])])*
-                fn kzg_evm_on_chain_input_kzg_output_kzg_params_prove_and_verify_(test: &str) {
-                    crate::native_tests::init_binary();
-                    let test_dir = TempDir::new(test).unwrap();
-                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                    let _anvil_child = crate::native_tests::start_anvil(true, Hardfork::Latest);
-                    kzg_evm_on_chain_input_prove_and_verify(path, test.to_string(), "on-chain", "file", "public", "polycommit", "polycommit");
-                    test_dir.close().unwrap();
-                }
-                #(#[test_case(TESTS_ON_CHAIN_INPUT[N])])*
-                fn kzg_evm_on_chain_output_kzg_input_kzg_params_prove_and_verify_(test: &str) {
-                    crate::native_tests::init_binary();
-                    let test_dir = TempDir::new(test).unwrap();
-                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                    let _anvil_child = crate::native_tests::start_anvil(true, Hardfork::Latest);
-                    kzg_evm_on_chain_input_prove_and_verify(path, test.to_string(), "file", "on-chain", "polycommit", "public", "polycommit");
-                    test_dir.close().unwrap();
-                }
-                #(#[test_case(TESTS_ON_CHAIN_INPUT[N])])*
-                fn kzg_evm_on_chain_all_kzg_params_prove_and_verify_(test: &str) {
-                    crate::native_tests::init_binary();
-                    let test_dir = TempDir::new(test).unwrap();
-                    let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
-                    let _anvil_child = crate::native_tests::start_anvil(true, Hardfork::Latest);
-                    kzg_evm_on_chain_input_prove_and_verify(path, test.to_string(), "file", "file", "polycommit", "polycommit", "polycommit");
-                    test_dir.close().unwrap();
-                }
-            });
-
-
             seq!(N in 0..=17 {
                 // these take a particularly long time to run
                 #(#[test_case(TESTS_EVM_AGGR[N])])*
@@ -2192,15 +2093,14 @@ mod native_tests {
             }
         };
 
-        let addr_path_arg_vk = format!("--addr-path={}/{}/addr_vk.txt", test_dir, example_name);
-        let sol_arg_vk: String = format!("--sol-code-path={}/{}/vk.sol", test_dir, example_name);
+        let arg_vka: String = format!("--vka-path={}/{}/vka.bytes", test_dir, example_name);
         // create the verifier
         let args = vec![
             "create-evm-vka",
             "--vk-path",
             &vk_arg,
             &settings_arg,
-            &sol_arg_vk,
+            &arg_vka,
         ];
 
         let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
@@ -2209,13 +2109,12 @@ mod native_tests {
             .expect("failed to execute process");
         assert!(status.success());
 
-        // deploy the vka
+        // register the vka
         let args = vec![
-            "deploy-evm",
+            "register-vka",
             rpc_arg.as_str(),
-            addr_path_arg_vk.as_str(),
-            sol_arg_vk.as_str(),
-            "-C=vka",
+            arg_vka.as_str(),
+            deployed_addr_arg.as_str(),
         ];
 
         let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
@@ -2224,19 +2123,13 @@ mod native_tests {
             .expect("failed to execute process");
         assert!(status.success());
 
-        // read in the address
-        let addr_vk = std::fs::read_to_string(format!("{}/{}/addr_vk.txt", test_dir, example_name))
-            .expect("failed to read address file");
-
-        let deployed_addr_arg_vk = format!("--addr-vk={}", addr_vk);
-
         // create encoded calldata
         let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
             .args([
                 "encode-evm-calldata",
                 "--proof-path",
                 &format!("{}/{}/proof.pf", test_dir, example_name),
-                &deployed_addr_arg_vk,
+                &arg_vka,
             ])
             .status()
             .expect("failed to execute process");
@@ -2251,7 +2144,7 @@ mod native_tests {
             pf_arg.as_str(),
             rpc_arg.as_str(),
             deployed_addr_arg.as_str(),
-            deployed_addr_arg_vk.as_str(),
+            arg_vka.as_str(),
         ];
 
         let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
@@ -2293,7 +2186,12 @@ mod native_tests {
                 .expect("failed to execute process");
 
             if status.success() {
-                log::error!("Verification unexpectedly succeeded for modified proof {}. Flipped bit {} in byte {}", i, random_bit, random_byte);
+                log::error!(
+                    "Verification unexpectedly succeeded for modified proof {}. Flipped bit {} in byte {}",
+                    i,
+                    random_bit,
+                    random_byte
+                );
             }
 
             assert!(
@@ -2324,328 +2222,6 @@ mod native_tests {
         assert!(status.success());
     }
 
-    fn kzg_evm_on_chain_input_prove_and_verify(
-        test_dir: &str,
-        example_name: String,
-        input_source: &str,
-        output_source: &str,
-        input_visibility: &str,
-        output_visibility: &str,
-        param_visibility: &str,
-    ) {
-        gen_circuit_settings_and_witness(
-            test_dir,
-            example_name.clone(),
-            input_visibility,
-            param_visibility,
-            output_visibility,
-            1,
-            "resources",
-            // we need the accuracy
-            Some(vec![4]),
-            1,
-            Commitments::KZG,
-            2,
-            false,
-            None,
-            None,
-        );
-
-        let model_path = format!("{}/{}/network.compiled", test_dir, example_name);
-        let settings_path = format!("{}/{}/settings.json", test_dir, example_name);
-        init_params(settings_path.clone().into());
-
-        let data_path = format!("{}/{}/input.json", test_dir, example_name);
-        let witness_path = format!("{}/{}/witness.json", test_dir, example_name);
-        let test_on_chain_data_path = format!("{}/{}/on_chain_input.json", test_dir, example_name);
-        let rpc_arg = format!("--rpc-url={}", LIMITLESS_ANVIL_URL.as_str());
-        let private_key = format!("--private-key={}", *ANVIL_DEFAULT_PRIVATE_KEY);
-
-        let test_input_source = format!("--input-source={}", input_source);
-        let test_output_source = format!("--output-source={}", output_source);
-
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-            .args([
-                "setup",
-                "-M",
-                &model_path,
-                "--pk-path",
-                &format!("{}/{}/key.pk", test_dir, example_name),
-                "--vk-path",
-                &format!("{}/{}/key.vk", test_dir, example_name),
-            ])
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
-
-        // generate the witness, passing the vk path to generate the necessary kzg commits
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-            .args([
-                "gen-witness",
-                "-D",
-                &data_path,
-                "-M",
-                &model_path,
-                "-O",
-                &witness_path,
-                "--vk-path",
-                &format!("{}/{}/key.vk", test_dir, example_name),
-            ])
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
-
-        // load witness
-        let witness: GraphWitness = GraphWitness::from_path(witness_path.clone().into()).unwrap();
-        // print out the witness
-        println!("WITNESS: {:?}", witness);
-        let mut input: GraphData = GraphData::from_path(data_path.clone().into()).unwrap();
-        if input_source != "file" || output_source != "file" {
-            println!("on chain input");
-            if input_visibility == "hashed" {
-                let hashes = witness.processed_inputs.unwrap().poseidon_hash.unwrap();
-                input.input_data = DataSource::File(
-                    hashes
-                        .iter()
-                        .map(|h| vec![FileSourceInner::Field(*h)])
-                        .collect(),
-                );
-            }
-            if output_visibility == "hashed" {
-                let hashes = witness.processed_outputs.unwrap().poseidon_hash.unwrap();
-                input.output_data = Some(DataSource::File(
-                    hashes
-                        .iter()
-                        .map(|h| vec![FileSourceInner::Field(*h)])
-                        .collect(),
-                ));
-            } else {
-                input.output_data = Some(DataSource::File(
-                    witness
-                        .pretty_elements
-                        .unwrap()
-                        .rescaled_outputs
-                        .iter()
-                        .map(|o| {
-                            o.iter()
-                                .map(|f| FileSourceInner::Float(f.parse().unwrap()))
-                                .collect()
-                        })
-                        .collect(),
-                ));
-            }
-            input.save(data_path.clone().into()).unwrap();
-
-            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-                .args([
-                    "setup-test-evm-data",
-                    "-D",
-                    data_path.as_str(),
-                    "-M",
-                    &model_path,
-                    "--test-data",
-                    test_on_chain_data_path.as_str(),
-                    rpc_arg.as_str(),
-                    test_input_source.as_str(),
-                    test_output_source.as_str(),
-                ])
-                .status()
-                .expect("failed to execute process");
-            assert!(status.success());
-        }
-
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-            .args([
-                "prove",
-                "-W",
-                &witness_path,
-                "-M",
-                &model_path,
-                "--proof-path",
-                &format!("{}/{}/proof.pf", test_dir, example_name),
-                "--pk-path",
-                &format!("{}/{}/key.pk", test_dir, example_name),
-            ])
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
-
-        let vk_arg = format!("{}/{}/key.vk", test_dir, example_name);
-
-        let settings_arg = format!("--settings-path={}", settings_path);
-
-        // create encoded calldata
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-            .args([
-                "encode-evm-calldata",
-                "--proof-path",
-                &format!("{}/{}/proof.pf", test_dir, example_name),
-            ])
-            .status()
-            .expect("failed to execute process");
-
-        assert!(status.success());
-
-        // create the verifier
-        let mut args = vec!["create-evm-verifier", "--vk-path", &vk_arg, &settings_arg];
-
-        let sol_arg = format!("{}/{}/kzg.sol", test_dir, example_name);
-
-        args.push("--sol-code-path");
-        args.push(sol_arg.as_str());
-
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-            .args(&args)
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
-
-        let addr_path_verifier_arg = format!(
-            "--addr-path={}/{}/addr_verifier.txt",
-            test_dir, example_name
-        );
-
-        // deploy the verifier
-        let mut args = vec![
-            "deploy-evm",
-            rpc_arg.as_str(),
-            addr_path_verifier_arg.as_str(),
-        ];
-
-        args.push("--sol-code-path");
-        args.push(sol_arg.as_str());
-
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-            .args(&args)
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
-
-        let sol_arg = format!("{}/{}/kzg.sol", test_dir, example_name);
-
-        let mut create_da_args = vec![
-            "create-evm-da",
-            &settings_arg,
-            "--sol-code-path",
-            sol_arg.as_str(),
-            "-W",
-            &witness_path,
-        ];
-
-        // if there is a on-chain source we add the data
-        if input_source != "file" || output_source != "file" {
-            create_da_args.push("-D");
-            create_da_args.push(test_on_chain_data_path.as_str());
-        }
-
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-            .args(&create_da_args)
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
-
-        let deploy_evm_data_path = if input_source != "file" || output_source != "file" {
-            test_on_chain_data_path.clone()
-        } else {
-            data_path.clone()
-        };
-
-        let addr_path_da_arg = format!("--addr-path={}/{}/addr_da.txt", test_dir, example_name);
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-            .args([
-                "deploy-evm-da",
-                format!("--settings-path={}", settings_path).as_str(),
-                "-D",
-                deploy_evm_data_path.as_str(),
-                "--sol-code-path",
-                sol_arg.as_str(),
-                rpc_arg.as_str(),
-                addr_path_da_arg.as_str(),
-                private_key.as_str(),
-            ])
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
-
-        let pf_arg = format!("{}/{}/proof.pf", test_dir, example_name);
-        // read in the verifier address
-        let addr_verifier =
-            std::fs::read_to_string(format!("{}/{}/addr_verifier.txt", test_dir, example_name))
-                .expect("failed to read address file");
-
-        let deployed_addr_verifier_arg = format!("--addr-verifier={}", addr_verifier);
-
-        // read in the da address
-        let addr_da = std::fs::read_to_string(format!("{}/{}/addr_da.txt", test_dir, example_name))
-            .expect("failed to read address file");
-
-        let deployed_addr_da_arg = format!("--addr-da={}", addr_da);
-
-        let args = vec![
-            "verify-evm",
-            "--proof-path",
-            pf_arg.as_str(),
-            deployed_addr_verifier_arg.as_str(),
-            deployed_addr_da_arg.as_str(),
-            rpc_arg.as_str(),
-        ];
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-            .args(&args)
-            .status()
-            .expect("failed to execute process");
-        assert!(status.success());
-        // Create a new set of test on chain data only for the on-chain input source
-        if input_source != "file" || output_source != "file" {
-            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-                .args([
-                    "setup-test-evm-data",
-                    "-D",
-                    data_path.as_str(),
-                    "-M",
-                    &model_path,
-                    "--test-data",
-                    test_on_chain_data_path.as_str(),
-                    rpc_arg.as_str(),
-                    test_input_source.as_str(),
-                    test_output_source.as_str(),
-                ])
-                .status()
-                .expect("failed to execute process");
-
-            assert!(status.success());
-
-            let deployed_addr_arg = format!("--addr={}", addr_da);
-
-            let args: Vec<&str> = vec![
-                "test-update-account-calls",
-                deployed_addr_arg.as_str(),
-                "-D",
-                test_on_chain_data_path.as_str(),
-                rpc_arg.as_str(),
-            ];
-            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-                .args(&args)
-                .status()
-                .expect("failed to execute process");
-
-            assert!(status.success());
-        }
-        // As sanity check, add example that should fail.
-        let args = vec![
-            "verify-evm",
-            "--proof-path",
-            PF_FAILURE,
-            deployed_addr_verifier_arg.as_str(),
-            deployed_addr_da_arg.as_str(),
-            rpc_arg.as_str(),
-        ];
-        let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
-            .args(args)
-            .status()
-            .expect("failed to execute process");
-        assert!(!status.success());
-    }
-
     fn build_ezkl() {
         #[cfg(feature = "icicle")]
         let args = [
@@ -2668,7 +2244,7 @@ mod native_tests {
         // not macos-metal and not icicle
         #[cfg(all(not(feature = "icicle"), not(feature = "macos-metal")))]
         let args = ["build", "--profile=test-runs", "--bin", "ezkl"];
-        #[cfg(not(feature = "mv-lookup"))]
+        #[cfg(feature = "eth-original-lookup")]
         let args = [
             "build",
             "--profile=test-runs",
@@ -2676,7 +2252,7 @@ mod native_tests {
             "ezkl",
             "--no-default-features",
             "--features",
-            "ezkl",
+            "ezkl,solidity-verifier,eth",
         ];
 
         let status = Command::new("cargo")

tests/py_integration_tests.rs

@@ -146,7 +146,7 @@ mod py_tests {
         }
     }
 
-    const TESTS: [&str; 35] = [
+    const TESTS: [&str; 31] = [
         "mnist_gan.ipynb",                         // 0
         "ezkl_demo_batch.ipynb",                   // 1
         "proof_splitting.ipynb",                   // 2
@@ -155,33 +155,29 @@ mod py_tests {
         "mnist_gan_proof_splitting.ipynb",         // 5
         "hashed_vis.ipynb",                        // 6
         "simple_demo_all_public.ipynb",            // 7
-        "data_attest.ipynb",                       // 8
-        "little_transformer.ipynb",                // 9
-        "simple_demo_aggregated_proofs.ipynb",     // 10
-        "ezkl_demo.ipynb",                         // 11
-        "lstm.ipynb",                              // 12
-        "set_membership.ipynb",                    // 13
-        "decision_tree.ipynb",                     // 14
-        "random_forest.ipynb",                     // 15
-        "gradient_boosted_trees.ipynb",            // 16
-        "xgboost.ipynb",                           // 17
-        "lightgbm.ipynb",                          // 18
-        "svm.ipynb",                               // 19
-        "simple_demo_public_input_output.ipynb",   // 20
-        "simple_demo_public_network_output.ipynb", // 21
-        "gcn.ipynb",                               // 22
-        "linear_regression.ipynb",                 // 23
-        "stacked_regression.ipynb",                // 24
-        "data_attest_hashed.ipynb",                // 25
-        "kzg_vis.ipynb",                           // 26
-        "kmeans.ipynb",                            // 27
-        "solvency.ipynb",                          // 28
-        "sklearn_mlp.ipynb",                       // 29
-        "generalized_inverse.ipynb",               // 30
-        "mnist_classifier.ipynb",                  // 31
-        "world_rotation.ipynb",                    // 32
-        "logistic_regression.ipynb",               // 33
-        "univ3-da.ipynb",                          // 34
+        "little_transformer.ipynb",                // 8
+        "simple_demo_aggregated_proofs.ipynb",     // 9
+        "ezkl_demo.ipynb",                         // 10
+        "lstm.ipynb",                              // 11
+        "set_membership.ipynb",                    // 12
+        "decision_tree.ipynb",                     // 13
+        "random_forest.ipynb",                     // 14
+        "gradient_boosted_trees.ipynb",            // 15
+        "xgboost.ipynb",                           // 16
+        "lightgbm.ipynb",                          // 17
+        "svm.ipynb",                               // 18
+        "simple_demo_public_input_output.ipynb",   // 19
+        "simple_demo_public_network_output.ipynb", // 20
+        "gcn.ipynb",                               // 21
+        "linear_regression.ipynb",                 // 22
+        "stacked_regression.ipynb",                // 23
+        "kzg_vis.ipynb",                           // 24
+        "kmeans.ipynb",                            // 25
+        "solvency.ipynb",                          // 26
+        "sklearn_mlp.ipynb",                       // 27
+        "generalized_inverse.ipynb",               // 28
+        "mnist_classifier.ipynb",                  // 29
+        "logistic_regression.ipynb",               // 30
     ];
 
     macro_rules! test_func {
@@ -194,7 +190,7 @@ mod py_tests {
             use super::*;
 
 
-            seq!(N in 0..=32 {
+            seq!(N in 0..=30 {
 
             #(#[test_case(TESTS[N])])*
             fn run_notebook_(test: &str) {
@@ -272,16 +268,6 @@ mod py_tests {
                 anvil_child.kill().unwrap();
             }
 
-            #[test]
-            fn postgres_notebook_() {
-                crate::py_tests::init_binary();
-                let test_dir: TempDir = TempDir::new("mean_postgres").unwrap();
-                let path = test_dir.path().to_str().unwrap();
-                crate::py_tests::mv_test_(path, "mean_postgres.ipynb");
-                run_notebook(path, "mean_postgres.ipynb");
-                test_dir.close().unwrap();
-            }
-
             #[test]
             fn tictactoe_autoencoder_notebook_() {
                 crate::py_tests::init_binary();

tests/python/binding_tests.py

@@ -430,7 +430,7 @@ async def test_create_evm_verifier_separate_vk():
     vk_path = os.path.join(folder_path, 'test_evm.vk')
     settings_path = os.path.join(folder_path, 'settings.json')
     sol_code_path = os.path.join(folder_path, 'test_separate.sol')
-    vk_code_path = os.path.join(folder_path, 'test_vk.sol')
+    vka_path = os.path.join(folder_path, 'vka.calldata')
     abi_path = os.path.join(folder_path, 'test_separate.abi')
     abi_vk_path = os.path.join(folder_path, 'test_vk_separate.abi')
     proof_path = os.path.join(folder_path, 'test_evm.pf')
@@ -455,9 +455,8 @@ async def test_create_evm_verifier_separate_vk():
     res = await ezkl.create_evm_vka(
         vk_path,
         settings_path,
-        vk_code_path,
-        abi_vk_path,
-        srs_path=srs_path,
+        vka_path,
+        srs_path=srs_path
     )
 
     assert res == True
@@ -472,23 +471,26 @@ async def test_deploy_evm_reusable_and_vka():
     addr_path_verifier = os.path.join(folder_path, 'address_separate.json')
     addr_path_vk = os.path.join(folder_path, 'address_vk.json')
     sol_code_path = os.path.join(folder_path, 'test_separate.sol')
-    vk_code_path = os.path.join(folder_path, 'test_vk.sol')
+    vka_path = os.path.join(folder_path, 'vka.calldata')
 
     # TODO: without optimization there will be out of gas errors
     # sol_code_path = os.path.join(folder_path, 'test.sol')
 
     res = await ezkl.deploy_evm(
         addr_path_verifier,
-        sol_code_path,
         anvil_url,
+        sol_code_path,
         "verifier/reusable",
     )
 
-    res = await ezkl.deploy_evm(
-        addr_path_vk,
-        vk_code_path,
+    with open(addr_path_verifier, 'r') as file:
+        addr_verifier = file.read().rstrip()
+
+    # TODO fix: we need to call register vka instead of deploy evm
+    res = await ezkl.register_vka(
+        addr_verifier,
         anvil_url,
-        "vka",
+        vka_path=vka_path,
     )
 
     assert res == True
@@ -506,8 +508,8 @@ async def test_deploy_evm():
 
     res = await ezkl.deploy_evm(
         addr_path,
-        sol_code_path,
         anvil_url,
+        sol_code_path,
     )
 
     assert res == True
@@ -528,8 +530,8 @@ async def test_deploy_evm_with_private_key():
 
     res = await ezkl.deploy_evm(
         addr_path,
+        anvil_url,
         sol_code_path,
-        rpc_url=anvil_url,
         private_key=anvil_default_private_key
     )
 
@@ -540,8 +542,8 @@ async def test_deploy_evm_with_private_key():
     with pytest.raises(RuntimeError, match="Failed to run deploy_evm"):
         res = await ezkl.deploy_evm(
             addr_path,
+            anvil_url,
             sol_code_path,
-            rpc_url=anvil_url,
             private_key=custom_zero_balance_private_key
         )
 
@@ -564,8 +566,8 @@ async def test_verify_evm():
 
     res = await ezkl.verify_evm(
         addr,
+        anvil_url,
         proof_path,
-        rpc_url=anvil_url,
         # sol_code_path
         # optimizer_runs
     )
@@ -579,7 +581,7 @@ async def test_verify_evm_separate_vk():
     """
     proof_path = os.path.join(folder_path, 'test_evm.pf')
     addr_path_verifier = os.path.join(folder_path, 'address_separate.json')
-    addr_path_vk = os.path.join(folder_path, 'address_vk.json')
+    vka_path = os.path.join(folder_path, 'vka.calldata')
     proof_path = os.path.join(folder_path, 'test_evm.pf')
     calldata_path = os.path.join(folder_path, 'calldata_separate.bytes')
 
@@ -588,13 +590,8 @@ async def test_verify_evm_separate_vk():
 
     print(addr_verifier)
 
-    with open(addr_path_vk, 'r') as file:
-        addr_vk = file.read().rstrip()
-
-    print(addr_vk)
-
     # res is now a vector of bytes
-    res = ezkl.encode_evm_calldata(proof_path, calldata_path, addr_vk=addr_vk)
+    res = ezkl.encode_evm_calldata(proof_path, calldata_path, vka_path=vka_path)
 
     assert os.path.isfile(calldata_path)
     assert len(res) > 0
@@ -604,9 +601,9 @@ async def test_verify_evm_separate_vk():
 
     res = await ezkl.verify_evm(
         addr_verifier,
+        anvil_url,
         proof_path,
-        rpc_url=anvil_url,
-        addr_vk=addr_vk,
+        vka_path=vka_path,
         # sol_code_path
         # optimizer_runs
     )
@@ -831,8 +828,8 @@ async def test_evm_aggregate_and_verify_aggr():
 
     res = await ezkl.deploy_evm(
         addr_path,
+        anvil_url,
         sol_code_path,
-        rpc_url=anvil_url,
     )
 
     # as a sanity check