Update rust.yml

This reverts commit 72e6c1daa2.

.github/workflows/release.yml

@@ -198,15 +198,15 @@ jobs:
 
       - name: Build release binary (no asm or metal)
         if: matrix.build != 'linux-gnu' && matrix.build != 'macos-aarch64'
-        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry
+        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry --features mimalloc
 
       - name: Build release binary (asm)
         if: matrix.build == 'linux-gnu'
-        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry --features asm
+        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry --features asm,mimalloc
 
       - name: Build release binary (metal)
         if: matrix.build == 'macos-aarch64'
-        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry --features macos-metal
+        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry --features macos-metal,mimalloc
 
       - name: Strip release binary
         if: matrix.build != 'windows-msvc' && matrix.build != 'linux-aarch64'

.github/workflows/rust.yml

@@ -24,31 +24,10 @@ 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
@@ -65,31 +44,10 @@ 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
@@ -102,31 +60,10 @@ 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
@@ -139,31 +76,10 @@ 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
@@ -179,7 +95,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,eth-original-lookup
+        run: cargo nextest run --lib --verbose --no-default-features --features ezkl
 
   # ultra-overflow-tests-gpu:
   #   runs-on: GPU
@@ -218,31 +134,10 @@ 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
@@ -260,43 +155,22 @@ 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,eth-original-lookup -- --include-ignored
+        run: cargo nextest run --release lookup_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
       - name: Matmul overflow
-        run: RUST_LOG=debug cargo nextest run --release matmul_col_ultra_overflow --no-capture --no-default-features --features ezkl,eth-original-lookup -- --include-ignored
+        run: RUST_LOG=debug cargo nextest run --release matmul_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
       - name: Conv overflow
-        run: RUST_LOG=debug cargo nextest run --release conv_col_ultra_overflow --no-capture --no-default-features --features ezkl,eth-original-lookup -- --include-ignored
+        run: RUST_LOG=debug cargo nextest run --release conv_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --include-ignored
       - name: Conv + relu overflow
-        run: cargo nextest run --release conv_relu_col_ultra_overflow --no-capture --no-default-features --features ezkl,eth-original-lookup -- --include-ignored
+        run: cargo nextest run --release conv_relu_col_ultra_overflow --no-capture --no-default-features --features ezkl -- --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
@@ -326,31 +200,10 @@ 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
@@ -367,31 +220,10 @@ 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
@@ -413,54 +245,14 @@ 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
 
-  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
@@ -524,31 +316,10 @@ 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
@@ -582,9 +353,6 @@ jobs:
       - name: Build wasm package for nodejs target.
         run: |
           wasm-pack build --target nodejs --out-dir ./in-browser-evm-verifier/nodejs . -- -Z build-std="panic_abort,std"
-      - name: Replace memory definition in nodejs
-        run: |
-          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" in-browser-evm-verifier/nodejs/ezkl.js
       - name: Build @ezkljs/verify package
         run: |
           cd in-browser-evm-verifier
@@ -664,31 +432,10 @@ 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
@@ -728,9 +475,6 @@ jobs:
       - name: Build wasm package for nodejs target.
         run: |
           wasm-pack build --target nodejs --out-dir ./tests/wasm/nodejs . -- -Z build-std="panic_abort,std"
-      - name: Replace memory definition in nodejs
-        run: |
-          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" tests/wasm/nodejs/ezkl.js
       - name: KZG prove and verify tests (public outputs + column overflow)
         run: cargo nextest run --verbose tests::kzg_prove_and_verify_with_overflow_::w
       - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
@@ -804,31 +548,10 @@ 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
@@ -866,31 +589,10 @@ 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
@@ -908,31 +610,10 @@ 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
@@ -954,31 +635,10 @@ 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
@@ -996,31 +656,10 @@ 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"
@@ -1047,31 +686,10 @@ 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"
@@ -1101,49 +719,10 @@ jobs:
     permissions:
       contents: read
     runs-on: large-self-hosted
-    services:
-      # Label used to access the service container
-      postgres:
-        # Docker Hub image
-        image: postgres
-        env:
-          POSTGRES_USER: ubuntu
-          POSTGRES_HOST_AUTH_METHOD: trust
-        # Set health checks to wait until postgres has started
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-          -v /var/run/postgresql:/var/run/postgresql
-        ports:
-          # Maps tcp port 5432 on service container to the host
-          - 5432:5432
-    env:
-      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"
@@ -1190,39 +769,16 @@ 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_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
+      # run: source .env/bin/activate; cargo nextest run py_tests::tests::reusable_
 
   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
@@ -1241,31 +797,10 @@ 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

Cargo.lock

@@ -929,7 +929,7 @@ dependencies = [
  "bitflags 2.9.0",
  "cexpr",
  "clang-sys",
- "itertools 0.11.0",
+ "itertools 0.12.1",
  "lazy_static",
  "lazycell",
  "log",
@@ -1316,7 +1316,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
 dependencies = [
  "lazy_static",
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1939,7 +1939,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -2014,6 +2014,7 @@ dependencies = [
  "indicatif",
  "instant",
  "itertools 0.10.5",
+ "jemallocator",
  "lazy_static",
  "log",
  "maybe-rayon",
@@ -2513,14 +2514,13 @@ dependencies = [
 [[package]]
 name = "halo2_solidity_verifier"
 version = "0.1.0"
-source = "git+https://github.com/zkonduit/verification-ezkl?branch=vka-hash#409f977e461b435b9afc33ed38edba09fe2eaee4"
+source = "git+https://github.com/alexander-camuto/halo2-solidity-verifier#3d237d566ca6714c9ee6fcf3f2dcefffa79f914c"
 dependencies = [
  "askama",
  "blake2b_simd",
  "halo2_proofs",
  "hex",
  "itertools 0.11.0",
- "regex",
  "ruint",
  "sha3 0.10.8",
 ]
@@ -3202,7 +3202,7 @@ checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
 dependencies = [
  "hermit-abi 0.5.0",
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -3262,6 +3262,26 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
+[[package]]
+name = "jemalloc-sys"
+version = "0.5.4+5.3.0-patched"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac6c1946e1cea1788cbfde01c993b52a10e2da07f4bac608228d1bed20bfebf2"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "jemallocator"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0de374a9f8e63150e6f5e8a60cc14c668226d7a347d8aee1a45766e3c4dd3bc"
+dependencies = [
+ "jemalloc-sys",
+ "libc",
+]
+
 [[package]]
 name = "jiff"
 version = "0.2.10"
@@ -3396,7 +3416,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
 dependencies = [
  "cfg-if",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -4603,7 +4623,7 @@ dependencies = [
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -5085,7 +5105,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.4.15",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -5098,7 +5118,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.9.4",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -5802,7 +5822,7 @@ dependencies = [
  "getrandom 0.3.2",
  "once_cell",
  "rustix 1.0.5",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -6931,7 +6951,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]

Cargo.toml

@@ -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/zkonduit/verification-ezkl", branch = "vka-hash", optional = true }
+halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier", optional = true }
 maybe-rayon = { version = "0.1.1", default-features = false }
 bincode = { version = "1.3.3", default-features = false }
 unzip-n = "0.1.2"
@@ -88,9 +88,9 @@ pyo3-log = { version = "0.12.0", default-features = false, optional = true }
 tract-onnx = { git = "https://github.com/sonos/tract/", rev = "37132e0397d0a73e5bd3a8615d932dabe44f6736", default-features = false, optional = true }
 tabled = { version = "0.12.0", optional = true }
 objc = { version = "0.2.4", optional = true }
-mimalloc = { version = "0.1", optional = true }
 pyo3-stub-gen = { version = "0.6.0", optional = true }
-
+jemallocator = { version = "0.5", optional = true }
+mimalloc = { version = "0.1", optional = true }
 # universal bindings
 uniffi = { version = "=0.28.0", optional = true }
 getrandom = { version = "0.2.8", optional = true }
@@ -217,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 = ["eth-mv-lookup", "precompute-coset", "parallel-poly-read", "uniffi"]
+ios-bindings = ["mv-lookup", "precompute-coset", "parallel-poly-read", "uniffi"]
 ios-bindings-test = ["ios-bindings", "uniffi/bindgen-tests"]
 ezkl = [
     "onnx",
@@ -234,6 +234,8 @@ ezkl = [
     "tabled/color",
     "serde_json/std",
     "colored_json",
+    "dep:alloy",
+    "dep:foundry-compilers",
     "dep:ethabi",
     "dep:indicatif",
     "dep:gag",
@@ -241,34 +243,14 @@ ezkl = [
     "dep:lazy_static",
     "dep:tokio",
     "dep:openssl",
-    "dep:mimalloc",
     "dep:chrono",
     "dep:sha256",
     "dep:clap_complete",
+    "dep:halo2_solidity_verifier",
     "dep:semver",
     "dep:clap",
     "dep:tosubcommand",
 ]
-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",
@@ -276,6 +258,7 @@ 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"]
@@ -286,12 +269,15 @@ no-banner = []
 no-update = []
 macos-metal = ["halo2_proofs/macos"]
 ios-metal = ["halo2_proofs/ios"]
+jemalloc = ["dep:jemallocator"]
+mimalloc = ["dep:mimalloc"]
 
 
 [patch.crates-io]
 uniffi_testing = { git = "https://github.com/ElusAegis/uniffi-rs", branch = "feat/testing-feature-build-fix" }
 
 [profile.release]
+# debug = true
 rustflags = ["-C", "relocation-model=pic"]
 lto = "fat"
 codegen-units = 1

benches/accum_conv.rs

@@ -68,7 +68,7 @@ impl Circuit<Fr> for MyCircuit {
                 config
                     .layout(
                         &mut region,
-                        &[self.image.clone(), self.kernel.clone(), self.bias.clone()],
+                        &[&self.image, &self.kernel, &self.bias],
                         Box::new(PolyOp::Conv {
                             padding: vec![(0, 0)],
                             stride: vec![1; 2],

benches/accum_dot.rs

@@ -15,6 +15,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use rand::rngs::OsRng;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
@@ -59,7 +60,7 @@ impl Circuit<Fr> for MyCircuit {
                 config
                     .layout(
                         &mut region,
-                        &self.inputs,
+                        &self.inputs.iter().collect_vec(),
                         Box::new(PolyOp::Einsum {
                             equation: "i,i->".to_string(),
                         }),

benches/accum_einsum_matmul.rs

@@ -15,6 +15,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use rand::rngs::OsRng;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
@@ -61,7 +62,7 @@ impl Circuit<Fr> for MyCircuit {
                 config
                     .layout(
                         &mut region,
-                        &self.inputs,
+                        &self.inputs.iter().collect_vec(),
                         Box::new(PolyOp::Einsum {
                             equation: "ab,bc->ac".to_string(),
                         }),

benches/accum_matmul_sigmoid.rs

@@ -17,6 +17,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
 
@@ -86,13 +87,13 @@ impl Circuit<Fr> for MyCircuit {
                 let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 let output = config
                     .base_config
-                    .layout(&mut region, &self.inputs, Box::new(op))
+                    .layout(&mut region, &self.inputs.iter().collect_vec(), Box::new(op))
                     .unwrap();
                 let _output = config
                     .base_config
                     .layout(
                         &mut region,
-                        &[output.unwrap()],
+                        &[&output.unwrap()],
                         Box::new(LookupOp::Sigmoid { scale: 1.0.into() }),
                     )
                     .unwrap();

benches/accum_matmul_sigmoid_overflow.rs

@@ -17,6 +17,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
 
@@ -87,13 +88,13 @@ impl Circuit<Fr> for MyCircuit {
                 let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 let output = config
                     .base_config
-                    .layout(&mut region, &self.inputs, Box::new(op))
+                    .layout(&mut region, &self.inputs.iter().collect_vec(), Box::new(op))
                     .unwrap();
                 let _output = config
                     .base_config
                     .layout(
                         &mut region,
-                        &[output.unwrap()],
+                        &[&output.unwrap()],
                         Box::new(LookupOp::Sigmoid { scale: 1.0.into() }),
                     )
                     .unwrap();

benches/accum_sum.rs

@@ -15,6 +15,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use rand::rngs::OsRng;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
@@ -59,7 +60,7 @@ impl Circuit<Fr> for MyCircuit {
                 config
                     .layout(
                         &mut region,
-                        &self.inputs,
+                        &self.inputs.iter().collect_vec(),
                         Box::new(PolyOp::Sum { axes: vec![0] }),
                     )
                     .unwrap();

benches/accum_sumpool.rs

@@ -63,7 +63,7 @@ impl Circuit<Fr> for MyCircuit {
                 config
                     .layout(
                         &mut region,
-                        &[self.image.clone()],
+                        &[&self.image],
                         Box::new(HybridOp::SumPool {
                             padding: vec![(0, 0); 2],
                             stride: vec![1, 1],

benches/pairwise_add.rs

@@ -15,6 +15,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use rand::rngs::OsRng;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
@@ -57,7 +58,11 @@ impl Circuit<Fr> for MyCircuit {
             |region| {
                 let mut region = region::RegionCtx::new(region, 0, 1, 1024, 2);
                 config
-                    .layout(&mut region, &self.inputs, Box::new(PolyOp::Add))
+                    .layout(
+                        &mut region,
+                        &self.inputs.iter().collect_vec(),
+                        Box::new(PolyOp::Add),
+                    )
                     .unwrap();
                 Ok(())
             },

benches/pairwise_pow.rs

@@ -16,6 +16,7 @@ use halo2_proofs::{
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
+use itertools::Itertools;
 use rand::rngs::OsRng;
 use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
@@ -58,7 +59,11 @@ impl Circuit<Fr> for MyCircuit {
             |region| {
                 let mut region = RegionCtx::new(region, 0, 1, 1024, 2);
                 config
-                    .layout(&mut region, &self.inputs, Box::new(PolyOp::Pow(4)))
+                    .layout(
+                        &mut region,
+                        &self.inputs.iter().collect_vec(),
+                        Box::new(PolyOp::Pow(4)),
+                    )
                     .unwrap();
                 Ok(())
             },

benches/relu_lookupless.rs

@@ -70,7 +70,7 @@ impl Circuit<Fr> for NLCircuit {
                 config
                     .layout(
                         &mut region,
-                        &[self.input.clone()],
+                        &[&self.input],
                         Box::new(PolyOp::LeakyReLU {
                             slope: 0.0.into(),
                             scale: 1,

benches/sigmoid.rs

@@ -67,7 +67,7 @@ impl Circuit<Fr> for NLCircuit {
                 config
                     .layout(
                         &mut region,
-                        &[self.input.clone()],
+                        &[&self.input],
                         Box::new(LookupOp::Sigmoid { scale: 1.0.into() }),
                     )
                     .unwrap();

examples/conv2d_mnist/main.rs

@@ -32,7 +32,6 @@ use mnist::*;
 use rand::rngs::OsRng;
 use std::marker::PhantomData;
 
-
 mod params;
 
 const K: usize = 20;
@@ -216,11 +215,7 @@ where
                         .layer_config
                         .layout(
                             &mut region,
-                            &[
-                                self.input.clone(),
-                                self.l0_params[0].clone(),
-                                self.l0_params[1].clone(),
-                            ],
+                            &[&self.input, &self.l0_params[0], &self.l0_params[1]],
                             Box::new(op),
                         )
                         .unwrap();
@@ -229,7 +224,7 @@ where
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x.unwrap()],
+                            &[&x.unwrap()],
                             Box::new(PolyOp::LeakyReLU {
                                 slope: 0.0.into(),
                                 scale: 1,
@@ -241,7 +236,7 @@ where
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x.unwrap()],
+                            &[&x.unwrap()],
                             Box::new(LookupOp::Div { denom: 32.0.into() }),
                         )
                         .unwrap()
@@ -253,7 +248,7 @@ where
                         .layer_config
                         .layout(
                             &mut region,
-                            &[self.l2_params[0].clone(), x],
+                            &[&self.l2_params[0], &x],
                             Box::new(PolyOp::Einsum {
                                 equation: "ij,j->ik".to_string(),
                             }),
@@ -265,7 +260,7 @@ where
                         .layer_config
                         .layout(
                             &mut region,
-                            &[x, self.l2_params[1].clone()],
+                            &[&x, &self.l2_params[1]],
                             Box::new(PolyOp::Add),
                         )
                         .unwrap()

examples/mlp_4d_einsum.rs

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

examples/notebooks/data_attest.ipynb

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

examples/notebooks/data_attest_hashed.ipynb

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

examples/notebooks/data_attest_kzg_vis.ipynb

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

examples/notebooks/univ3-da.ipynb

@@ -0,0 +1,685 @@
+{
+    "cells": [
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "# univ3-da-ezkl\n",
+                "\n",
+                "Here's an example leveraging EZKL whereby the inputs to the model are read and attested to from an on-chain source. For this setup we make a single call to a view function that returns an array of UniV3 historical TWAP price data that we will attest to on-chain. \n"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "First we import the necessary dependencies and set up logging to be as informative as possible. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# check if notebook is in colab\n",
+                "try:\n",
+                "    # install ezkl\n",
+                "    import google.colab\n",
+                "    import subprocess\n",
+                "    import sys\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
+                "\n",
+                "# rely on local installation of ezkl if the notebook is not in colab\n",
+                "except:\n",
+                "    pass\n",
+                "\n",
+                "\n",
+                "from torch import nn\n",
+                "import ezkl\n",
+                "import os\n",
+                "import json\n",
+                "import logging\n",
+                "\n",
+                "# uncomment for more descriptive logging \n",
+                "FORMAT = '%(levelname)s %(name)s %(asctime)-15s %(filename)s:%(lineno)d %(message)s'\n",
+                "logging.basicConfig(format=FORMAT)\n",
+                "logging.getLogger().setLevel(logging.DEBUG)\n"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Now we define our model. It is a very simple PyTorch model that has just one layer, an average pooling 2D layer. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import torch\n",
+                "# Defines the model\n",
+                "\n",
+                "class MyModel(nn.Module):\n",
+                "    def __init__(self):\n",
+                "        super(MyModel, self).__init__()\n",
+                "        self.layer = nn.AvgPool2d(2, 1, (1, 1))\n",
+                "\n",
+                "    def forward(self, x):\n",
+                "        return self.layer(x)[0]\n",
+                "\n",
+                "\n",
+                "circuit = MyModel()\n",
+                "\n",
+                "# this is where you'd train your model"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "We omit training for purposes of this demonstration. We've marked where training would happen in the cell above. \n",
+                "Now we export the model to onnx and create a corresponding (randomly generated) input. This input data will eventually be stored on chain and read from according to the call_data field in the graph input.\n",
+                "\n",
+                "You can replace the random `x` with real data if you so wish. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 3,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "x = 0.1*torch.rand(1,*[3, 2, 2], requires_grad=True)\n",
+                "\n",
+                "# Flips the neural net into inference mode\n",
+                "circuit.eval()\n",
+                "\n",
+                "    # Export the model\n",
+                "torch.onnx.export(circuit,               # model being run\n",
+                "                      x,                   # model input (or a tuple for multiple inputs)\n",
+                "                      \"network.onnx\",            # where to save the model (can be a file or file-like object)\n",
+                "                      export_params=True,        # store the trained parameter weights inside the model file\n",
+                "                      opset_version=10,          # the ONNX version to export the model to\n",
+                "                      do_constant_folding=True,  # whether to execute constant folding for optimization\n",
+                "                      input_names = ['input'],   # the model's input names\n",
+                "                      output_names = ['output'], # the model's output names\n",
+                "                      dynamic_axes={'input' : {0 : 'batch_size'},    # variable length axes\n",
+                "                                    'output' : {0 : 'batch_size'}})\n",
+                "\n",
+                "data_array = ((x).detach().numpy()).reshape([-1]).tolist()\n",
+                "\n",
+                "data = dict(input_data = [data_array])\n",
+                "\n",
+                "    # Serialize data into file:\n",
+                "json.dump(data, open(\"input.json\", 'w' ))\n",
+                "\n"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "We now define a function that will create a new anvil instance which we will deploy our test contract too. This contract will contain in its storage the data that we will read from and attest to. In production you would not need to set up a local anvil instance. Instead you would replace RPC_URL with the actual RPC endpoint of the chain you are deploying your verifiers too, reading from the data on said chain."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 4,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import subprocess\n",
+                "import time\n",
+                "import threading\n",
+                "\n",
+                "# make sure anvil is running locally\n",
+                "# $ anvil -p 3030\n",
+                "\n",
+                "RPC_URL = \"http://localhost:3030\"\n",
+                "\n",
+                "# Save process globally\n",
+                "anvil_process = None\n",
+                "\n",
+                "def start_anvil():\n",
+                "    global anvil_process\n",
+                "    if anvil_process is None:\n",
+                "        anvil_process = subprocess.Popen([\"anvil\", \"-p\", \"3030\", \"--fork-url\", \"https://arb1.arbitrum.io/rpc\", \"--code-size-limit=41943040\"])\n",
+                "        if anvil_process.returncode is not None:\n",
+                "            raise Exception(\"failed to start anvil process\")\n",
+                "        time.sleep(3)\n",
+                "\n",
+                "def stop_anvil():\n",
+                "    global anvil_process\n",
+                "    if anvil_process is not None:\n",
+                "        anvil_process.terminate()\n",
+                "        anvil_process = None\n"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "We define our `PyRunArgs` objects which contains the visibility parameters for out model. \n",
+                "- `input_visibility` defines the visibility of the model inputs\n",
+                "- `param_visibility` defines the visibility of the model weights and constants and parameters \n",
+                "- `output_visibility` defines the visibility of the model outputs\n",
+                "\n",
+                "Here we create the following setup:\n",
+                "- `input_visibility`: \"public\"\n",
+                "- `param_visibility`: \"private\"\n",
+                "- `output_visibility`: public\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import ezkl\n",
+                "\n",
+                "model_path = os.path.join('network.onnx')\n",
+                "compiled_model_path = os.path.join('network.compiled')\n",
+                "pk_path = os.path.join('test.pk')\n",
+                "vk_path = os.path.join('test.vk')\n",
+                "settings_path = os.path.join('settings.json')\n",
+                "srs_path = os.path.join('kzg.srs')\n",
+                "data_path = os.path.join('input.json')\n",
+                "\n",
+                "run_args = ezkl.PyRunArgs()\n",
+                "run_args.input_visibility = \"public\"\n",
+                "run_args.param_visibility = \"private\"\n",
+                "run_args.output_visibility = \"public\"\n",
+                "run_args.decomp_legs=5\n",
+                "run_args.num_inner_cols = 1\n",
+                "run_args.variables = [(\"batch_size\", 1)]"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Now we generate a settings file. This file basically instantiates a bunch of parameters that determine their circuit shape, size etc... Because of the way we represent nonlinearities in the circuit (using Halo2's [lookup tables](https://zcash.github.io/halo2/design/proving-system/lookup.html)), it is often best to _calibrate_ this settings file as some data can fall out of range of these lookups.\n",
+                "\n",
+                "You can pass a dataset for calibration that will be representative of real inputs you might find if and when you deploy the prover. Here we create a dummy calibration dataset for demonstration purposes. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# TODO: Dictionary outputs\n",
+                "res = ezkl.gen_settings(model_path, settings_path, py_run_args=run_args)\n",
+                "assert res == True"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# generate a bunch of dummy calibration data\n",
+                "cal_data = {\n",
+                "    \"input_data\": [(0.1*torch.rand(2, *[3, 2, 2])).flatten().tolist()],\n",
+                "}\n",
+                "\n",
+                "cal_path = os.path.join('val_data.json')\n",
+                "# save as json file\n",
+                "with open(cal_path, \"w\") as f:\n",
+                "    json.dump(cal_data, f)\n",
+                "\n",
+                "res = await ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
+                "assert res == True"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "The graph input for on chain data sources is formatted completely differently compared to file based data sources.\n",
+                "\n",
+                "- For file data sources, the raw floating point values that eventually get quantized, converted into field elements and stored in `witness.json` to be consumed by the circuit are stored. The output data contains the expected floating point values returned as outputs from running your vanilla pytorch model on the given inputs.\n",
+                "- For on chain data sources, the input_data field contains all the data necessary to read and format the on chain data into something digestable by EZKL (aka field elements :-D). \n",
+                "Here is what the schema for an on-chain data source graph input file should look like for a single call data source:\n",
+                "    \n",
+                "```json\n",
+                "{\n",
+                "    \"input_data\": {\n",
+                "        \"rpc\": \"http://localhost:3030\", // The rpc endpoint of the chain you are deploying your verifier to\n",
+                "        \"call\": {\n",
+                "            \"call_data\": \"1f3be514000000000000000000000000c6962004f452be9203591991d15f6b388e09e8d00000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000\", // The abi encoded call data to a view function that returns an array of on-chain data points we are attesting to. \n",
+                "            \"decimals\": 0, // The number of decimal places of the large uint256 value. This is our way of representing large wei values as floating points on chain, since the evm only natively supports integer values.\n",
+                "            \"address\": \"9A213F53334279C128C37DA962E5472eCD90554f\", // The address of the contract that we are calling to get the data. \n",
+                "            \"len\": 12 // The number of data points returned by the view function (the length of the array)\n",
+                "        }\n",
+                "    }\n",
+                "}\n",
+                "```"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "from web3 import Web3, HTTPProvider\n",
+                "from solcx import compile_standard\n",
+                "from decimal import Decimal\n",
+                "import json\n",
+                "import os\n",
+                "import torch\n",
+                "import requests\n",
+                "\n",
+                "def count_decimal_places(num):\n",
+                "    num_str = str(num)\n",
+                "    if '.' in num_str:\n",
+                "        return len(num_str) - 1 - num_str.index('.')\n",
+                "    else:\n",
+                "        return 0\n",
+                "\n",
+                "w3 = Web3(HTTPProvider(RPC_URL)) \n",
+                "\n",
+                "def on_chain_data(tensor):\n",
+                "    data = tensor.view(-1).tolist()\n",
+                "    secondsAgo = [len(data) - 1 - i for i in range(len(data))]\n",
+                "\n",
+                "    contract_source_code = '''\n",
+                "    // SPDX-License-Identifier: MIT\n",
+                "    pragma solidity ^0.8.20;\n",
+                "\n",
+                "    interface IUniswapV3PoolDerivedState {\n",
+                "        function observe(\n",
+                "            uint32[] calldata secondsAgos\n",
+                "        ) external view returns (\n",
+                "            int56[] memory tickCumulatives,\n",
+                "            uint160[] memory secondsPerLiquidityCumulativeX128s\n",
+                "        );\n",
+                "    }\n",
+                "\n",
+                "    contract UniTickAttestor {\n",
+                "        int256[] private cachedTicks;\n",
+                "\n",
+                "        function consult(\n",
+                "            IUniswapV3PoolDerivedState pool,\n",
+                "            uint32[] memory secondsAgo\n",
+                "        ) public view returns (int256[] memory tickCumulatives) {\n",
+                "            tickCumulatives = new int256[](secondsAgo.length);\n",
+                "            (int56[] memory _ticks,) = pool.observe(secondsAgo);\n",
+                "            for (uint256 i = 0; i < secondsAgo.length; i++) {\n",
+                "                tickCumulatives[i] = int256(_ticks[i]);\n",
+                "            }\n",
+                "        }\n",
+                "\n",
+                "        function cache_price(\n",
+                "            IUniswapV3PoolDerivedState pool,\n",
+                "            uint32[] memory secondsAgo\n",
+                "        ) public {\n",
+                "            (int56[] memory _ticks,) = pool.observe(secondsAgo);\n",
+                "            cachedTicks = new int256[](_ticks.length);\n",
+                "            for (uint256 i = 0; i < _ticks.length; i++) {\n",
+                "                cachedTicks[i] = int256(_ticks[i]);\n",
+                "            }\n",
+                "        }\n",
+                "\n",
+                "        function readPriceCache() public view returns (int256[] memory) {\n",
+                "            return cachedTicks;\n",
+                "        }\n",
+                "    }\n",
+                "    '''\n",
+                "\n",
+                "    compiled_sol = compile_standard({\n",
+                "        \"language\": \"Solidity\",\n",
+                "        \"sources\": {\"UniTickAttestor.sol\": {\"content\": contract_source_code}},\n",
+                "        \"settings\": {\"outputSelection\": {\"*\": {\"*\": [\"metadata\", \"evm.bytecode\", \"abi\"]}}}\n",
+                "    })\n",
+                "\n",
+                "    bytecode = compiled_sol['contracts']['UniTickAttestor.sol']['UniTickAttestor']['evm']['bytecode']['object']\n",
+                "    abi = json.loads(compiled_sol['contracts']['UniTickAttestor.sol']['UniTickAttestor']['metadata'])['output']['abi']\n",
+                "\n",
+                "    # Deploy contract\n",
+                "    UniTickAttestor = w3.eth.contract(abi=abi, bytecode=bytecode)\n",
+                "    tx_hash = UniTickAttestor.constructor().transact()\n",
+                "    tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)\n",
+                "    contract = w3.eth.contract(address=tx_receipt['contractAddress'], abi=abi)\n",
+                "\n",
+                "    # Step 4: Store data via cache_price transaction\n",
+                "    tx_hash = contract.functions.cache_price(\n",
+                "        \"0xC6962004f452bE9203591991D15f6b388e09E8D0\",\n",
+                "        secondsAgo\n",
+                "    ).transact()\n",
+                "    tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)\n",
+                "\n",
+                "    # Step 5: Prepare calldata for readPriceCache\n",
+                "    call = contract.functions.readPriceCache().build_transaction()\n",
+                "    calldata = call['data'][2:]\n",
+                "\n",
+                "    # Get stored data\n",
+                "    result = contract.functions.readPriceCache().call()\n",
+                "    print(f'Cached ticks: {result}')\n",
+                "\n",
+                "    decimals = [0] * len(data)\n",
+                "\n",
+                "    call_to_account = {\n",
+                "        'call_data': calldata,\n",
+                "        'decimals': decimals,\n",
+                "        'address': contract.address[2:],\n",
+                "    }\n",
+                "\n",
+                "    return call_to_account\n",
+                "\n",
+                "start_anvil()\n",
+                "call_to_account = on_chain_data(x)\n",
+                "\n",
+                "data = dict(input_data =  {'rpc': RPC_URL, 'call': call_to_account })\n",
+                "json.dump(data, open(\"input.json\", 'w'))"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "As we use Halo2 with KZG-commitments we need an SRS string from (preferably) a multi-party trusted setup ceremony. For an overview of the procedures for such a ceremony check out [this page](https://blog.ethereum.org/2023/01/16/announcing-kzg-ceremony). The `get_srs` command retrieves a correctly sized SRS given the calibrated settings file from [here](https://github.com/han0110/halo2-kzg-srs). \n",
+                "\n",
+                "These SRS were generated with [this](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) ceremony. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "res = await ezkl.get_srs( settings_path)"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "We now need to generate the circuit witness. These are the model outputs (and any hashes) that are generated when feeding the previously generated `input.json` through the circuit / model. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# !export RUST_BACKTRACE=1\n",
+                "\n",
+                "witness_path = \"witness.json\"\n",
+                "\n",
+                "res = await ezkl.gen_witness(data_path, compiled_model_path, witness_path)"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Here we setup verifying and proving keys for the circuit. As the name suggests the proving key is needed for ... proving and the verifying key is needed for ... verifying. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# HERE WE SETUP THE CIRCUIT PARAMS\n",
+                "# WE GOT KEYS\n",
+                "# WE GOT CIRCUIT PARAMETERS\n",
+                "# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
+                "res = ezkl.setup(\n",
+                "        compiled_model_path,\n",
+                "        vk_path,\n",
+                "        pk_path,\n",
+                "    )\n",
+                "\n",
+                "assert res == True\n",
+                "assert os.path.isfile(vk_path)\n",
+                "assert os.path.isfile(pk_path)\n",
+                "assert os.path.isfile(settings_path)"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Now we generate a full proof. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# GENERATE A PROOF\n",
+                "\n",
+                "proof_path = os.path.join('test.pf')\n",
+                "\n",
+                "res = ezkl.prove(\n",
+                "        witness_path,\n",
+                "        compiled_model_path,\n",
+                "        pk_path,\n",
+                "        proof_path,\n",
+                "        \"single\",\n",
+                "    )\n",
+                "\n",
+                "print(res)\n",
+                "assert os.path.isfile(proof_path)"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "And verify it as a sanity check. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# VERIFY IT\n",
+                "\n",
+                "res = ezkl.verify(\n",
+                "        proof_path,\n",
+                "        settings_path,\n",
+                "        vk_path,\n",
+                "    )\n",
+                "\n",
+                "assert res == True\n",
+                "print(\"verified\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "We can now create and then deploy a vanilla evm verifier."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "abi_path = 'test.abi'\n",
+                "sol_code_path = 'test.sol'\n",
+                "\n",
+                "res = await ezkl.create_evm_verifier(\n",
+                "        vk_path,\n",
+                "        settings_path,\n",
+                "        sol_code_path,\n",
+                "        abi_path,\n",
+                "    )\n",
+                "assert res == True"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import json\n",
+                "\n",
+                "addr_path_verifier = \"addr_verifier.txt\"\n",
+                "\n",
+                "res = await ezkl.deploy_evm(\n",
+                "    addr_path_verifier,\n",
+                "    'http://127.0.0.1:3030',\n",
+                "    sol_code_path,\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",
+                "        RPC_URL,\n",
+                "        settings_path,\n",
+                "        sol_code_path,\n",
+                "    )\n"
+            ]
+        },
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Here we need to regenerate the witness, prove and then verify all within the same cell. This is because we want to reduce the amount of latency between reading on-chain state and verifying it on-chain. This is because the attest input values read from the oracle are time sensitive (their values are derived from computing on block.timestamp) and can change between the time of reading and the time of verifying.\n",
+                "\n",
+                "Call the view only verify method on the contract to verify the proof. Since it is a view function this is safe to use in production since you don't have to pass your private key."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# !export RUST_BACKTRACE=1\n",
+                "\n",
+                "# print(res)\n",
+                "assert os.path.isfile(proof_path)\n",
+                "# read the verifier address\n",
+                "addr_verifier = None\n",
+                "with open(addr_path_verifier, 'r') as f:\n",
+                "    addr = f.read()\n",
+                "#read the data attestation address\n",
+                "addr_da = None\n",
+                "with open(addr_path_da, 'r') as f:\n",
+                "    addr_da = f.read()\n",
+                "\n",
+                "res = await ezkl.verify_evm(\n",
+                "    addr,\n",
+                "    RPC_URL,\n",
+                "    proof_path,\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/world_rotation.ipynb

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

ezkl.pyi

@@ -160,6 +160,30 @@ 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
@@ -223,7 +247,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,vka_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,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:
     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.
@@ -236,8 +260,8 @@ def create_evm_vka(vk_path:str | os.PathLike | pathlib.Path,settings_path:str |
     settings_path: str
         The path to the settings file
     
-    vka_path: str
-        The path to the create the vka calldata.
+    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
@@ -251,6 +275,12 @@ 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
@@ -676,6 +706,35 @@ def setup_aggregate(sample_snarks:typing.Sequence[str | os.PathLike | pathlib.Pa
     """
     ...
 
+def setup_test_evm_data(data_path:str | os.PathLike | pathlib.Path,compiled_circuit_path:str | os.PathLike | pathlib.Path,test_data:str | os.PathLike | pathlib.Path,input_source:PyTestDataSource,output_source:PyTestDataSource,rpc_url:typing.Optional[str]) -> typing.Any:
+    r"""
+    Setup test evm data
+    
+    Arguments
+    ---------
+    data_path: str
+        The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
+    
+    compiled_circuit_path: str
+        The path to the compiled model file (generated using the compile-circuit command)
+    
+    test_data: str
+        For testing purposes only. The optional path to the .json data file that will be generated that contains the OnChain data storage information derived from the file information in the data .json file. Should include both the network input (possibly private) and the network output (public input to the proof)
+    
+    input_sources: str
+        Where the input data comes from
+    
+    output_source: str
+        Where the output data comes from
+    
+    rpc_url: str
+        RPC URL for an EVM compatible node, if None, uses Anvil as a local RPC node
+    
+    Returns
+    -------
+    bool
+    """
+    ...
 
 def swap_proof_commitments(proof_path:str | os.PathLike | pathlib.Path,witness_path:str | os.PathLike | pathlib.Path) -> None:
     r"""
@@ -764,7 +823,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],vka_path:typing.Optional[str]) -> typing.Any:
+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:
     r"""
     verifies an evm compatible proof, you will need solc installed in your environment to run this
     
@@ -779,8 +838,11 @@ 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
     
-    vka_path: str
-        The path to the VKA calldata bytes file (generated using the create_evm_vka command)
+    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)
     Returns
     -------
     bool

src/bin/ezkl.rs

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

src/bindings/python.rs

@@ -1040,22 +1040,25 @@ fn calibrate_settings(
     scale_rebase_multiplier: Vec<u32>,
     max_logrows: Option<u32>,
 ) -> PyResult<Bound<'_, PyAny>> {
-    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)
-    })?;
+    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)
+        })?;
 
-    Ok(true)
+        Ok(true)
+    })
 }
 
 /// Runs the forward pass operation to generate a witness
@@ -1098,12 +1101,15 @@ fn gen_witness(
     vk_path: Option<PathBuf>,
     srs_path: Option<PathBuf>,
 ) -> PyResult<Bound<'_, PyAny>> {
-    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)))
+    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)))
+    })
 }
 
 /// Mocks the prover
@@ -1601,15 +1607,22 @@ fn verify_aggr(
 #[pyfunction(signature = (
     proof=PathBuf::from(DEFAULT_PROOF),
     calldata=PathBuf::from(DEFAULT_CALLDATA),
-    vka_path=None,
+    addr_vk=None,
 ))]
 #[gen_stub_pyfunction]
 fn encode_evm_calldata<'a>(
     proof: PathBuf,
     calldata: PathBuf,
-    vka_path: Option<PathBuf>,
+    addr_vk: Option<&'a str>,
 ) -> Result<Vec<u8>, PyErr> {
-    crate::execute::encode_evm_calldata(proof, calldata, vka_path).map_err(|e| {
+    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| {
         let err_str = format!("Failed to generate calldata: {}", e);
         PyRuntimeError::new_err(err_str)
     })
@@ -1689,15 +1702,15 @@ fn create_evm_verifier(
 /// settings_path: str
 ///     The path to the settings file
 ///
-/// vka_path: str
-///     The path to the verification artifact calldata bytes 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
 ///
 /// 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
@@ -1705,21 +1718,21 @@ fn create_evm_verifier(
 #[pyfunction(signature = (
     vk_path=PathBuf::from(DEFAULT_VK),
     settings_path=PathBuf::from(DEFAULT_SETTINGS),
-    vka_path=PathBuf::from(DEFAULT_VKA),
-    srs_path=None,
-    decimals=DEFAULT_DECIMALS.parse().unwrap(),
+    sol_code_path=PathBuf::from(DEFAULT_VK_SOL),
+    abi_path=PathBuf::from(DEFAULT_VERIFIER_ABI),
+    srs_path=None
 ))]
 #[gen_stub_pyfunction]
 fn create_evm_vka(
     py: Python,
     vk_path: PathBuf,
     settings_path: PathBuf,
-    vka_path: PathBuf,
+    sol_code_path: PathBuf,
+    abi_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, vka_path, decimals)
+        crate::execute::create_evm_vka(vk_path, srs_path, settings_path, sol_code_path, abi_path)
             .await
             .map_err(|e| {
                 let err_str = format!("Failed to run create_evm_verifier: {}", e);
@@ -1730,7 +1743,124 @@ fn create_evm_vka(
     })
 }
 
-/// Deploys the solidity verifier
+/// 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,
+))]
+#[gen_stub_pyfunction]
+fn setup_test_evm_data(
+    py: Python,
+    data_path: String,
+    compiled_circuit_path: PathBuf,
+    test_data: PathBuf,
+    input_source: PyTestDataSource,
+    output_source: PyTestDataSource,
+    rpc_url: String,
+) -> PyResult<Bound<'_, PyAny>> {
+    pyo3_async_runtimes::tokio::future_into_py(py, async move {
+        crate::execute::setup_test_evm_data(
+            data_path,
+            compiled_circuit_path,
+            test_data,
+            rpc_url,
+            input_source.into(),
+            output_source.into(),
+        )
+        .await
+        .map_err(|e| {
+            let err_str = format!("Failed to run setup_test_evm_data: {}", e);
+            PyRuntimeError::new_err(err_str)
+        })?;
+
+        Ok(true)
+    })
+}
+
+/// deploys the solidity verifier
 #[pyfunction(signature = (
     addr_path,
     rpc_url,
@@ -1768,64 +1898,46 @@ fn deploy_evm(
     })
 }
 
-/// 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
-///
+/// deploys the solidity da verifier
 #[pyfunction(signature = (
-    addr_verifier,
+    addr_path,
+    input_data,
     rpc_url,
-    vka_path=PathBuf::from(DEFAULT_VKA),
-    vka_digest_path=PathBuf::from(DEFAULT_VKA_DIGEST),
-    private_key=None,
+    settings_path=PathBuf::from(DEFAULT_SETTINGS),
+    sol_code_path=PathBuf::from(DEFAULT_SOL_CODE_DA),
+    optimizer_runs=DEFAULT_OPTIMIZER_RUNS.parse().unwrap(),
+    private_key=None
 ))]
 #[gen_stub_pyfunction]
-fn register_vka<'a>(
-    py: Python<'a>,
-    addr_verifier: &'a str,
+fn deploy_da_evm(
+    py: Python,
+    addr_path: PathBuf,
+    input_data: String,
     rpc_url: String,
-    vka_path: PathBuf,
-    vka_digest_path: PathBuf,
+    settings_path: PathBuf,
+    sol_code_path: PathBuf,
+    optimizer_runs: usize,
     private_key: Option<String>,
-) -> PyResult<Bound<'a, PyAny>> {
-    let addr_verifier = H160Flag::from(addr_verifier);
+) -> PyResult<Bound<'_, PyAny>> {
     pyo3_async_runtimes::tokio::future_into_py(py, async move {
-        crate::execute::register_vka(
+        crate::execute::deploy_da_evm(
+            input_data,
+            settings_path,
+            sol_code_path,
             rpc_url,
-            addr_verifier,
-            vka_path,
-            vka_digest_path,
+            addr_path,
+            optimizer_runs,
             private_key,
         )
         .await
         .map_err(|e| {
-            let err_str = format!("Failed to run register_vka: {}", e);
+            let err_str = format!("Failed to run deploy_da_evm: {}", 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
@@ -1839,8 +1951,11 @@ fn register_vka<'a>(
 /// 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)
+/// 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)
 /// Returns
 /// -------
 /// bool
@@ -1849,7 +1964,8 @@ fn register_vka<'a>(
     addr_verifier,
     rpc_url,
     proof_path=PathBuf::from(DEFAULT_PROOF),
-    vka_path = None,
+    addr_da = None,
+    addr_vk = None,
 ))]
 #[gen_stub_pyfunction]
 fn verify_evm<'a>(
@@ -1857,12 +1973,25 @@ fn verify_evm<'a>(
     addr_verifier: &'a str,
     rpc_url: String,
     proof_path: PathBuf,
-    vka_path: Option<PathBuf>,
+    addr_da: Option<&'a str>,
+    addr_vk: Option<&'a str>,
 ) -> 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, vka_path)
+        crate::execute::verify_evm(proof_path, addr_verifier, rpc_url, addr_da, addr_vk)
             .await
             .map_err(|e| {
                 let err_str = format!("Failed to run verify_evm: {}", e);
@@ -1986,10 +2115,12 @@ 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_data, m)?)?;
     m.add_function(wrap_pyfunction!(create_evm_verifier_aggr, m)?)?;
+    m.add_function(wrap_pyfunction!(create_evm_data_attestation, m)?)?;
     m.add_function(wrap_pyfunction!(encode_evm_calldata, m)?)?;
-    m.add_function(wrap_pyfunction!(register_vka, m)?)?;
     Ok(())
 }
 

src/bindings/universal.rs

@@ -1,7 +1,6 @@
 use halo2_proofs::{
     plonk::*,
     poly::{
-        VerificationStrategy,
         commitment::{CommitmentScheme, ParamsProver},
         ipa::{
             commitment::{IPACommitmentScheme, ParamsIPA},
@@ -13,6 +12,7 @@ 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::{
-        TranscriptType, create_proof_circuit,
+        create_proof_circuit,
         evm::aggregation_kzg::{AggregationCircuit, PoseidonTranscript},
-        verify_proof_circuit,
+        verify_proof_circuit, TranscriptType,
     },
     tensor::TensorType,
+    CheckMode, Commitments, EZKLError as InnerEZKLError,
 };
 
 use crate::graph::{GraphCircuit, GraphWitness};
@@ -66,24 +66,26 @@ 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>,
-    vka: Option<Vec<u8>>,
+    vk_address: Option<Vec<u8>>,
 ) -> Result<Vec<u8>, EZKLError> {
     let snark: crate::pfsys::Snark<Fr, G1Affine> =
         serde_json::from_slice(&proof[..]).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)?;
+    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)?;
         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(vka, &snark.proof, &flattened_instances.collect::<Vec<_>>());
+    let encoded = encode_calldata(
+        vk_address,
+        &snark.proof,
+        &flattened_instances.collect::<Vec<_>>(),
+    );
 
     Ok(encoded)
 }

src/circuit/ops/chip.rs

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

src/circuit/ops/hybrid.rs

@@ -1,7 +1,7 @@
 use super::*;
 use crate::{
     circuit::{layouts, utils},
-    fieldutils::{IntegerRep, integer_rep_to_felt},
+    fieldutils::{integer_rep_to_felt, IntegerRep},
     graph::multiplier_to_scale,
     tensor::{self, DataFormat, Tensor, TensorType, ValTensor},
 };
@@ -109,13 +109,13 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
     ///
     fn requires_homogenous_input_scales(&self) -> Vec<usize> {
         match self {
-            HybridOp::Greater { .. }
-            | HybridOp::Less { .. }
-            | HybridOp::Equals { .. }
-            | HybridOp::GreaterEqual { .. }
+            HybridOp::Greater
+            | HybridOp::Less
+            | HybridOp::Equals
+            | HybridOp::GreaterEqual
             | HybridOp::Max
             | HybridOp::Min
-            | HybridOp::LessEqual { .. } => {
+            | HybridOp::LessEqual => {
                 vec![0, 1]
             }
             _ => vec![],
@@ -213,7 +213,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
         &self,
         config: &mut crate::circuit::BaseConfig<F>,
         region: &mut RegionCtx<F>,
-        values: &[ValTensor<F>],
+        values: &[&ValTensor<F>],
     ) -> Result<Option<ValTensor<F>>, CircuitError> {
         Ok(Some(match self {
             HybridOp::Rsqrt {
@@ -362,10 +362,10 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Hybrid
 
     fn out_scale(&self, in_scales: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
         let scale = match self {
-            HybridOp::Greater { .. }
-            | HybridOp::GreaterEqual { .. }
-            | HybridOp::Less { .. }
-            | HybridOp::LessEqual { .. }
+            HybridOp::Greater
+            | HybridOp::GreaterEqual
+            | HybridOp::Less
+            | HybridOp::LessEqual
             | HybridOp::ReduceArgMax { .. }
             | HybridOp::OneHot { .. }
             | HybridOp::ReduceArgMin { .. } => 0,

src/circuit/ops/lookup.rs

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

src/circuit/ops/mod.rs

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

src/circuit/ops/poly.rs

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

src/circuit/ops/region.rs

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

src/circuit/tests.rs

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

src/commands.rs

@@ -1,4 +1,3 @@
-#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
 use alloy::primitives::Address as H160;
 use clap::{Command, Parser, Subcommand};
 use clap_complete::{generate, Generator, Shell};
@@ -12,6 +11,7 @@ use tosubcommand::{ToFlags, ToSubcommand};
 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,14 +42,20 @@ 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
@@ -72,8 +78,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 VKA calldata path
-pub const DEFAULT_VKA: &str = "vka.bytes";
+/// Default VK sol path
+pub const DEFAULT_VK_SOL: &str = "vk.sol";
 /// Default VK abi path
 pub const DEFAULT_VK_ABI: &str = "vk.abi";
 /// Default scale rebase multipliers for calibration
@@ -86,10 +92,6 @@ 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)
@@ -185,6 +187,8 @@ 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 {
@@ -203,6 +207,7 @@ impl std::fmt::Display for ContractType {
                     "verifier/reusable".to_string()
                 }
                 ContractType::Verifier { reusable: false } => "verifier".to_string(),
+                ContractType::VerifyingKeyArtifact => "vka".to_string(),
             }
         )
     }
@@ -219,6 +224,7 @@ 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");
@@ -228,25 +234,24 @@ 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 {
@@ -294,6 +299,7 @@ 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),
         }
     }
 }
@@ -306,6 +312,7 @@ 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")),
         }
     }
@@ -384,10 +391,8 @@ impl FromStr for DataField {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         // Check if the input starts with '@'
-        if s.starts_with('@') {
+        if let Some(file_path) = s.strip_prefix('@') {
             // 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))?;
@@ -664,6 +669,30 @@ pub enum Commands {
         #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION, action = clap::ArgAction::SetTrue)]
         disable_selector_compression: Option<bool>,
     },
+    /// Deploys a test contact that the data attester reads from and creates a data attestation formatted input.json file that contains call data information
+    #[command(arg_required_else_help = true)]
+    SetupTestEvmData {
+        /// The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
+        #[arg(short = 'D', long, value_hint = clap::ValueHint::FilePath)]
+        data: Option<String>,
+        /// The path to the compiled model file (generated using the compile-circuit command)
+        #[arg(short = 'M', long, value_hint = clap::ValueHint::FilePath)]
+        compiled_circuit: Option<PathBuf>,
+        /// For testing purposes only. The optional path to the .json data file that will be generated that contains the OnChain data storage information
+        /// derived from the file information in the data .json file.
+        /// Should include both the network input (possibly private) and the network output (public input to the proof)
+        #[arg(short = 'T', long, value_hint = clap::ValueHint::FilePath)]
+        test_data: PathBuf,
+        /// RPC URL for an Ethereum node
+        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
+        rpc_url: String,
+        /// where the input data come from
+        #[arg(long, default_value = "on-chain", value_hint = clap::ValueHint::Other)]
+        input_source: TestDataSource,
+        /// where the output data come from
+        #[arg(long, default_value = "on-chain", value_hint = clap::ValueHint::Other)]
+        output_source: TestDataSource,
+    },
     /// Swaps the positions in the transcript that correspond to commitments
     SwapProofCommitments {
         /// The path to the proof file
@@ -706,7 +735,6 @@ 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)]
@@ -714,13 +742,12 @@ 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 serialized VKA file
+        /// The path to the verification key address (only used if the vk is rendered as a separate contract)
         #[arg(long, value_hint = clap::ValueHint::Other)]
-        vka_path: Option<PathBuf>,
+        addr_vk: Option<H160Flag>,
     },
     /// 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)]
@@ -741,9 +768,8 @@ pub enum Commands {
         #[arg(long, default_value = DEFAULT_RENDER_REUSABLE, action = clap::ArgAction::SetTrue)]
         reusable: Option<bool>,
     },
-    /// Creates an evm verifier artifact to be used by the reusable verifier
+    /// Creates an Evm verifier artifact for a single proof to be used by the reusable verifier
     #[command(name = "create-evm-vka")]
-    #[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)]
@@ -754,18 +780,39 @@ 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 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>,
+        /// 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")]
+    CreateEvmDa {
+        /// 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>,
     },
 
     /// 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)]
@@ -829,7 +876,6 @@ 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)]
@@ -850,9 +896,33 @@ 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")]
+    DeployEvmDa {
+        /// The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
+        #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
+        data: Option<String>,
+        /// The path to load circuit settings .json file from (generated using the gen-settings command)
+        #[arg(long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
+        settings_path: Option<PathBuf>,
+        /// The path to the Solidity code
+        #[arg(long, default_value = DEFAULT_SOL_CODE_DA, value_hint = clap::ValueHint::FilePath)]
+        sol_code_path: Option<PathBuf>,
+        /// RPC URL for an Ethereum node
+        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
+        rpc_url: 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)]
@@ -863,29 +933,12 @@ pub enum Commands {
         /// 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: 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>,
+        /// 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>,
     },
     #[cfg(not(feature = "no-update"))]
     /// Updates ezkl binary to version specified (or latest if not specified)

src/eth.rs

@@ -1,20 +1,24 @@
-use crate::graph::input::FileSourceInner;
-use crate::pfsys::Snark;
+use crate::graph::input::{CallToAccount, CallsToAccount, FileSourceInner, GraphData};
+use crate::graph::modules::POSEIDON_INSTANCES;
+use crate::graph::DataSource;
+use crate::graph::GraphSettings;
 use crate::pfsys::evm::EvmVerificationError;
+use crate::pfsys::Snark;
 use alloy::contract::CallBuilder;
 use alloy::core::primitives::Address as H160;
 use alloy::core::primitives::Bytes;
 use alloy::core::primitives::U256;
+use alloy::dyn_abi::abi::token::{DynSeqToken, PackedSeqToken, WordToken};
 use alloy::dyn_abi::abi::TokenSeq;
 // use alloy::providers::Middleware;
 use alloy::json_abi::JsonAbi;
 use alloy::primitives::ruint::ParseError;
-use alloy::primitives::{I256, ParseSignedError};
-use alloy::providers::ProviderBuilder;
+use alloy::primitives::{ParseSignedError, B256, I256};
 use alloy::providers::fillers::{
     ChainIdFiller, FillProvider, GasFiller, JoinFill, NonceFiller, SignerFiller,
 };
 use alloy::providers::network::{Ethereum, EthereumSigner};
+use alloy::providers::ProviderBuilder;
 use alloy::providers::{Identity, Provider, RootProvider};
 use alloy::rpc::types::eth::TransactionInput;
 use alloy::rpc::types::eth::TransactionRequest;
@@ -23,12 +27,13 @@ use alloy::signers::wallet::{LocalWallet, WalletError};
 use alloy::sol as abigen;
 use alloy::transports::http::Http;
 use alloy::transports::{RpcError, TransportErrorKind};
-use foundry_compilers::Solc;
 use foundry_compilers::artifacts::Settings as SolcSettings;
 use foundry_compilers::error::{SolcError, SolcIoError};
-use halo2_solidity_verifier::{encode_calldata, encode_register_vk_calldata};
+use foundry_compilers::Solc;
+use halo2_solidity_verifier::encode_calldata;
 use halo2curves::bn256::{Fr, G1Affine};
 use halo2curves::group::ff::PrimeField;
+use itertools::Itertools;
 use log::{debug, info, warn};
 use reqwest::Client;
 use std::path::PathBuf;
@@ -224,9 +229,9 @@ abigen!(
                 bool neg;
                 if (instances[i] > uint128(type(int128).max)) {
                     x = int256(ORDER - instances[i]);
-                    neg = true;
                 } else {
                     x = int256(instances[i]);
+                    neg = true;
                 }
                 uint output = mulDiv(uint256(x), numerator, denominator);
                 if (mulmod(uint256(x), numerator, denominator) * 2 >= denominator) {
@@ -239,16 +244,6 @@ abigen!(
     }
 );
 
-#[derive(Debug, thiserror::Error)]
-pub enum RescaleCheckError {
-    #[error("rescaled instance #{idx} mismatch: expected {expected}, got {got}")]
-    Mismatch {
-        idx: usize,
-        expected: String,
-        got: String,
-    },
-}
-
 #[derive(Debug, thiserror::Error)]
 pub enum EthError {
     #[error("a transport error occurred: {0}")]
@@ -296,10 +291,6 @@ pub enum EthError {
     Svm(String),
     #[error("no contract output found")]
     NoContractOutput,
-    #[error("failed to load vka data: {0}")]
-    VkaData(String),
-    #[error("rescaled‑instance mismatch: {0}")]
-    RescaleCheckError(#[from] RescaleCheckError),
 }
 
 // we have to generate these two contract differently because they are generated dynamically ! and hence the static compilation from above does not suit
@@ -378,82 +369,206 @@ pub async fn deploy_contract_via_solidity(
 }
 
 ///
-pub async fn register_vka_via_rv(
+pub async fn deploy_da_verifier_via_solidity(
+    settings_path: PathBuf,
+    input: String,
+    sol_code_path: PathBuf,
     rpc_url: &str,
+    runs: usize,
     private_key: Option<&str>,
-    rv_address: H160,
-    vka_words: &[[u8; 32]],
-) -> Result<Vec<u8>, EthError> {
-    let (client, _) = setup_eth_backend(rpc_url, private_key).await?;
+) -> Result<H160, EthError> {
+    let (client, client_address) = setup_eth_backend(rpc_url, private_key).await?;
 
-    let encoded = encode_register_vk_calldata(vka_words);
+    let input = GraphData::from_str(&input).map_err(|_| EthError::GraphData)?;
 
-    debug!(
-        "encoded register vka calldata: {:#?}",
-        hex::encode(&encoded)
-    );
+    let settings = GraphSettings::load(&settings_path).map_err(|_| EthError::GraphSettings)?;
 
-    let input: TransactionInput = encoded.into();
+    let mut scales: Vec<u32> = vec![];
+    // The data that will be stored in the test contracts that will eventually be read from.
+    let mut call_to_account = None;
 
-    let tx = TransactionRequest::default().to(rv_address).input(input);
-    debug!("transaction {:#?}", tx);
+    let mut instance_shapes = vec![];
+    let mut model_instance_offset = 0;
 
-    let result = client.call(&tx).await;
-
-    if let Err(e) = result {
-        return Err(EvmVerificationError::SolidityExecution(e.to_string()).into());
-    }
-    let result = result?;
-    debug!("result: {:#?}", result.to_vec());
-    // decode return bytes value into uint8
-    let output = result.to_vec();
-
-    let gas = client.estimate_gas(&tx).await?;
-
-    info!("estimated vka registration cost: {:#?}", gas);
-
-    // broadcast the transaction
-
-    let result = client.send_transaction(tx).await?;
-
-    result.watch().await?;
-
-    // if gas is greater than 30 million warn the user that the gas cost is above ethereum's 30 million block gas limit
-    if gas > 30_000_000_u128 {
-        warn!(
-            "Gas cost of verify transaction is greater than 30 million block gas limit. It will fail on mainnet."
-        );
-    } else if gas > 15_000_000_u128 {
-        warn!(
-            "Gas cost of verify transaction is greater than 15 million, the target block size for ethereum"
-        );
+    if settings.run_args.input_visibility.is_hashed() {
+        instance_shapes.push(POSEIDON_INSTANCES)
+    } else if settings.run_args.input_visibility.is_public() {
+        for idx in 0..settings.model_input_scales.len() {
+            let shape = &settings.model_instance_shapes[idx];
+            instance_shapes.push(shape.iter().product::<usize>());
+            model_instance_offset += 1;
+        }
     }
 
-    Ok(output)
+    if settings.run_args.param_visibility.is_hashed() {
+        return Err(EvmVerificationError::InvalidVisibility.into());
+    }
+
+    if settings.run_args.output_visibility.is_hashed() {
+        instance_shapes.push(POSEIDON_INSTANCES)
+    } else if settings.run_args.output_visibility.is_public() {
+        for idx in model_instance_offset..model_instance_offset + settings.model_output_scales.len()
+        {
+            let shape = &settings.model_instance_shapes[idx];
+            instance_shapes.push(shape.iter().product::<usize>());
+        }
+    }
+
+    let mut instance_idx = 0;
+    let mut contract_instance_offset = 0;
+
+    if let DataSource::OnChain(source) = input.input_data {
+        if settings.run_args.input_visibility.is_hashed_public() {
+            // set scales 1.0
+            scales.extend(vec![0; instance_shapes[instance_idx]]);
+            instance_idx += 1;
+        } else {
+            let input_scales = settings.clone().model_input_scales;
+            // give each input a scale
+            for scale in input_scales {
+                scales.extend(vec![scale as u32; instance_shapes[instance_idx]]);
+                instance_idx += 1;
+            }
+        }
+        // match statement for enum type of source.call
+        call_to_account = Some(source.call);
+    } else if let DataSource::File(source) = input.input_data {
+        if settings.run_args.input_visibility.is_public() {
+            instance_idx += source.len();
+            for s in source {
+                contract_instance_offset += s.len();
+            }
+        }
+    }
+
+    if let Some(DataSource::OnChain(source)) = input.output_data {
+        if settings.run_args.output_visibility.is_hashed_public() {
+            // set scales 1.0
+            scales.extend(vec![0; instance_shapes[instance_idx]]);
+        } else {
+            let input_scales = settings.clone().model_output_scales;
+            // give each output a scale
+            for scale in input_scales {
+                scales.extend(vec![scale as u32; instance_shapes[instance_idx]]);
+                instance_idx += 1;
+            }
+        }
+        call_to_account = Some(source.call);
+        // match statement for enum type of source.calls
+    }
+
+    deploy_da_contract(
+        client,
+        contract_instance_offset,
+        client_address,
+        scales,
+        call_to_account,
+        sol_code_path,
+        runs,
+        &settings,
+    )
+    .await
+}
+async fn deploy_da_contract(
+    client: EthersClient,
+    contract_instance_offset: usize,
+    client_address: alloy::primitives::Address,
+    scales: Vec<u32>,
+    call_to_accounts: Option<CallToAccount>,
+    sol_code_path: PathBuf,
+    runs: usize,
+    settings: &GraphSettings,
+) -> Result<H160, EthError> {
+    let (abi, bytecode, runtime_bytecode) =
+        get_contract_artifacts(sol_code_path, "DataAttestation", runs).await?;
+    let (contract_address, call_data, decimals) = if let Some(call_to_accounts) = call_to_accounts {
+        parse_call_to_account(call_to_accounts)?
+    } else {
+        // if calls to accounts is empty then we know need to check that atleast there kzg visibility in the settings file
+        let kzg_visibility = settings.run_args.input_visibility.is_polycommit()
+            || settings.run_args.output_visibility.is_polycommit()
+            || settings.run_args.param_visibility.is_polycommit();
+        if !kzg_visibility {
+            return Err(EthError::OnChainDataSource);
+        }
+        let factory =
+            get_sol_contract_factory(abi, bytecode, runtime_bytecode, client, None::<()>)?;
+        let contract = factory.deploy().await?;
+        return Ok(contract);
+    };
+
+    let factory = get_sol_contract_factory(
+        abi,
+        bytecode,
+        runtime_bytecode,
+        client,
+        Some((
+            // address _contractAddress,
+            WordToken(contract_address.into_word()),
+            // bytes memory _callData,
+            PackedSeqToken(call_data.as_ref()),
+            // uint256 [] _decimals,
+            DynSeqToken(
+                decimals
+                    .iter()
+                    .map(|i| WordToken(B256::from(*i)))
+                    .collect_vec(),
+            ),
+            // uint[] memory _bits,
+            DynSeqToken(
+                scales
+                    .clone()
+                    .into_iter()
+                    .map(|i| WordToken(U256::from(i).into()))
+                    .collect_vec(),
+            ),
+            //  uint8 _instanceOffset,
+            WordToken(U256::from(contract_instance_offset as u32).into()),
+            // address _admin
+            WordToken(client_address.into_word()),
+        )),
+    )?;
+
+    debug!("scales: {:#?}", scales);
+    debug!("call_data: {:#?}", call_data);
+    debug!("contract_addresses: {:#?}", contract_address);
+    debug!("decimals: {:#?}", decimals);
+
+    let contract = factory.deploy().await?;
+
+    Ok(contract)
+}
+type ParsedCallToAccount = (H160, Bytes, Vec<U256>);
+
+fn parse_call_to_account(call_to_account: CallToAccount) -> Result<ParsedCallToAccount, EthError> {
+    let contract_address_bytes = hex::decode(&call_to_account.address)?;
+    let contract_address = H160::from_slice(&contract_address_bytes);
+    let call_data_bytes = hex::decode(&call_to_account.call_data)?;
+    let call_data = Bytes::from(call_data_bytes);
+    // Parse the decimals array as uint256 array for the contract.
+    // iterate through the decimals array and convert each element to a uint256
+    let mut decimals: Vec<U256> = vec![];
+    for decimal in &call_to_account.decimals {
+        decimals.push(I256::from_dec_str(&decimal.to_string())?.unsigned_abs());
+    }
+    // let decimal = I256::from_dec_str(&call_to_account.decimals.to_string())?.unsigned_abs();
+    Ok((contract_address, call_data, decimals))
 }
 
 /// Verify a proof using a Solidity verifier contract
-/// TODO: add param to pass vka_digest and use that to fetch the VKA by indexing the RegisteredVKA events on the RV
 pub async fn verify_proof_via_solidity(
     proof: Snark<Fr, G1Affine>,
     addr: H160,
-    vka_path: Option<PathBuf>,
+    addr_vk: Option<H160>,
     rpc_url: &str,
 ) -> Result<bool, EthError> {
     let flattened_instances = proof.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| EthError::VkaData(e.to_string()))?)
-        }
-        None => None,
-    };
-
-    let vka: Option<&[[u8; 32]]> = vka_buf.as_deref();
-
-    let encoded = encode_calldata(vka, &proof.proof, &flattened_instances.collect::<Vec<_>>());
+    let encoded = encode_calldata(
+        addr_vk.as_ref().map(|x| x.0).map(|x| x.0),
+        &proof.proof,
+        &flattened_instances.collect::<Vec<_>>(),
+    );
 
     debug!("encoded: {:#?}", hex::encode(&encoded));
 
@@ -470,37 +585,8 @@ pub async fn verify_proof_via_solidity(
     }
     let result = result?;
     debug!("result: {:#?}", result.to_vec());
-    // if result is larger than 32
-    if result.to_vec().len() > 32 {
-        // From result[96..], iterate through 32 byte chunks converting them to U256
-        let rescaled_instances = result.to_vec()[96..]
-            .chunks_exact(32)
-            .map(|chunk| U256::from_be_slice(chunk).to_string())
-            .collect::<Vec<_>>();
-        if let Some(pretty) = &proof.pretty_public_inputs {
-            // 1️⃣ collect reference decimals --------------------------------------
-            let mut refs = pretty.rescaled_inputs.clone();
-            refs.extend(pretty.rescaled_outputs.clone()); // extend inputs with outputs
-            let reference: Vec<String> = refs.into_iter().flatten().collect();
-
-            // 2️⃣ compare element‑wise -------------------------------------------
-            for (idx, (inst, exp)) in rescaled_instances.iter().zip(reference.iter()).enumerate() {
-                if !scaled_matches(inst, exp) {
-                    return Err(EthError::RescaleCheckError(RescaleCheckError::Mismatch {
-                        idx,
-                        expected: exp.clone(),
-                        got: to_decimal_18(inst),
-                    }));
-                }
-            }
-            debug!("✅ all rescaled instances match their expected values");
-        }
-    }
     // decode return bytes value into uint8
-    let result = result.to_vec()[..32]
-        .last()
-        .ok_or(EthError::NoContractOutput)?
-        == &1u8;
+    let result = result.to_vec().last().ok_or(EthError::NoContractOutput)? == &1u8;
     if !result {
         return Err(EvmVerificationError::InvalidProof.into());
     }
@@ -569,6 +655,170 @@ pub async fn setup_test_contract<M: 'static + Provider<Http<Client>, Ethereum>>(
     Ok((contract, decimals))
 }
 
+/// Verify a proof using a Solidity DataAttestation contract.
+/// Used for testing purposes.
+pub async fn verify_proof_with_data_attestation(
+    proof: Snark<Fr, G1Affine>,
+    addr_verifier: H160,
+    addr_da: H160,
+    addr_vk: Option<H160>,
+    rpc_url: &str,
+) -> Result<bool, EthError> {
+    use ethabi::{Function, Param, ParamType, StateMutability, Token};
+
+    let mut public_inputs: Vec<U256> = vec![];
+    let flattened_instances = proof.instances.into_iter().flatten();
+
+    for val in flattened_instances.clone() {
+        let bytes = val.to_repr();
+        let u = U256::from_le_slice(bytes.inner().as_slice());
+        public_inputs.push(u);
+    }
+
+    let encoded_verifier = encode_calldata(
+        addr_vk.as_ref().map(|x| x.0).map(|x| x.0),
+        &proof.proof,
+        &flattened_instances.collect::<Vec<_>>(),
+    );
+
+    debug!("encoded: {:#?}", hex::encode(&encoded_verifier));
+
+    debug!("public_inputs: {:#?}", public_inputs);
+    debug!("proof: {:#?}", Bytes::from(proof.proof.to_vec()));
+
+    #[allow(deprecated)]
+    let func = Function {
+        name: "verifyWithDataAttestation".to_owned(),
+        inputs: vec![
+            Param {
+                name: "verifier".to_owned(),
+                kind: ParamType::Address,
+                internal_type: None,
+            },
+            Param {
+                name: "encoded".to_owned(),
+                kind: ParamType::Bytes,
+                internal_type: None,
+            },
+        ],
+        outputs: vec![Param {
+            name: "success".to_owned(),
+            kind: ParamType::Bool,
+            internal_type: None,
+        }],
+        constant: None,
+        state_mutability: StateMutability::View,
+    };
+
+    let encoded = func.encode_input(&[
+        Token::Address(addr_verifier.0 .0.into()),
+        Token::Bytes(encoded_verifier),
+    ])?;
+
+    debug!("encoded: {:#?}", hex::encode(&encoded));
+
+    let encoded: TransactionInput = encoded.into();
+
+    let (client, _) = setup_eth_backend(rpc_url, None).await?;
+    let tx = TransactionRequest::default().to(addr_da).input(encoded);
+    debug!("transaction {:#?}", tx);
+    info!(
+        "estimated verify gas cost: {:#?}",
+        client.estimate_gas(&tx).await?
+    );
+
+    let result = client.call(&tx).await;
+    if let Err(e) = result {
+        return Err(EvmVerificationError::SolidityExecution(e.to_string()).into());
+    }
+    let result = result?;
+    debug!("result: {:#?}", result);
+    // decode return bytes value into uint8
+    let result = result.to_vec().last().ok_or(EthError::NoContractOutput)? == &1u8;
+    if !result {
+        return Err(EvmVerificationError::InvalidProof.into());
+    }
+
+    Ok(true)
+}
+
+/// Tests on-chain data storage by deploying a contract that stores the network input and or output
+/// data in its storage. It does this by converting the floating point values to integers and storing the
+/// the number of decimals of the floating point value on chain.
+pub async fn test_on_chain_data<M: 'static + Provider<Http<Client>, Ethereum>>(
+    client: Arc<M>,
+    data: &[Vec<FileSourceInner>],
+) -> Result<CallToAccount, EthError> {
+    let (contract, decimals) = setup_test_contract(client, data).await?;
+
+    // Get the encoded calldata for the input
+    let builder = contract.readAll();
+    let call = builder.calldata();
+    let call_to_account = CallToAccount {
+        call_data: hex::encode(call),
+        decimals,
+        address: hex::encode(contract.address().0 .0),
+    };
+    info!("call_to_account: {:#?}", call_to_account);
+    Ok(call_to_account)
+}
+
+/// Reads on-chain inputs, returning the raw encoded data returned from making all the calls in on_chain_input_data
+pub async fn read_on_chain_inputs_multi<M: 'static + Provider<Http<Client>, Ethereum>>(
+    client: Arc<M>,
+    address: H160,
+    data: &Vec<CallsToAccount>,
+) -> Result<(Vec<Bytes>, Vec<u8>), EthError> {
+    // Iterate over all on-chain inputs
+
+    let mut fetched_inputs = vec![];
+    let mut decimals = vec![];
+    for on_chain_data in data {
+        // Construct the address
+        let contract_address_bytes = hex::decode(&on_chain_data.address)?;
+        let contract_address = H160::from_slice(&contract_address_bytes);
+        for (call_data, decimal) in &on_chain_data.call_data {
+            let call_data_bytes = hex::decode(call_data)?;
+            let input: TransactionInput = call_data_bytes.into();
+
+            let tx = TransactionRequest::default()
+                .to(contract_address)
+                .from(address)
+                .input(input);
+            debug!("transaction {:#?}", tx);
+
+            let result = client.call(&tx).await?;
+            debug!("return data {:#?}", result);
+            fetched_inputs.push(result);
+            decimals.push(*decimal);
+        }
+    }
+    Ok((fetched_inputs, decimals))
+}
+
+/// Reads on-chain inputs, returning the raw encoded data returned from making the single call in on_chain_input_data
+/// that returns the array of input data we will attest to.
+pub async fn read_on_chain_inputs<M: 'static + Provider<Http<Client>, Ethereum>>(
+    client: Arc<M>,
+    address: H160,
+    data: &CallToAccount,
+) -> Result<Bytes, EthError> {
+    // Iterate over all on-chain inputs
+    let contract_address_bytes = hex::decode(&data.address)?;
+    let contract_address = H160::from_slice(&contract_address_bytes);
+    let call_data_bytes = hex::decode(&data.call_data)?;
+    let input: TransactionInput = call_data_bytes.into();
+    let tx = TransactionRequest::default()
+        .to(contract_address)
+        .from(address)
+        .input(input);
+    debug!("transaction {:#?}", tx);
+
+    let result = client.call(&tx).await?;
+    debug!("return data {:#?}", result);
+    Ok(result)
+}
+
 pub async fn evm_quantize<M: 'static + Provider<Http<Client>, Ethereum>>(
     client: Arc<M>,
     scales: Vec<crate::Scale>,
@@ -663,9 +913,9 @@ pub async fn get_contract_artifacts(
     runs: usize,
 ) -> Result<(JsonAbi, Bytes, Bytes), EthError> {
     use foundry_compilers::{
-        SHANGHAI_SOLC, SolcInput,
-        artifacts::{Optimizer, output_selection::OutputSelection},
+        artifacts::{output_selection::OutputSelection, Optimizer},
         compilers::CompilerInput,
+        SolcInput, SHANGHAI_SOLC,
     };
 
     if !sol_code_path.exists() {
@@ -716,74 +966,6 @@ pub async fn get_contract_artifacts(
     Ok((abi, bytecode, runtime_bytecode))
 }
 
-/// Convert a 1e‑18 fixed‑point **integer string** into a decimal string.
-///
-/// `"1541748046875000000"` → `"1.541748046875000000"`  
-/// `"273690402507781982"`  → `"0.273690402507781982"`
-fn to_decimal_18(s: &str) -> String {
-    let s = s.trim_start_matches('0');
-    if s.is_empty() {
-        return "0".into();
-    }
-    if s.len() <= 18 {
-        // pad on the left so we always have exactly 18 fraction digits
-        return format!("0.{:0>18}", s);
-    }
-    let split = s.len() - 18;
-    format!("{}.{}", &s[..split], &s[split..]) // ← correct slice here
-}
-
-/// “Banker’s‐round” comparison:  compare the **decimal** produced
-/// by `instance` to the reference string `expected`.
-///
-/// *  All digits present in `expected` (integer part **and** fraction)
-///    must match exactly.
-/// *  Excess digits in `instance` are ignored **unless** the very first
-///    excess digit ≥ 5; in that case we round the last compared digit
-///    and check again.
-fn scaled_matches(instance: &str, expected: &str) -> bool {
-    let inst_dec = to_decimal_18(instance);
-    let (inst_int, inst_frac) = inst_dec.split_once('.').unwrap_or((&inst_dec, ""));
-    let (exp_int, exp_frac) = expected.split_once('.').unwrap_or((expected, ""));
-
-    // integer part must be identical
-    if inst_int != exp_int {
-        return false;
-    }
-
-    // fraction‑part comparison with optional rounding
-    let cmp_len = exp_frac.len();
-    let inst_cmp = &inst_frac[..cmp_len.min(inst_frac.len())];
-    let trailing = inst_frac.chars().nth(cmp_len).unwrap_or('0');
-
-    if inst_cmp == exp_frac {
-        true // exact match
-    } else if trailing >= '5' {
-        // need to round
-        // round the inst_cmp (string) up by one ulp
-        let mut rounded = inst_cmp.chars().collect::<Vec<_>>();
-        let mut carry = true;
-        for d in rounded.iter_mut().rev() {
-            if !carry {
-                break;
-            }
-            let v = d.to_digit(10).unwrap() + 1;
-            *d = char::from_digit(v % 10, 10).unwrap();
-            carry = v == 10;
-        }
-        if carry {
-            // 0.999… → 1.000…
-            return exp_int
-                == &(num::BigUint::parse_bytes(exp_int.as_bytes(), 10).unwrap() + 1u32)
-                    .to_string()
-                && exp_frac.chars().all(|c| c == '0');
-        }
-        rounded.into_iter().collect::<String>() == exp_frac
-    } else {
-        false
-    }
-}
-
 /// Sets the constants stored in the da verifier
 pub fn fix_da_sol(commitment_bytes: Option<Vec<u8>>, only_kzg: bool) -> Result<String, EthError> {
     let mut contract = ATTESTDATA_SOL.to_string();

src/execute.rs

@@ -1,13 +1,12 @@
 use crate::circuit::region::RegionSettings;
 use crate::circuit::CheckMode;
 use crate::commands::CalibrationTarget;
-#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
-use crate::eth::{deploy_contract_via_solidity, register_vka_via_rv};
+use crate::eth::{deploy_contract_via_solidity, deploy_da_verifier_via_solidity, fix_da_sol};
 #[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::GraphData;
 use crate::graph::{GraphCircuit, GraphSettings, GraphWitness, Model};
+use crate::graph::{TestDataSource, TestSources};
 use crate::pfsys::evm::aggregation_kzg::{AggregationCircuit, PoseidonTranscript};
 use crate::pfsys::{
     create_keys, load_pk, load_vk, save_params, save_pk, Snark, StrategyType, TranscriptType,
@@ -39,7 +38,6 @@ use halo2_proofs::poly::kzg::{
 };
 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};
@@ -56,12 +54,9 @@ use snark_verifier::loader::native::NativeLoader;
 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;
-#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
-use std::io::Write;
+use std::io::{Cursor, Write};
 use std::path::Path;
 use std::path::PathBuf;
 use std::str::FromStr;
@@ -171,6 +166,7 @@ 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,
@@ -185,12 +181,12 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             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,
@@ -209,35 +205,48 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             )
             .await
         }
-        #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
         Commands::EncodeEvmCalldata {
             proof_path,
             calldata_path,
-            vka_path,
+            addr_vk,
         } => encode_evm_calldata(
             proof_path.unwrap_or(DEFAULT_PROOF.into()),
             calldata_path.unwrap_or(DEFAULT_CALLDATA.into()),
-            vka_path,
+            addr_vk,
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
-        #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
         Commands::CreateEvmVka {
             vk_path,
             srs_path,
             settings_path,
-            vka_path,
-            decimals,
+            sol_code_path,
+            abi_path,
         } => {
             create_evm_vka(
                 vk_path.unwrap_or(DEFAULT_VK.into()),
                 srs_path,
                 settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
-                vka_path.unwrap_or(DEFAULT_VKA.into()),
-                decimals.unwrap_or(DEFAULT_DECIMALS.parse().unwrap()),
+                sol_code_path.unwrap_or(DEFAULT_VK_SOL.into()),
+                abi_path.unwrap_or(DEFAULT_VK_ABI.into()),
+            )
+            .await
+        }
+        Commands::CreateEvmDa {
+            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,
             )
             .await
         }
-        #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
         Commands::CreateEvmVerifierAggr {
             vk_path,
             srs_path,
@@ -283,6 +292,24 @@ 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_data(
+                data.unwrap_or(DEFAULT_DATA.into()),
+                compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
+                test_data,
+                rpc_url,
+                input_source,
+                output_source,
+            )
+            .await
+        }
         Commands::SwapProofCommitments {
             proof_path,
             witness_path,
@@ -391,7 +418,6 @@ 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,
@@ -410,35 +436,39 @@ pub async fn run(command: Commands) -> Result<String, EZKLError> {
             )
             .await
         }
-        #[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
+        Commands::DeployEvmDa {
+            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
+        }
         Commands::VerifyEvm {
             proof_path,
             addr_verifier,
             rpc_url,
-            vka_path,
+            addr_da,
+            addr_vk,
         } => {
             verify_evm(
                 proof_path.unwrap_or(DEFAULT_PROOF.into()),
                 addr_verifier,
                 rpc_url,
-                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,
+                addr_da,
+                addr_vk,
             )
             .await
         }
@@ -689,7 +719,7 @@ pub(crate) fn table(model: PathBuf, run_args: RunArgs) -> Result<String, EZKLErr
     Ok(String::new())
 }
 
-pub(crate) fn gen_witness(
+pub(crate) async fn gen_witness(
     compiled_circuit_path: PathBuf,
     data: String,
     output: Option<PathBuf>,
@@ -711,7 +741,7 @@ pub(crate) fn gen_witness(
         None
     };
 
-    let mut input = circuit.load_graph_input(&data)?;
+    let mut input = circuit.load_graph_input(&data).await?;
     #[cfg(any(not(feature = "ezkl"), target_arch = "wasm32"))]
     let mut input = circuit.load_graph_input(&data)?;
 
@@ -1022,7 +1052,7 @@ impl AccuracyResults {
 /// Calibrate the circuit parameters to a given a dataset
 #[allow(trivial_casts)]
 #[allow(clippy::too_many_arguments)]
-pub(crate) fn calibrate(
+pub(crate) async fn calibrate(
     model_path: PathBuf,
     data: String,
     settings_path: PathBuf,
@@ -1048,7 +1078,7 @@ pub(crate) fn calibrate(
 
     let input_shapes = model.graph.input_shapes()?;
 
-    let chunks = data.split_into_batches(input_shapes)?;
+    let chunks = data.split_into_batches(input_shapes).await?;
     info!("num calibration batches: {}", chunks.len());
 
     debug!("running onnx predictions...");
@@ -1133,15 +1163,9 @@ pub(crate) fn calibrate(
 
         // if unix get a gag
         #[cfg(all(not(not(feature = "ezkl")), unix))]
-        let _r = match Gag::stdout() {
-            Ok(g) => Some(g),
-            _ => None,
-        };
+        let _r = Gag::stdout().ok();
         #[cfg(all(not(not(feature = "ezkl")), unix))]
-        let _g = match Gag::stderr() {
-            Ok(g) => Some(g),
-            _ => None,
-        };
+        let _g = Gag::stderr().ok();
 
         let mut circuit = match GraphCircuit::from_run_args(&local_run_args, &model_path) {
             Ok(c) => c,
@@ -1159,7 +1183,7 @@ pub(crate) fn calibrate(
                 let chunk = chunk.clone();
 
                 let data = circuit
-                    .load_graph_input(&chunk)
+                    .load_graph_from_file_exclusively(&chunk)
                     .map_err(|e| format!("failed to load circuit inputs: {}", e))?;
 
                 let forward_res = circuit
@@ -1299,7 +1323,7 @@ pub(crate) fn calibrate(
                 .clone()
         }
         CalibrationTarget::Accuracy => {
-            let param_iterator = found_params.iter().sorted_by_key(|p| {
+            let mut param_iterator = found_params.iter().sorted_by_key(|p| {
                 (
                     p.run_args.input_scale,
                     p.run_args.param_scale,
@@ -1308,7 +1332,7 @@ pub(crate) fn calibrate(
                 )
             });
 
-            let last = param_iterator.last().ok_or("no params found")?;
+            let last = param_iterator.next_back().ok_or("no params found")?;
             let max_scale = (
                 last.run_args.input_scale,
                 last.run_args.param_scale,
@@ -1414,7 +1438,6 @@ 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>,
@@ -1432,9 +1455,7 @@ pub(crate) async fn create_evm_verifier(
     )?;
 
     let num_instance = settings.total_instances();
-    // 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 num_instance: usize = num_instance.iter().sum::<usize>();
 
     let vk = load_vk::<KZGCommitmentScheme<Bn256>, GraphCircuit>(vk_path, settings)?;
     trace!("params computed");
@@ -1443,10 +1464,7 @@ pub(crate) async fn create_evm_verifier(
         &params,
         &vk,
         halo2_solidity_verifier::BatchOpenScheme::Bdfg21,
-        &num_instance,
-        &scales,
-        0,
-        0,
+        num_instance,
     );
     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
@@ -1464,13 +1482,12 @@ 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,
-    vka_path: PathBuf,
-    decimals: usize,
+    sol_code_path: PathBuf,
+    abi_path: PathBuf,
 ) -> Result<String, EZKLError> {
     let settings = GraphSettings::load(&settings_path)?;
     let commitment: Commitments = settings.run_args.commitment.into();
@@ -1480,52 +1497,133 @@ pub(crate) async fn create_evm_vka(
         commitment,
     )?;
 
-    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 num_instance = settings.total_instances();
+    let num_instance: usize = num_instance.iter().sum::<usize>();
 
-    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_fixed_point_instance,
-        &scales,
-        decimals,
-        num_poseidon_instance,
+        num_instance,
     );
 
-    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
-        )))
-    })?;
+    let vk_solidity = generator.render_separately()?.1;
 
-    File::create(vka_path.clone())?.write_all(&serialized_vka_words)?;
+    File::create(sol_code_path.clone())?.write_all(vk_solidity.as_bytes())?;
 
-    // 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());
-    };
+    // 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)?;
 
     Ok(String::new())
 }
-#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
+
+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![])));
+
+    debug!("data attestation data: {:?}", data);
+
+    // 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;
+
+    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());
+        }
+        output_len = Some(source.call.decimals.len());
+    };
+
+    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());
+        }
+        input_len = Some(source.call.decimals.len());
+    };
+
+    // If both model inputs and outputs are attested to then we
+
+    // 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
+    };
+
+    let output: String = fix_da_sol(
+        commitment_bytes,
+        input_len.is_none() && output_len.is_none(),
+    )?;
+    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, "DataAttestation", 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: 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,
+        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())
+}
+
 pub(crate) async fn deploy_evm(
     sol_code_path: PathBuf,
     rpc_url: String,
@@ -1537,6 +1635,7 @@ 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,
@@ -1554,61 +1653,21 @@ 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,
-    vka_path: Option<PathBuf>,
+    addr_vk: Option<H160Flag>,
 ) -> 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(
-        vka,
+        addr_vk
+            .as_ref()
+            .map(|x| alloy::primitives::Address::from(*x).0)
+            .map(|x| x.0),
         &snark.proof,
         &flattened_instances.collect::<Vec<_>>(),
     );
@@ -1620,24 +1679,35 @@ 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: String,
-    vka_path: Option<PathBuf>,
+    addr_da: Option<H160Flag>,
+    addr_vk: Option<H160Flag>,
 ) -> Result<String, EZKLError> {
+    use crate::eth::verify_proof_with_data_attestation;
+
     let proof = Snark::load::<KZGCommitmentScheme<Bn256>>(&proof_path)?;
 
-    let result = verify_proof_via_solidity(
-        proof.clone(),
-        addr_verifier.into(),
-        vka_path.map(|s| s.into()),
-        rpc_url.as_ref(),
-    )
-    .await?;
+    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,
+        )
+        .await?
+    } else {
+        verify_proof_via_solidity(
+            proof.clone(),
+            addr_verifier.into(),
+            addr_vk.map(|s| s.into()),
+            &rpc_url,
+        )
+        .await?
+    };
 
     info!("Solidity verification result: {}", result);
 
@@ -1648,7 +1718,6 @@ 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>,
@@ -1674,8 +1743,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, ())?;
 
@@ -1683,10 +1752,7 @@ pub(crate) async fn create_evm_aggregate_verifier(
         &params,
         &agg_vk,
         halo2_solidity_verifier::BatchOpenScheme::Bdfg21,
-        &num_instance,
-        &scales,
-        0,
-        0,
+        num_instance,
     );
 
     let acc_encoding = halo2_solidity_verifier::AccumulatorEncoding::new(
@@ -1775,6 +1841,41 @@ pub(crate) fn setup(
     Ok(String::new())
 }
 
+pub(crate) async fn setup_test_evm_data(
+    data_path: String,
+    compiled_circuit_path: PathBuf,
+    test_data: PathBuf,
+    rpc_url: 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;
 
 #[allow(clippy::too_many_arguments)]

src/graph/errors.rs

@@ -67,8 +67,11 @@ pub enum GraphError {
     #[error("invalid input types")]
     InvalidInputTypes,
     /// Missing results
-    #[error("missing results")]
-    MissingResults,
+    #[error("missing result for node {0}")]
+    MissingResults(usize),
+    /// Missing input
+    #[error("missing input {0}")]
+    MissingInputForNode(usize),
     /// Tensor error
     #[error("[tensor] {0}")]
     TensorError(#[from] crate::tensor::TensorError),
@@ -104,7 +107,6 @@ pub enum GraphError {
         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}")]

src/graph/input.rs

@@ -182,6 +182,46 @@ impl OnChainSource {
     pub fn new(call: CallToAccount, rpc: RPCUrl) -> Self {
         OnChainSource { 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: &str,
+    ) -> Result<Self, GraphError> {
+        use crate::eth::{read_on_chain_inputs, test_on_chain_data};
+        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 used_rpc = rpc.to_string();
+
+        let call_to_account = test_on_chain_data(client.clone(), data).await?;
+        debug!("Call to account: {:?}", call_to_account);
+        let inputs = read_on_chain_inputs(client.clone(), client_address, &call_to_account).await?;
+        debug!("Inputs: {:?}", inputs);
+
+        // Fill the input_data field of the GraphData struct
+        Ok(OnChainSource::new(call_to_account, used_rpc))
+    }
 }
 
 /// Specification for view-only calls to fetch on-chain data
@@ -209,30 +249,29 @@ pub struct CallToAccount {
 
 /// Represents different sources of input/output data for the EZKL model
 #[derive(Clone, Debug, Serialize, PartialOrd, PartialEq)]
-pub struct DataSource(FileSource);
-
-impl DataSource {
-    /// Gets the underlying file source data
-    pub fn values(&self) -> &FileSource {
-        &self.0
-    }
+#[serde(untagged)]
+pub enum DataSource {
+    /// Data from a JSON file containing arrays of values
+    File(FileSource),
+    /// Data fetched from blockchain contracts
+    OnChain(OnChainSource),
 }
 
 impl Default for DataSource {
     fn default() -> Self {
-        DataSource(vec![vec![]])
+        DataSource::File(vec![vec![]])
     }
 }
 
 impl From<FileSource> for DataSource {
     fn from(data: FileSource) -> Self {
-        DataSource(data)
+        DataSource::File(data)
     }
 }
 
 impl From<Vec<Vec<Fp>>> for DataSource {
     fn from(data: Vec<Vec<Fp>>) -> Self {
-        DataSource(
+        DataSource::File(
             data.iter()
                 .map(|e| e.iter().map(|e| FileSourceInner::Field(*e)).collect())
                 .collect(),
@@ -242,7 +281,7 @@ impl From<Vec<Vec<Fp>>> for DataSource {
 
 impl From<Vec<Vec<f64>>> for DataSource {
     fn from(data: Vec<Vec<f64>>) -> Self {
-        DataSource(
+        DataSource::File(
             data.iter()
                 .map(|e| e.iter().map(|e| FileSourceInner::Float(*e)).collect())
                 .collect(),
@@ -250,6 +289,12 @@ 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>
@@ -261,7 +306,13 @@ 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(t));
+            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));
         }
 
         Err(serde::de::Error::custom("failed to deserialize DataSource"))
@@ -297,16 +348,25 @@ impl GraphData {
         datum_types: &[tract_onnx::prelude::DatumType],
     ) -> Result<TVec<TValue>, GraphError> {
         let mut inputs = TVec::new();
-        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());
+        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(),
+                ));
             }
         }
-
         Ok(inputs)
     }
 
@@ -338,7 +398,7 @@ impl GraphData {
             }
         }
         Ok(GraphData {
-            input_data: DataSource(input_data),
+            input_data: DataSource::File(input_data),
             output_data: None,
         })
     }
@@ -365,9 +425,7 @@ impl GraphData {
     pub fn from_str(data: &str) -> Result<Self, GraphError> {
         let graph_input = serde_json::from_str(data);
         match graph_input {
-            Ok(graph_input) => {
-                return Ok(graph_input);
-            }
+            Ok(graph_input) => Ok(graph_input),
             Err(_) => {
                 let path = std::path::PathBuf::from(data);
                 GraphData::from_path(path)
@@ -420,7 +478,7 @@ impl GraphData {
     /// Returns error if:
     /// - Data is from on-chain source
     /// - Input size is not evenly divisible by batch size
-    pub fn split_into_batches(
+    pub async fn split_into_batches(
         &self,
         input_shapes: Vec<Vec<usize>>,
     ) -> Result<Vec<Self>, GraphError> {
@@ -428,9 +486,18 @@ impl GraphData {
 
         let iterable = match self {
             GraphData {
-                input_data: DataSource(data),
+                input_data: DataSource::File(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(),
+                ));
+            }
         };
 
         // Process each input tensor according to its shape
@@ -476,12 +543,12 @@ impl GraphData {
             for input in batched_inputs.iter() {
                 batch.push(input[i].clone());
             }
-            input_batches.push(DataSource(batch));
+            input_batches.push(DataSource::File(batch));
         }
 
         // Ensure at least one batch exists
         if input_batches.is_empty() {
-            input_batches.push(DataSource(vec![vec![]]));
+            input_batches.push(DataSource::File(vec![vec![]]));
         }
 
         // Create GraphData instance for each batch
@@ -556,7 +623,16 @@ impl ToPyObject for CallToAccount {
 #[cfg(feature = "python-bindings")]
 impl ToPyObject for DataSource {
     fn to_object(&self, py: Python) -> PyObject {
-        self.0.to_object(py)
+        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.call.to_object(py))
+                    .unwrap();
+                dict.to_object(py)
+            }
+        }
     }
 }
 

src/graph/mod.rs

@@ -25,11 +25,9 @@ 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;
@@ -540,38 +538,16 @@ impl GraphSettings {
 
     /// calculate the total number of instances
     pub fn total_instances(&self) -> Vec<usize> {
-        let mut instances: Vec<usize> = self.module_sizes.num_instances();
-        instances.extend(
-            self.model_instance_shapes
-                .iter()
-                .map(|x| x.iter().product::<usize>()),
-        );
+        let mut instances: Vec<usize> = self
+            .model_instance_shapes
+            .iter()
+            .map(|x| x.iter().product())
+            .collect();
+        instances.extend(self.module_sizes.num_instances());
 
         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>();
@@ -595,7 +571,7 @@ impl GraphSettings {
             std::io::BufWriter::with_capacity(*EZKL_BUF_CAPACITY, std::fs::File::create(path)?);
         serde_json::to_writer(writer, &self).map_err(|e| {
             error!("failed to save settings file at {}", e);
-            std::io::Error::new(std::io::ErrorKind::Other, e)
+            std::io::Error::other(e)
         })
     }
     /// load params from file
@@ -605,7 +581,7 @@ impl GraphSettings {
             std::io::BufReader::with_capacity(*EZKL_BUF_CAPACITY, std::fs::File::open(path)?);
         let settings: GraphSettings = serde_json::from_reader(reader).map_err(|e| {
             error!("failed to load settings file at {}", e);
-            std::io::Error::new(std::io::ErrorKind::Other, e)
+            std::io::Error::other(e)
         })?;
 
         crate::check_version_string_matches(&settings.version);
@@ -952,11 +928,111 @@ 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.load_file_data(data.input_data.values(), &shapes, scales, 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)
+            }
+        }
+    }
+
+    /// 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, read_on_chain_inputs, setup_eth_backend};
+        let (client, client_address) = setup_eth_backend(&source.rpc, None).await?;
+        let input = read_on_chain_inputs(client.clone(), client_address, &source.call).await?;
+        let quantized_evm_inputs =
+            evm_quantize(client, scales, &input, &source.call.decimals).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)
     }
 
     ///
@@ -1156,15 +1232,9 @@ impl GraphCircuit {
         let mut cs = ConstraintSystem::default();
         // if unix get a gag
         #[cfg(all(not(not(feature = "ezkl")), unix))]
-        let _r = match Gag::stdout() {
-            Ok(g) => Some(g),
-            _ => None,
-        };
+        let _r = Gag::stdout().ok();
         #[cfg(all(not(not(feature = "ezkl")), unix))]
-        let _g = match Gag::stderr() {
-            Ok(g) => Some(g),
-            _ => None,
-        };
+        let _g = Gag::stderr().ok();
 
         Self::configure_with_params(&mut cs, settings);
 
@@ -1334,6 +1404,85 @@ 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()?;
+        let mut input_data = None;
+        let mut output_data = None;
+
+        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);
+            }
+
+            input_data = match &data.input_data {
+                DataSource::File(input_data) => Some(input_data),
+                _ => {
+                    return Err(GraphError::MissingDataSource);
+                }
+            };
+        }
+        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);
+            }
+
+            output_data = match &data.output_data {
+                Some(DataSource::File(output_data)) => Some(output_data),
+                _ => return Err(GraphError::MissingDataSource),
+            };
+        }
+        // Merge the input and output data
+        let mut file_data: Vec<Vec<input::FileSourceInner>> = vec![];
+        let mut scales: Vec<crate::Scale> = vec![];
+        let mut shapes: Vec<Vec<usize>> = vec![];
+        if let Some(input_data) = input_data {
+            file_data.extend(input_data.clone());
+            scales.extend(input_scales.clone());
+            shapes.extend(input_shapes.clone());
+        }
+        if let Some(output_data) = output_data {
+            file_data.extend(output_data.clone());
+            scales.extend(output_scales.clone());
+            shapes.extend(output_shapes.clone());
+        };
+        // print file data
+        debug!("file data: {:?}", file_data);
+
+        let on_chain_data: OnChainSource =
+            OnChainSource::test_from_file_data(&file_data, scales, shapes, &test_on_chain_data.rpc)
+                .await?;
+        // Here we update the GraphData struct with the on-chain data
+        if input_data.is_some() {
+            data.input_data = on_chain_data.clone().into();
+        }
+        if output_data.is_some() {
+            data.output_data = Some(on_chain_data.into());
+        }
+        debug!("test on-chain data: {:?}", data);
+        // Save the updated GraphData struct to the data_path
+        data.save(test_on_chain_data.data)?;
+        Ok(())
+    }
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
@@ -1421,13 +1570,13 @@ impl Circuit<Fp> for GraphCircuit {
 
         let mut module_configs = ModuleConfigs::from_visibility(
             cs,
-            params.module_sizes.clone(),
+            &params.module_sizes,
             params.run_args.logrows as usize,
         );
 
         let mut vars = ModelVars::new(cs, &params);
 
-        module_configs.configure_complex_modules(cs, visibility, params.module_sizes.clone());
+        module_configs.configure_complex_modules(cs, &visibility, &params.module_sizes);
 
         vars.instantiate_instance(
             cs,

src/graph/model.rs

@@ -200,7 +200,7 @@ fn number_of_iterations(mappings: &[InputMapping], dims: Vec<&[usize]>) -> usize
                 InputMapping::Stacked { axis, chunk } => Some(
                     // number of iterations given the dim size along the axis
                     // and the chunk size
-                    (dims[*axis] + chunk - 1) / chunk,
+                    dims[*axis].div_ceil(*chunk), // (dims[*axis] + chunk - 1) / chunk,
                 ),
                 _ => None,
             });
@@ -589,10 +589,7 @@ impl Model {
             required_range_checks: res.range_checks.into_iter().collect(),
             model_output_scales: self.graph.get_output_scales()?,
             model_input_scales: self.graph.get_input_scales(),
-            input_types: match self.get_input_types() {
-                Ok(x) => Some(x),
-                Err(_) => None,
-            },
+            input_types: self.get_input_types().ok(),
             output_types: Some(self.get_output_types()),
             num_dynamic_lookups: res.num_dynamic_lookups,
             total_dynamic_col_size: res.dynamic_lookup_col_coord,
@@ -650,10 +647,13 @@ impl Model {
         let variables: std::collections::HashMap<String, usize> =
             std::collections::HashMap::from_iter(variables.iter().map(|(k, v)| (k.clone(), *v)));
 
-        for (i, id) in model.clone().inputs.iter().enumerate() {
+        let inputs = model.inputs.clone();
+        let outputs = model.outputs.clone();
+
+        for (i, id) in inputs.iter().enumerate() {
             let input = model.node_mut(id.node);
 
-            if input.outputs.len() == 0 {
+            if input.outputs.is_empty() {
                 return Err(GraphError::MissingOutput(id.node));
             }
             let mut fact: InferenceFact = input.outputs[0].fact.clone();
@@ -672,7 +672,7 @@ impl Model {
             model.set_input_fact(i, fact)?;
         }
 
-        for (i, _) in model.clone().outputs.iter().enumerate() {
+        for (i, _) in outputs.iter().enumerate() {
             model.set_output_fact(i, InferenceFact::default())?;
         }
 
@@ -1196,7 +1196,7 @@ impl Model {
                                 .base
                                 .layout(
                                     &mut thread_safe_region,
-                                    &[output.clone(), comparators],
+                                    &[output, &comparators],
                                     Box::new(HybridOp::Output {
                                         decomp: !run_args.ignore_range_check_inputs_outputs,
                                     }),
@@ -1257,12 +1257,27 @@ impl Model {
                 node.inputs()
                     .iter()
                     .map(|(idx, outlet)| {
-                        Ok(results.get(idx).ok_or(GraphError::MissingResults)?[*outlet].clone())
+                        // check node is not an output
+                        let is_output = self.graph.outputs.iter().any(|(o_idx, _)| *idx == *o_idx);
+
+                        let res = if self.graph.nodes[idx].num_uses() == 1 && !is_output {
+                            let res = results.remove(idx);
+                            res.ok_or(GraphError::MissingResults(*idx))?[*outlet].clone()
+                        } else {
+                            results.get(idx).ok_or(GraphError::MissingResults(*idx))?[*outlet]
+                                .clone()
+                        };
+                        Ok(res)
                     })
                     .collect::<Result<Vec<_>, GraphError>>()?
             } else {
                 // we re-assign inputs, always from the 0 outlet
-                vec![results.get(idx).ok_or(GraphError::MissingResults)?[0].clone()]
+                if self.graph.nodes[idx].num_uses() == 1 {
+                    let res = results.remove(idx);
+                    vec![res.ok_or(GraphError::MissingInput(*idx))?[0].clone()]
+                } else {
+                    vec![results.get(idx).ok_or(GraphError::MissingInput(*idx))?[0].clone()]
+                }
             };
             trace!("output dims: {:?}", node.out_dims());
             trace!(
@@ -1273,7 +1288,7 @@ impl Model {
             let start = instant::Instant::now();
             match &node {
                 NodeType::Node(n) => {
-                    let res = if node.is_constant() && node.num_uses() == 1 {
+                    let mut res = if node.is_constant() && node.num_uses() == 1 {
                         log::debug!("node {} is a constant with 1 use", n.idx);
                         let mut node = n.clone();
                         let c = node
@@ -1284,19 +1299,19 @@ impl Model {
                     } else {
                         config
                             .base
-                            .layout(region, &values, n.opkind.clone_dyn())
+                            .layout(region, &values.iter().collect_vec(), n.opkind.clone_dyn())
                             .map_err(|e| {
                                 error!("{}", e);
                                 halo2_proofs::plonk::Error::Synthesis
                             })?
                     };
 
-                    if let Some(mut vt) = res {
+                    if let Some(vt) = &mut res {
                         vt.reshape(&node.out_dims()[0])?;
-                        // we get the max as for fused nodes this corresponds to the node output
-                        results.insert(*idx, vec![vt.clone()]);
                         //only use with mock prover
                         debug!("------------ output node {:?}: {:?}", idx, vt.show());
+                        // we get the max as for fused nodes this corresponds to the node output
+                        results.insert(*idx, vec![vt.clone()]);
                     }
                 }
                 NodeType::SubGraph {
@@ -1340,7 +1355,7 @@ impl Model {
                                 .inputs
                                 .clone()
                                 .into_iter()
-                                .zip(values.clone().into_iter().map(|v| vec![v])),
+                                .zip(values.iter().map(|v| vec![v.clone()])),
                         );
 
                         let res = model.layout_nodes(config, region, &mut subgraph_results)?;
@@ -1421,7 +1436,7 @@ impl Model {
         );
         let outputs = output_nodes
             .map(|(idx, outlet)| {
-                Ok(results.get(idx).ok_or(GraphError::MissingResults)?[*outlet].clone())
+                Ok(results.get(idx).ok_or(GraphError::MissingResults(*idx))?[*outlet].clone())
             })
             .collect::<Result<Vec<_>, GraphError>>()?;
 
@@ -1476,7 +1491,7 @@ impl Model {
 
                     dummy_config.layout(
                         &mut region,
-                        &[output.clone(), comparator],
+                        &[output, &comparator],
                         Box::new(HybridOp::Output {
                             decomp: !run_args.ignore_range_check_inputs_outputs,
                         }),

src/graph/modules.rs

@@ -37,15 +37,15 @@ impl ModuleConfigs {
     /// Create new module configs from visibility of each variable
     pub fn from_visibility(
         cs: &mut ConstraintSystem<Fp>,
-        module_size: ModuleSizes,
+        module_size: &ModuleSizes,
         logrows: usize,
     ) -> Self {
         let mut config = Self::default();
 
-        for size in module_size.polycommit {
+        for size in &module_size.polycommit {
             config
                 .polycommit
-                .push(PolyCommitChip::configure(cs, (logrows, size)));
+                .push(PolyCommitChip::configure(cs, (logrows, *size)));
         }
 
         config
@@ -55,8 +55,8 @@ impl ModuleConfigs {
     pub fn configure_complex_modules(
         &mut self,
         cs: &mut ConstraintSystem<Fp>,
-        visibility: VarVisibility,
-        module_size: ModuleSizes,
+        visibility: &VarVisibility,
+        module_size: &ModuleSizes,
     ) {
         if (visibility.input.is_hashed()
             || visibility.output.is_hashed()

src/graph/node.rs

@@ -37,6 +37,7 @@ use crate::tensor::TensorError;
 // Import curve-specific field type
 use halo2curves::bn256::Fr as Fp;
 
+use itertools::Itertools;
 // Import logging for EZKL
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 use log::trace;
@@ -118,16 +119,15 @@ impl Op<Fp> for Rescaled {
         &self,
         config: &mut crate::circuit::BaseConfig<Fp>,
         region: &mut crate::circuit::region::RegionCtx<Fp>,
-        values: &[crate::tensor::ValTensor<Fp>],
+        values: &[&crate::tensor::ValTensor<Fp>],
     ) -> Result<Option<crate::tensor::ValTensor<Fp>>, CircuitError> {
         if self.scale.len() != values.len() {
             return Err(TensorError::DimMismatch("rescaled inputs".to_string()).into());
         }
 
         let res =
-            &crate::circuit::layouts::rescale(config, region, values[..].try_into()?, &self.scale)?
-                [..];
-        self.inner.layout(config, region, res)
+            crate::circuit::layouts::rescale(config, region, values[..].try_into()?, &self.scale)?;
+        self.inner.layout(config, region, &res.iter().collect_vec())
     }
 
     /// Create a cloned boxed copy of this operation
@@ -274,13 +274,13 @@ impl Op<Fp> for RebaseScale {
         &self,
         config: &mut crate::circuit::BaseConfig<Fp>,
         region: &mut crate::circuit::region::RegionCtx<Fp>,
-        values: &[crate::tensor::ValTensor<Fp>],
+        values: &[&crate::tensor::ValTensor<Fp>],
     ) -> Result<Option<crate::tensor::ValTensor<Fp>>, CircuitError> {
         let original_res = self
             .inner
             .layout(config, region, values)?
             .ok_or(CircuitError::MissingLayout(self.as_string()))?;
-        self.rebase_op.layout(config, region, &[original_res])
+        self.rebase_op.layout(config, region, &[&original_res])
     }
 
     /// Create a cloned boxed copy of this operation
@@ -472,7 +472,7 @@ impl Op<Fp> for SupportedOp {
         &self,
         config: &mut crate::circuit::BaseConfig<Fp>,
         region: &mut crate::circuit::region::RegionCtx<Fp>,
-        values: &[crate::tensor::ValTensor<Fp>],
+        values: &[&crate::tensor::ValTensor<Fp>],
     ) -> Result<Option<crate::tensor::ValTensor<Fp>>, CircuitError> {
         self.as_op().layout(config, region, values)
     }

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,7 +22,6 @@ 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,
@@ -32,6 +31,7 @@ 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::{

src/lib.rs

@@ -29,8 +29,14 @@
 //! A library for turning computational graphs, such as neural networks, into ZK-circuits.
 //!
 use log::warn;
-#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
-use mimalloc as _;
+
+#[global_allocator]
+#[cfg(all(feature = "jemalloc", not(target_arch = "wasm32")))]
+static GLOBAL: jemallocator::Jemalloc = jemallocator::Jemalloc;
+
+#[global_allocator]
+#[cfg(all(feature = "mimalloc", not(target_arch = "wasm32")))]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
 /// Error type
 // #[cfg_attr(not(feature = "ezkl"), derive(uniffi::Error))]
@@ -44,7 +50,6 @@ 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),
@@ -135,7 +140,7 @@ pub mod circuit;
 /// CLI commands.
 #[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 pub mod commands;
-#[cfg(all(feature = "eth", not(target_arch = "wasm32")))]
+#[cfg(all(feature = "ezkl", not(target_arch = "wasm32")))]
 // abigen doesn't generate docs for this module
 #[allow(missing_docs)]
 /// Utility functions for contracts

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::{
-    Circuit, ProvingKey, VerifyingKey, create_proof, keygen_pk, keygen_vk_custom, verify_proof,
+    create_proof, keygen_pk, keygen_vk_custom, verify_proof, Circuit, ProvingKey, VerifyingKey,
 };
-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"))]
@@ -324,7 +324,7 @@ where
 }
 
 #[cfg(feature = "python-bindings")]
-use pyo3::{PyObject, Python, ToPyObject, types::PyDict};
+use pyo3::{types::PyDict, PyObject, Python, ToPyObject};
 #[cfg(feature = "python-bindings")]
 impl<F: PrimeField + SerdeObject + Serialize, C: CurveAffine + Serialize> ToPyObject for Snark<F, C>
 where
@@ -348,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::{IntegerRep, integer_rep_to_felt},
+    fieldutils::{integer_rep_to_felt, IntegerRep},
     graph::Visibility,
 };
 
@@ -42,11 +42,11 @@ use std::error::Error;
 use std::fmt::Debug;
 use std::io::Read;
 use std::iter::Iterator;
+use std::ops::Rem;
 use std::ops::{Add, Deref, DerefMut, Div, Mul, Neg, Range, Sub};
-use std::{cmp::max, ops::Rem};
 
 /// The (inner) type of tensor elements.
-pub trait TensorType: Clone + Debug + 'static {
+pub trait TensorType: Clone + Debug {
     /// Returns the zero value.
     fn zero() -> Option<Self> {
         None
@@ -55,10 +55,6 @@ pub trait TensorType: Clone + Debug + 'static {
     fn one() -> Option<Self> {
         None
     }
-    /// Max operator for ordering values.
-    fn tmax(&self, _: &Self) -> Option<Self> {
-        None
-    }
 }
 
 macro_rules! tensor_type {
@@ -70,10 +66,6 @@ macro_rules! tensor_type {
             fn one() -> Option<Self> {
                 Some($one)
             }
-
-            fn tmax(&self, other: &Self) -> Option<Self> {
-                Some(max(*self, *other))
-            }
         }
     };
 }
@@ -82,46 +74,12 @@ impl TensorType for f32 {
     fn zero() -> Option<Self> {
         Some(0.0)
     }
-
-    // f32 doesnt impl Ord so we cant just use max like we can for IntegerRep, usize.
-    // A comparison between f32s needs to handle NAN values.
-    fn tmax(&self, other: &Self) -> Option<Self> {
-        match (self.is_nan(), other.is_nan()) {
-            (true, true) => Some(f32::NAN),
-            (true, false) => Some(*other),
-            (false, true) => Some(*self),
-            (false, false) => {
-                if self >= other {
-                    Some(*self)
-                } else {
-                    Some(*other)
-                }
-            }
-        }
-    }
 }
 
 impl TensorType for f64 {
     fn zero() -> Option<Self> {
         Some(0.0)
     }
-
-    // f32 doesnt impl Ord so we cant just use max like we can for IntegerRep, usize.
-    // A comparison between f32s needs to handle NAN values.
-    fn tmax(&self, other: &Self) -> Option<Self> {
-        match (self.is_nan(), other.is_nan()) {
-            (true, true) => Some(f64::NAN),
-            (true, false) => Some(*other),
-            (false, true) => Some(*self),
-            (false, false) => {
-                if self >= other {
-                    Some(*self)
-                } else {
-                    Some(*other)
-                }
-            }
-        }
-    }
 }
 
 tensor_type!(bool, Bool, false, true);
@@ -147,14 +105,6 @@ impl<T: TensorType> TensorType for Value<T> {
     fn one() -> Option<Self> {
         Some(Value::known(T::one().unwrap()))
     }
-
-    fn tmax(&self, other: &Self) -> Option<Self> {
-        Some(
-            (self.clone())
-                .zip(other.clone())
-                .map(|(a, b)| a.tmax(&b).unwrap()),
-        )
-    }
 }
 
 impl<F: PrimeField + PartialOrd> TensorType for Assigned<F>
@@ -168,14 +118,6 @@ where
     fn one() -> Option<Self> {
         Some(F::ONE.into())
     }
-
-    fn tmax(&self, other: &Self) -> Option<Self> {
-        if self.evaluate() >= other.evaluate() {
-            Some(*self)
-        } else {
-            Some(*other)
-        }
-    }
 }
 
 impl<F: PrimeField> TensorType for Expression<F>
@@ -189,42 +131,14 @@ where
     fn one() -> Option<Self> {
         Some(Expression::Constant(F::ONE))
     }
-
-    fn tmax(&self, _: &Self) -> Option<Self> {
-        todo!()
-    }
 }
 
 impl TensorType for Column<Advice> {}
 impl TensorType for Column<Fixed> {}
 
-impl<F: PrimeField + PartialOrd> TensorType for AssignedCell<Assigned<F>, F> {
-    fn tmax(&self, other: &Self) -> Option<Self> {
-        let mut output: Option<Self> = None;
-        self.value_field().zip(other.value_field()).map(|(a, b)| {
-            if a.evaluate() >= b.evaluate() {
-                output = Some(self.clone());
-            } else {
-                output = Some(other.clone());
-            }
-        });
-        output
-    }
-}
+impl<F: PrimeField + PartialOrd> TensorType for AssignedCell<Assigned<F>, F> {}
 
-impl<F: PrimeField + PartialOrd> TensorType for AssignedCell<F, F> {
-    fn tmax(&self, other: &Self) -> Option<Self> {
-        let mut output: Option<Self> = None;
-        self.value().zip(other.value()).map(|(a, b)| {
-            if a >= b {
-                output = Some(self.clone());
-            } else {
-                output = Some(other.clone());
-            }
-        });
-        output
-    }
-}
+impl<F: PrimeField + PartialOrd> TensorType for AssignedCell<F, F> {}
 
 // specific types
 impl TensorType for halo2curves::pasta::Fp {
@@ -235,10 +149,6 @@ impl TensorType for halo2curves::pasta::Fp {
     fn one() -> Option<Self> {
         Some(halo2curves::pasta::Fp::one())
     }
-
-    fn tmax(&self, other: &Self) -> Option<Self> {
-        Some((*self).max(*other))
-    }
 }
 
 impl TensorType for halo2curves::bn256::Fr {
@@ -249,9 +159,15 @@ impl TensorType for halo2curves::bn256::Fr {
     fn one() -> Option<Self> {
         Some(halo2curves::bn256::Fr::one())
     }
+}
 
-    fn tmax(&self, other: &Self) -> Option<Self> {
-        Some((*self).max(*other))
+impl<F: TensorType> TensorType for &F {
+    fn zero() -> Option<Self> {
+        None
+    }
+
+    fn one() -> Option<Self> {
+        None
     }
 }
 
@@ -374,7 +290,7 @@ impl<T: Clone + TensorType + std::marker::Send + std::marker::Sync>
     }
 }
 
-impl<'data, T: Clone + TensorType + std::marker::Send + std::marker::Sync>
+impl<'data, T: Clone + TensorType + std::marker::Send + std::marker::Sync + 'data>
     maybe_rayon::iter::IntoParallelRefMutIterator<'data> for Tensor<T>
 {
     type Iter = maybe_rayon::slice::IterMut<'data, T>;
@@ -423,6 +339,14 @@ impl<T: Clone + TensorType + PrimeField> Tensor<T> {
     }
 }
 
+impl<T: Clone + TensorType> Tensor<&T> {
+    /// Clones the tensor values into a new tensor.
+    pub fn cloned(&self) -> Tensor<T> {
+        let inner = self.inner.clone().into_iter().cloned().collect::<Vec<T>>();
+        Tensor::new(Some(&inner), &self.dims).unwrap()
+    }
+}
+
 impl<T: Clone + TensorType> Tensor<T> {
     /// Sets (copies) the tensor values to the provided ones.
     pub fn new(values: Option<&[T]>, dims: &[usize]) -> Result<Self, TensorError> {
@@ -554,7 +478,6 @@ impl<T: Clone + TensorType> Tensor<T> {
     /// let mut a = Tensor::<IntegerRep>::new(Some(&[1,2,3,4,5,6]), &[2, 3]).unwrap();
     /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6, 0, 0]), &[8]).unwrap();
     /// assert_eq!(a.pad_to_zero_rem(4, 0).unwrap(), expected);
-    ///
     /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6, 0, 0, 0]), &[9]).unwrap();
     /// assert_eq!(a.pad_to_zero_rem(9, 0).unwrap(), expected);
     /// ```
@@ -631,23 +554,23 @@ impl<T: Clone + TensorType> Tensor<T> {
         // Fill remaining dimensions
         full_indices.extend((indices.len()..self.dims.len()).map(|i| 0..self.dims[i]));
 
-        // Pre-calculate total size and allocate result vector
-        let total_size: usize = full_indices
-            .iter()
-            .map(|range| range.end - range.start)
-            .product();
-        let mut res = Vec::with_capacity(total_size);
-
         // Calculate new dimensions once
         let dims: Vec<usize> = full_indices.iter().map(|e| e.end - e.start).collect();
 
-        // Use iterator directly without collecting into intermediate Vec
-        for coord in full_indices.iter().cloned().multi_cartesian_product() {
-            let index = self.get_index(&coord);
-            res.push(self[index].clone());
-        }
+        let mut output = Tensor::new(None, &dims)?;
 
-        Tensor::new(Some(&res), &dims)
+        let cartesian_coord: Vec<Vec<usize>> = full_indices
+            .iter()
+            .cloned()
+            .multi_cartesian_product()
+            .collect();
+
+        output.par_iter_mut().enumerate().for_each(|(i, e)| {
+            let coord = &cartesian_coord[i];
+            *e = self.get(coord);
+        });
+
+        Ok(output)
     }
 
     /// Set a slice of the Tensor.
@@ -753,7 +676,7 @@ impl<T: Clone + TensorType> Tensor<T> {
     /// ```
     pub fn get_every_n(&self, n: usize) -> Result<Tensor<T>, TensorError> {
         let mut inner: Vec<T> = vec![];
-        for (i, elem) in self.inner.clone().into_iter().enumerate() {
+        for (i, elem) in self.inner.iter().enumerate() {
             if i % n == 0 {
                 inner.push(elem.clone());
             }
@@ -776,7 +699,7 @@ impl<T: Clone + TensorType> Tensor<T> {
     /// ```
     pub fn exclude_every_n(&self, n: usize) -> Result<Tensor<T>, TensorError> {
         let mut inner: Vec<T> = vec![];
-        for (i, elem) in self.inner.clone().into_iter().enumerate() {
+        for (i, elem) in self.inner.iter().enumerate() {
             if i % n != 0 {
                 inner.push(elem.clone());
             }
@@ -812,9 +735,9 @@ impl<T: Clone + TensorType> Tensor<T> {
 
         let mut inner: Vec<T> = Vec::with_capacity(self.inner.len());
         let mut offset = initial_offset;
-        for (i, elem) in self.inner.clone().into_iter().enumerate() {
+        for (i, elem) in self.inner.iter().enumerate() {
             if (i + offset + 1) % n == 0 {
-                inner.extend(vec![elem; 1 + num_repeats]);
+                inner.extend(vec![elem.clone(); 1 + num_repeats]);
                 offset += num_repeats;
             } else {
                 inner.push(elem.clone());
@@ -871,16 +794,16 @@ impl<T: Clone + TensorType> Tensor<T> {
     /// ```
     /// use ezkl::tensor::Tensor;
     /// use ezkl::fieldutils::IntegerRep;
-    /// let a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6]), &[6]).unwrap();
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6]), &[6]).unwrap();
     /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 6]), &[4]).unwrap();
     /// let mut indices = vec![3, 4];
-    /// assert_eq!(a.remove_indices(&mut indices, true).unwrap(), expected);
+    /// assert_eq!(a.remove_indices(&mut indices, false).unwrap(), expected);
     ///
     ///
     /// let a = Tensor::<IntegerRep>::new(Some(&[52, -245, 153, 13, -4, -56, -163, 249, -128, -172, 396, 143, 2, -96, 504, -44, -158, -393, 61, 95, 191, 74, 64, -219, 553, 104, 235, 222, 44, -216, 63, -251, 40, -140, 112, -355, 60, 123, 26, -116, -89, -200, -109, 168, 135, -34, -99, -54, 5, -81, 322, 87, 4, -139, 420, 92, -295, -12, 262, -1, 26, -48, 231, 1, -335, 244, 188, -4, 5, -362, 57, -198, -184, -117, 40, 305, 49, 30, -59, -26, -37, 96]), &[82]).unwrap();
     /// let b = Tensor::<IntegerRep>::new(Some(&[52, -245, 153, 13, -4, -56, -163, 249, -128, -172, 396, 143, 2, -96, 504, -44, -158, -393, 61, 95, 191, 74, 64, -219, 553, 104, 235, 222, 44, -216, 63, -251, 40, -140, 112, -355, 60, 123, 26, -116, -89, -200, -109, 168, 135, -34, -99, -54, 5, -81, 322, 87, 4, -139, 420, 92, -295, -12, 262, -1, 26, -48, 231, -335, 244, 188, 5, -362, 57, -198, -184, -117, 40, 305, 49, 30, -59, -26, -37, 96]), &[80]).unwrap();
     /// let mut indices = vec![63, 67];
-    /// assert_eq!(a.remove_indices(&mut indices, true).unwrap(), b);
+    /// assert_eq!(a.remove_indices(&mut indices, false).unwrap(), b);
     /// ```
     pub fn remove_indices(
         &self,
@@ -927,7 +850,7 @@ impl<T: Clone + TensorType> Tensor<T> {
             }
             self.dims = vec![];
         }
-        if self.dims() == &[0] && new_dims.iter().product::<usize>() == 1 {
+        if self.dims() == [0] && new_dims.iter().product::<usize>() == 1 {
             self.dims = Vec::from(new_dims);
         } else {
             let product = if new_dims != [0] {
@@ -1292,33 +1215,6 @@ impl<T: Clone + TensorType> Tensor<T> {
 
         Tensor::new(Some(&[res]), &[1])
     }
-
-    /// Maps a function to tensors and enumerates in parallel
-    /// ```
-    /// use ezkl::tensor::{Tensor, TensorError};
-    /// use ezkl::fieldutils::IntegerRep;
-    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 4]), &[2]).unwrap();
-    /// let mut c = a.par_enum_map::<_,_,TensorError>(|i, x| Ok(IntegerRep::pow(x + i as IntegerRep, 2))).unwrap();
-    /// assert_eq!(c, Tensor::from([1, 25].into_iter()));
-    /// ```
-    pub fn par_enum_map_mut_filtered<
-        F: Fn(usize) -> Result<T, E> + std::marker::Send + std::marker::Sync,
-        E: Error + std::marker::Send + std::marker::Sync,
-    >(
-        &mut self,
-        filter_indices: &std::collections::HashSet<usize>,
-        f: F,
-    ) -> Result<(), E>
-    where
-        T: std::marker::Send + std::marker::Sync,
-    {
-        self.inner
-            .par_iter_mut()
-            .enumerate()
-            .filter(|(i, _)| filter_indices.contains(i))
-            .for_each(move |(i, e)| *e = f(i).unwrap());
-        Ok(())
-    }
 }
 
 impl<T: Clone + TensorType> Tensor<Tensor<T>> {
@@ -1335,9 +1231,9 @@ impl<T: Clone + TensorType> Tensor<Tensor<T>> {
     pub fn combine(&self) -> Result<Tensor<T>, TensorError> {
         let mut dims = 0;
         let mut inner = Vec::new();
-        for t in self.inner.clone().into_iter() {
+        for t in self.inner.iter() {
             dims += t.len();
-            inner.extend(t.inner);
+            inner.extend(t.inner.clone());
         }
         Tensor::new(Some(&inner), &[dims])
     }
@@ -1808,7 +1704,7 @@ impl DataFormat {
         match self {
             DataFormat::NHWC => DataFormat::NCHW,
             DataFormat::HWC => DataFormat::CHW,
-            _ => self.clone(),
+            _ => *self,
         }
     }
 
@@ -1908,7 +1804,7 @@ impl KernelFormat {
         match self {
             KernelFormat::HWIO => KernelFormat::OIHW,
             KernelFormat::OHWI => KernelFormat::OIHW,
-            _ => self.clone(),
+            _ => *self,
         }
     }
 
@@ -2030,6 +1926,9 @@ mod tests {
     fn tensor_slice() {
         let a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6]), &[2, 3]).unwrap();
         let b = Tensor::<IntegerRep>::new(Some(&[1, 4]), &[2, 1]).unwrap();
-        assert_eq!(a.get_slice(&[0..2, 0..1]).unwrap(), b);
+        assert_eq!(
+            a.get_slice(&[0..2, 0..1]).unwrap(),
+            b.get_slice(&[0..2, 0..1]).unwrap()
+        );
     }
 }

src/tensor/ops.rs

@@ -916,11 +916,14 @@ pub fn gather_elements<T: TensorType + Send + Sync>(
 /// let expected = Tensor::<IntegerRep>::new(Some(&[2, 7]), &[2]).unwrap();
 /// assert_eq!(result, expected);
 ///
-pub fn gather_nd<T: TensorType + Send + Sync>(
-    input: &Tensor<T>,
+pub fn gather_nd<'a, T: TensorType + Send + Sync + 'a>(
+    input: &'a Tensor<T>,
     index: &Tensor<usize>,
     batch_dims: usize,
-) -> Result<Tensor<T>, TensorError> {
+) -> Result<Tensor<T>, TensorError>
+where
+    &'a T: TensorType,
+{
     // Calculate the output tensor size
     let index_dims = index.dims().to_vec();
     let input_dims = input.dims().to_vec();
@@ -1108,11 +1111,14 @@ pub fn gather_nd<T: TensorType + Send + Sync>(
 /// assert_eq!(result, expected);
 /// ````
 ///
-pub fn scatter_nd<T: TensorType + Send + Sync>(
+pub fn scatter_nd<'a, T: TensorType + Send + Sync + 'a>(
     input: &Tensor<T>,
     index: &Tensor<usize>,
-    src: &Tensor<T>,
-) -> Result<Tensor<T>, TensorError> {
+    src: &'a Tensor<T>,
+) -> Result<Tensor<T>, TensorError>
+where
+    &'a T: TensorType,
+{
     // Calculate the output tensor size
     let index_dims = index.dims().to_vec();
     let input_dims = input.dims().to_vec();
@@ -1183,12 +1189,12 @@ pub fn abs<T: TensorType + Add<Output = T> + std::cmp::Ord + Neg<Output = T>>(
 /// use ezkl::tensor::ops::intercalate_values;
 ///
 /// let tensor = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4]), &[2, 2]).unwrap();
-/// let result = intercalate_values(&tensor, 0, 2, 1).unwrap();
+/// let result = intercalate_values(&tensor, &0, 2, 1).unwrap();
 ///
 /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 0, 2, 3, 0, 4]), &[2, 3]).unwrap();
 /// assert_eq!(result, expected);
 ///
-/// let result = intercalate_values(&expected, 0, 2, 0).unwrap();
+/// let result = intercalate_values(&expected, &0, 2, 0).unwrap();
 /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 0, 2, 0, 0, 0, 3, 0, 4]), &[3, 3]).unwrap();
 ///
 /// assert_eq!(result, expected);
@@ -1196,7 +1202,7 @@ pub fn abs<T: TensorType + Add<Output = T> + std::cmp::Ord + Neg<Output = T>>(
 /// ```
 pub fn intercalate_values<T: TensorType>(
     tensor: &Tensor<T>,
-    value: T,
+    value: &T,
     stride: usize,
     axis: usize,
 ) -> Result<Tensor<T>, TensorError> {
@@ -1494,7 +1500,7 @@ pub fn slice<T: TensorType + Send + Sync>(
         }
     }
 
-    t.get_slice(&slice)
+    Ok(t.get_slice(&slice)?)
 }
 
 // ---------------------------------------------------------------------------------------------------------
@@ -2414,20 +2420,20 @@ pub mod accumulated {
     ///     Some(&[25, 35]),
     ///     &[2],
     /// ).unwrap();
-    /// assert_eq!(dot(&[x, y], 1).unwrap(), expected);
+    /// assert_eq!(dot(&x, &y, 1).unwrap(), expected);
     /// ```
     pub fn dot<T: TensorType + Mul<Output = T> + Add<Output = T>>(
-        inputs: &[Tensor<T>; 2],
+        a: &Tensor<T>,
+        b: &Tensor<T>,
         chunk_size: usize,
     ) -> Result<Tensor<T>, TensorError> {
-        if inputs[0].clone().len() != inputs[1].clone().len() {
+        if a.len() != b.len() {
             return Err(TensorError::DimMismatch("dot".to_string()));
         }
-        let (a, b): (Tensor<T>, Tensor<T>) = (inputs[0].clone(), inputs[1].clone());
 
         let transcript: Tensor<T> = a
             .iter()
-            .zip(b)
+            .zip(b.iter())
             .chunks(chunk_size)
             .into_iter()
             .scan(T::zero().unwrap(), |acc, chunk| {

src/tensor/val.rs

@@ -280,9 +280,17 @@ impl<F: PrimeField + TensorType + PartialOrd> From<Vec<ValType<F>>> for ValTenso
     fn from(t: Vec<ValType<F>>) -> ValTensor<F> {
         ValTensor::Value {
             inner: t.clone().into_iter().into(),
-
             dims: vec![t.len()],
+            scale: 1,
+        }
+    }
+}
 
+impl<F: PrimeField + TensorType + PartialOrd> From<Vec<&ValType<F>>> for ValTensor<F> {
+    fn from(t: Vec<&ValType<F>>) -> ValTensor<F> {
+        ValTensor::Value {
+            inner: t.clone().into_iter().cloned().into(),
+            dims: vec![t.len()],
             scale: 1,
         }
     }
@@ -640,6 +648,9 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
     /// # Returns
     /// A tensor containing the base-n decomposition of each value
     pub fn decompose(&self, base: usize, n: usize) -> Result<Self, TensorError> {
+        let mut dims = self.dims().to_vec();
+        dims.push(n + 1);
+
         let res = self
             .get_inner()?
             .par_iter()
@@ -665,9 +676,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
             })
             .collect::<Result<Vec<_>, _>>();
 
-        let mut tensor = Tensor::from(res?.into_iter().flatten().collect::<Vec<_>>().into_iter());
-        let mut dims = self.dims().to_vec();
-        dims.push(n + 1);
+        let mut tensor = res?.into_iter().flatten().collect::<Tensor<_>>();
 
         tensor.reshape(&dims)?;
 
@@ -1043,119 +1052,6 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
         Ok(())
     }
 
-    /// Removes constant zero values from the tensor
-    /// Uses parallel processing for tensors larger than a threshold
-    pub fn remove_const_zero_values(&mut self) {
-        let size_threshold = 1_000_000; // Tuned using benchmarks
-
-        if self.len() < size_threshold {
-            // Single-threaded for small tensors
-            match self {
-                ValTensor::Value { inner: v, dims, .. } => {
-                    *v = v
-                        .clone()
-                        .into_iter()
-                        .filter_map(|e| {
-                            if let ValType::Constant(r) = e {
-                                if r == F::ZERO {
-                                    return None;
-                                }
-                            } else if let ValType::AssignedConstant(_, r) = e {
-                                if r == F::ZERO {
-                                    return None;
-                                }
-                            }
-                            Some(e)
-                        })
-                        .collect();
-                    *dims = v.dims().to_vec();
-                }
-                ValTensor::Instance { .. } => {}
-            }
-        } else {
-            // Parallel processing for large tensors
-            let num_cores = std::thread::available_parallelism()
-                .map(|n| n.get())
-                .unwrap_or(1);
-            let chunk_size = (self.len() / num_cores).max(100_000);
-
-            match self {
-                ValTensor::Value { inner: v, dims, .. } => {
-                    *v = v
-                        .par_chunks_mut(chunk_size)
-                        .flat_map(|chunk| {
-                            chunk.par_iter_mut().filter_map(|e| {
-                                if let ValType::Constant(r) = e {
-                                    if *r == F::ZERO {
-                                        return None;
-                                    }
-                                } else if let ValType::AssignedConstant(_, r) = e {
-                                    if *r == F::ZERO {
-                                        return None;
-                                    }
-                                }
-                                Some(e.clone())
-                            })
-                        })
-                        .collect();
-                    *dims = v.dims().to_vec();
-                }
-                ValTensor::Instance { .. } => {}
-            }
-        }
-    }
-
-    /// Gets the indices of all constant zero values
-    /// Uses parallel processing for large tensors
-    ///
-    /// # Returns
-    /// A vector of indices where constant zero values are located
-    pub fn get_const_zero_indices(&self) -> Vec<usize> {
-        let size_threshold = 1_000_000;
-
-        if self.len() < size_threshold {
-            // Single-threaded for small tensors
-            match &self {
-                ValTensor::Value { inner: v, .. } => v
-                    .iter()
-                    .enumerate()
-                    .filter_map(|(i, e)| match e {
-                        ValType::Constant(r) | ValType::AssignedConstant(_, r) => {
-                            (*r == F::ZERO).then_some(i)
-                        }
-                        _ => None,
-                    })
-                    .collect(),
-                ValTensor::Instance { .. } => vec![],
-            }
-        } else {
-            // Parallel processing for large tensors
-            let num_cores = std::thread::available_parallelism()
-                .map(|n| n.get())
-                .unwrap_or(1);
-            let chunk_size = (self.len() / num_cores).max(100_000);
-
-            match &self {
-                ValTensor::Value { inner: v, .. } => v
-                    .par_chunks(chunk_size)
-                    .enumerate()
-                    .flat_map(|(chunk_idx, chunk)| {
-                        chunk
-                            .par_iter()
-                            .enumerate()
-                            .filter_map(move |(i, e)| match e {
-                                ValType::Constant(r) | ValType::AssignedConstant(_, r) => {
-                                    (*r == F::ZERO).then_some(chunk_idx * chunk_size + i)
-                                }
-                                _ => None,
-                            })
-                    })
-                    .collect::<Vec<_>>(),
-                ValTensor::Instance { .. } => vec![],
-            }
-        }
-    }
-
     /// Gets the indices of all constant values
     /// Uses parallel processing for large tensors
     ///
@@ -1276,7 +1172,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
     /// Returns an error if called on an Instance tensor
     pub fn intercalate_values(
         &mut self,
-        value: ValType<F>,
+        value: &ValType<F>,
         stride: usize,
         axis: usize,
     ) -> Result<(), TensorError> {
@@ -1368,10 +1264,10 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
     }
 
     /// Concatenates two tensors along the first dimension
-    pub fn concat(&self, other: Self) -> Result<Self, TensorError> {
+    pub fn concat(&self, other: &Self) -> Result<Self, TensorError> {
         let res = match (self, other) {
             (ValTensor::Value { inner: v1, .. }, ValTensor::Value { inner: v2, .. }) => {
-                ValTensor::from(Tensor::new(Some(&[v1.clone(), v2]), &[2])?.combine()?)
+                ValTensor::from(Tensor::new(Some(&[v1.clone(), v2.clone()]), &[2])?.combine()?)
             }
             _ => {
                 return Err(TensorError::WrongMethod);

src/tensor/var.rs

@@ -1,8 +1,6 @@
-use std::collections::HashSet;
-
 use log::{debug, error, warn};
 
-use crate::circuit::{CheckMode, region::ConstantsMap};
+use crate::circuit::{region::ConstantsMap, CheckMode};
 
 use super::*;
 /// A wrapper around Halo2's Column types that represents a tensor of variables in the circuit.
@@ -381,50 +379,6 @@ impl VarTensor {
         }
     }
 
-    /// Assigns values from a ValTensor to this tensor, excluding specified positions
-    ///
-    /// # Arguments
-    /// * `region` - The region to assign values in
-    /// * `offset` - Base offset for assignments
-    /// * `values` - The ValTensor containing values to assign
-    /// * `omissions` - Set of positions to skip during assignment
-    /// * `constants` - Map for tracking constant assignments
-    ///
-    /// # Returns
-    /// The assigned ValTensor or an error if assignment fails
-    pub fn assign_with_omissions<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
-        &self,
-        region: &mut Region<F>,
-        offset: usize,
-        values: &ValTensor<F>,
-        omissions: &HashSet<usize>,
-        constants: &mut ConstantsMap<F>,
-    ) -> Result<ValTensor<F>, halo2_proofs::plonk::Error> {
-        let mut assigned_coord = 0;
-        let mut res: ValTensor<F> = match values {
-            ValTensor::Instance { .. } => {
-                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| {
-                    if omissions.contains(&coord) {
-                        return Ok::<_, halo2_proofs::plonk::Error>(k);
-                    }
-                    let cell =
-                        self.assign_value(region, offset, k.clone(), assigned_coord, constants)?;
-                    assigned_coord += 1;
-                    Ok::<_, halo2_proofs::plonk::Error>(cell)
-                })?
-                .into(),
-            ),
-        }?;
-        res.set_scale(values.scale());
-        Ok(res)
-    }
-
     /// Assigns values from a ValTensor to this tensor
     ///
     /// # Arguments

tests/integration_tests.rs

@@ -3,8 +3,8 @@
 mod native_tests {
 
     // use ezkl::circuit::table::RESERVED_BLINDING_ROWS_PAD;
-    use ezkl::graph::input::{FileSource, GraphData};
-    use ezkl::graph::GraphSettings;
+    use ezkl::graph::input::{FileSource, FileSourceInner, GraphData};
+    use ezkl::graph::{DataSource, GraphSettings, GraphWitness};
     use ezkl::pfsys::Snark;
     use ezkl::Commitments;
     use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
@@ -163,14 +163,17 @@ mod native_tests {
             let data = GraphData::from_path(format!("{}/{}/input.json", test_dir, test).into())
                 .expect("failed to load input data");
 
-            let duplicated_input_data: FileSource = data
-                .input_data
-                .values()
+            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
                 .iter()
                 .map(|data| (0..num_batches).flat_map(|_| data.clone()).collect())
                 .collect();
 
-            let duplicated_data = GraphData::new(duplicated_input_data.into());
+            let duplicated_data = GraphData::new(DataSource::File(duplicated_input_data));
 
             let res =
                 duplicated_data.save(format!("{}/{}/input.json", test_dir, output_dir).into());
@@ -988,6 +991,7 @@ 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;
@@ -1002,6 +1006,101 @@ 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])])*
@@ -2093,14 +2192,15 @@ mod native_tests {
             }
         };
 
-        let arg_vka: String = format!("--vka-path={}/{}/vka.bytes", test_dir, example_name);
+        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);
         // create the verifier
         let args = vec![
             "create-evm-vka",
             "--vk-path",
             &vk_arg,
             &settings_arg,
-            &arg_vka,
+            &sol_arg_vk,
         ];
 
         let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
@@ -2109,12 +2209,13 @@ mod native_tests {
             .expect("failed to execute process");
         assert!(status.success());
 
-        // register the vka
+        // deploy the vka
         let args = vec![
-            "register-vka",
+            "deploy-evm",
             rpc_arg.as_str(),
-            arg_vka.as_str(),
-            deployed_addr_arg.as_str(),
+            addr_path_arg_vk.as_str(),
+            sol_arg_vk.as_str(),
+            "-C=vka",
         ];
 
         let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
@@ -2123,13 +2224,19 @@ 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),
-                &arg_vka,
+                &deployed_addr_arg_vk,
             ])
             .status()
             .expect("failed to execute process");
@@ -2144,7 +2251,7 @@ mod native_tests {
             pf_arg.as_str(),
             rpc_arg.as_str(),
             deployed_addr_arg.as_str(),
-            arg_vka.as_str(),
+            deployed_addr_arg_vk.as_str(),
         ];
 
         let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
@@ -2222,6 +2329,298 @@ 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 args = vec![
+                "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(),
+            ];
+
+            let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+                .args(args)
+                .status()
+                .expect("failed to execute process");
+            assert!(status.success());
+            // generate the witness, passing the vk path to generate the necessary kzg commits only
+            // if input visibility is NOT hashed
+            if input_visibility != "hashed" {
+                let status = Command::new(format!("{}/{}", *CARGO_TARGET_DIR, TEST_BINARY))
+                    .args([
+                        "gen-witness",
+                        "-D",
+                        &test_on_chain_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());
+            }
+        }
+
+        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());
+    }
+
     fn build_ezkl() {
         #[cfg(feature = "icicle")]
         let args = [
@@ -2244,7 +2643,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(feature = "eth-original-lookup")]
+        #[cfg(not(feature = "mv-lookup"))]
         let args = [
             "build",
             "--profile=test-runs",
@@ -2252,7 +2651,7 @@ mod native_tests {
             "ezkl",
             "--no-default-features",
             "--features",
-            "ezkl,solidity-verifier,eth",
+            "ezkl",
         ];
 
         let status = Command::new("cargo")

tests/py_integration_tests.rs

@@ -146,7 +146,7 @@ mod py_tests {
         }
     }
 
-    const TESTS: [&str; 31] = [
+    const TESTS: [&str; 35] = [
         "mnist_gan.ipynb",                         // 0
         "ezkl_demo_batch.ipynb",                   // 1
         "proof_splitting.ipynb",                   // 2
@@ -155,29 +155,33 @@ mod py_tests {
         "mnist_gan_proof_splitting.ipynb",         // 5
         "hashed_vis.ipynb",                        // 6
         "simple_demo_all_public.ipynb",            // 7
-        "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
+        "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
     ];
 
     macro_rules! test_func {
@@ -190,7 +194,7 @@ mod py_tests {
             use super::*;
 
 
-            seq!(N in 0..=30 {
+            seq!(N in 0..=32 {
 
             #(#[test_case(TESTS[N])])*
             fn run_notebook_(test: &str) {

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')
-    vka_path = os.path.join(folder_path, 'vka.calldata')
+    vk_code_path = os.path.join(folder_path, 'test_vk.sol')
     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,8 +455,9 @@ async def test_create_evm_verifier_separate_vk():
     res = await ezkl.create_evm_vka(
         vk_path,
         settings_path,
-        vka_path,
-        srs_path=srs_path
+        vk_code_path,
+        abi_vk_path,
+        srs_path=srs_path,
     )
 
     assert res == True
@@ -471,7 +472,7 @@ 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')
-    vka_path = os.path.join(folder_path, 'vka.calldata')
+    vk_code_path = os.path.join(folder_path, 'test_vk.sol')
 
     # TODO: without optimization there will be out of gas errors
     # sol_code_path = os.path.join(folder_path, 'test.sol')
@@ -483,14 +484,11 @@ async def test_deploy_evm_reusable_and_vka():
         "verifier/reusable",
     )
 
-    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,
+    res = await ezkl.deploy_evm(
+        addr_path_vk,
         anvil_url,
-        vka_path=vka_path,
+        vk_code_path,
+        "vka",
     )
 
     assert res == True
@@ -581,7 +579,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')
-    vka_path = os.path.join(folder_path, 'vka.calldata')
+    addr_path_vk = os.path.join(folder_path, 'address_vk.json')
     proof_path = os.path.join(folder_path, 'test_evm.pf')
     calldata_path = os.path.join(folder_path, 'calldata_separate.bytes')
 
@@ -590,8 +588,13 @@ 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, vka_path=vka_path)
+    res = ezkl.encode_evm_calldata(proof_path, calldata_path, addr_vk=addr_vk)
 
     assert os.path.isfile(calldata_path)
     assert len(res) > 0
@@ -603,7 +606,7 @@ async def test_verify_evm_separate_vk():
         addr_verifier,
         anvil_url,
         proof_path,
-        vka_path=vka_path,
+        addr_vk=addr_vk,
         # sol_code_path
         # optimizer_runs
     )