Merge branch 'main' into example-reorg

.github/workflows/large-tests.yml

@@ -11,7 +11,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - name: nanoGPT Mock

.github/workflows/release.yml

@@ -45,7 +45,7 @@ jobs:
     steps:
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - name: Checkout repo

.github/workflows/rust.yml

@@ -26,7 +26,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - name: Build
@@ -38,7 +38,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - name: Docs
@@ -50,7 +50,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -73,7 +73,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -106,7 +106,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -139,7 +139,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -172,7 +172,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -189,7 +189,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: jetli/wasm-pack-action@v0.4.0
@@ -198,8 +198,10 @@ jobs:
         #   chromedriver-version: "115.0.5790.102"
       - name: Install wasm32-unknown-unknown
         run: rustup target add wasm32-unknown-unknown
+      - name: Install wasm runner
+        run: cargo install wasm-server-runner
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-01-04-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
       - name: Run wasm verifier tests
         # on mac:
         #   AR=/opt/homebrew/opt/llvm/bin/llvm-ar CC=/opt/homebrew/opt/llvm/bin/clang wasm-pack test --firefox --headless -- -Z build-std="panic_abort,std" --features web
@@ -212,7 +214,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -229,15 +231,13 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
-      - name: public outputs and tolerance > 0
-        run: cargo nextest run --release --verbose tests::mock_tolerance_public_outputs_ --test-threads 32
       - name: public outputs + batch size == 10
         run: cargo nextest run --release --verbose tests::mock_large_batch_public_outputs_ --test-threads 32
       - name: kzg inputs
@@ -286,7 +286,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -303,28 +303,16 @@ jobs:
         with:
           node-version: "18.12.1"
           cache: "pnpm"
-      - name: Install dependencies for js tests and in-browser-evm-verifier package
+      - name: Install dependencies
         run: |
           pnpm install --no-frozen-lockfile
-          pnpm install --dir ./in-browser-evm-verifier --no-frozen-lockfile
         env:
           CI: false
           NODE_ENV: development
-      - name: Build wasm package for nodejs target.
-        run: |
-          wasm-pack build --release --target nodejs --out-dir ./in-browser-evm-verifier/nodejs . -- -Z build-std="panic_abort,std"
-      - name: Replace memory definition in nodejs
-        run: |
-          sed -i "3s|.*|imports['env'] = {memory: new WebAssembly.Memory({initial:20,maximum:65536,shared:true})}|" in-browser-evm-verifier/nodejs/ezkl.js
-      - name: Build @ezkljs/verify package
-        run: |
-          cd in-browser-evm-verifier
-          pnpm build:commonjs
-          cd ..
       - name: Install solc
         run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
       - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev b320f350156a0fb15c2eb13dc380deb2367c4474 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
       - name: KZG prove and verify tests (EVM + VK rendered seperately)
         run: cargo nextest run --release --verbose tests_evm::kzg_evm_prove_and_verify_render_seperately_ --test-threads 1
       - name: KZG prove and verify tests (EVM + kzg all)
@@ -357,15 +345,18 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: jetli/wasm-pack-action@v0.4.0
       - name: Add wasm32-unknown-unknown target
         run: rustup target add wasm32-unknown-unknown
 
+      - name: Install wasm-server-runner
+        run: cargo install wasm-server-runner
+
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-01-04-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
       - uses: actions/checkout@v3
       - name: Use pnpm 8
         uses: pnpm/action-setup@v2
@@ -376,7 +367,7 @@ jobs:
         with:
           node-version: "18.12.1"
           cache: "pnpm"
-      - name: Install dependencies for js tests
+      - name: Install dependencies
         run: |
           pnpm install --no-frozen-lockfile
         env:
@@ -392,10 +383,6 @@ jobs:
       - 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: IPA prove and verify tests
-        run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_::t --test-threads 1
-      - name: IPA prove and verify tests (ipa outputs)
-        run: cargo nextest run --release --verbose tests::ipa_prove_and_verify_ipa_output
       - name: KZG prove and verify tests (public outputs + column overflow)
         run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w
       - name: KZG prove and verify tests single inner col
@@ -429,11 +416,11 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-01-04-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
       - uses: actions/checkout@v3
       - uses: baptiste0928/cargo-install@v1
         with:
@@ -456,6 +443,28 @@ jobs:
       - name: KZG prove and verify tests (hashed outputs)
         run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1
 
+  fuzz-tests:
+    runs-on: ubuntu-latest-32-cores
+    needs: [build, library-tests, python-tests]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly-2023-08-24
+          override: true
+          components: rustfmt, clippy
+      - uses: baptiste0928/cargo-install@v1
+        with:
+          crate: cargo-nextest
+          locked: true
+      - name: Install solc
+        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
+      - name: Install Anvil
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
+      - name: fuzz tests (EVM)
+        run: cargo nextest run --release --verbose tests_evm::kzg_evm_fuzz_ --test-threads 2
+      # - name: fuzz tests
+      #   run: cargo nextest run --release --verbose tests::kzg_fuzz_ --test-threads 6
 
   prove-and-verify-mock-aggr-tests:
     runs-on: self-hosted
@@ -464,14 +473,14 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
-      - name: Mock aggr tests (KZG)
+      - name: Mock aggr tests
         run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_mock_prove_and_verify_  --test-threads 8
 
   prove-and-verify-aggr-tests-gpu:
@@ -482,7 +491,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -494,31 +503,29 @@ jobs:
 
   prove-and-verify-aggr-tests:
     runs-on: large-self-hosted
-    needs: [build, library-tests]
+    needs: [build, library-tests, python-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
         with:
           crate: cargo-nextest
           locked: true
-      - name: KZG tests
-        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 4 -- --include-ignored
-
-
+      - name: KZG )tests
+        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 8 -- --include-ignored
 
   prove-and-verify-aggr-evm-tests:
     runs-on: large-self-hosted
-    needs: [build, library-tests]
+    needs: [build, library-tests, python-tests]
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -528,7 +535,7 @@ jobs:
       - name: Install solc
         run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
       - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev b320f350156a0fb15c2eb13dc380deb2367c4474 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
       - name: KZG prove and verify aggr tests
         run: cargo nextest run  --release --verbose tests_evm::kzg_evm_aggr_prove_and_verify_::t --test-threads 4 -- --include-ignored
 
@@ -539,7 +546,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -561,7 +568,7 @@ jobs:
           python-version: "3.7"
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - name: Install solc
@@ -569,9 +576,9 @@ jobs:
       - name: Setup Virtual Env and Install python dependencies
         run: python -m venv .env; source .env/bin/activate; pip install -r requirements.txt;
       - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev b320f350156a0fb15c2eb13dc380deb2367c4474 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
       - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; maturin develop --features python-bindings --release
       - name: Run pytest
         run: source .env/bin/activate; pytest -vv
 
@@ -585,7 +592,7 @@ jobs:
           python-version: "3.7"
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -595,7 +602,7 @@ jobs:
       - name: Setup Virtual Env and Install python dependencies
         run: python -m venv .env; source .env/bin/activate; pip install -r requirements.txt;
       - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; maturin develop --features python-bindings --release
       - name: Div rebase
         run: source .env/bin/activate; cargo nextest run --release --verbose tests::accuracy_measurement_div_rebase_
       - name: Public inputs
@@ -613,10 +620,10 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
-          python-version: "3.10"
+          python-version: "3.9"
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: baptiste0928/cargo-install@v1
@@ -626,11 +633,11 @@ jobs:
       - name: Install solc
         run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
       - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev b320f350156a0fb15c2eb13dc380deb2367c4474 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 95a93cd397f25f3f8d49d2851eb52bc2d52dd983 --profile local --locked anvil --force
       - name: Setup Virtual Env and Install python dependencies
         run: python -m venv .env; source .env/bin/activate; pip install -r requirements.txt;
       - name: Build python ezkl
-        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; maturin develop --features python-bindings --release
       # - name: authenticate-kaggle-cli
       #   shell: bash
       #   env:
@@ -641,12 +648,12 @@ jobs:
       #     echo $KAGGLE_API_KEY > /home/ubuntu/.kaggle/kaggle.json
       #     chmod 600 /home/ubuntu/.kaggle/kaggle.json
       - name: All notebooks
-        run: source .env/bin/activate; cargo nextest run py_tests::tests::run_notebook_ --test-threads 1
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::run_notebook_ --no-capture
       - name: Voice tutorial
         run: source .env/bin/activate; cargo nextest run py_tests::tests::voice_
       - name: NBEATS tutorial
         run: source .env/bin/activate; cargo nextest run py_tests::tests::nbeats_
       - name: Tictactoe tutorials
-        run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_ --no-capture
       # - name: Postgres tutorials
       #   run: source .env/bin/activate; cargo nextest run py_tests::tests::postgres_ --test-threads 1

.github/workflows/wasm.yml

@@ -1,4 +1,4 @@
-name: Build and Publish EZKL npm packages (wasm bindings and in-browser evm verifier)
+name: Build and Publish WASM<>JS Bindings
 
 on:
   workflow_dispatch:
@@ -14,7 +14,7 @@ defaults:
   run:
     working-directory: .
 jobs:
-  publish-wasm-bindings:
+  wasm-publish:
     name: publish-wasm-bindings
     runs-on: ubuntu-latest
     if: startsWith(github.ref, 'refs/tags/')
@@ -22,15 +22,18 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly-2024-01-04
+          toolchain: nightly-2023-08-24
           override: true
           components: rustfmt, clippy
       - uses: jetli/wasm-pack-action@v0.4.0
       - name: Add wasm32-unknown-unknown target
         run: rustup target add wasm32-unknown-unknown
 
+      - name: Install wasm-server-runner
+        run: cargo install wasm-server-runner
+
       - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-01-04-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2023-08-24-x86_64-unknown-linux-gnu
       - name: Install binaryen
         run: |
             set -e
@@ -174,40 +177,3 @@ jobs:
           npm publish
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-  in-browser-evm-ver-publish:
-    name: publish-in-browser-evm-verifier-package
-    needs: ["publish-wasm-bindings"]
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    steps:
-      - uses: actions/checkout@v4
-      - name: Update version in package.json
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          sed -i "s|\"version\": \".*\"|\"version\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
-      - name: Update @ezkljs/engine version in package.json
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          sed -i "s|\"@ezkljs/engine\": \".*\"|\"@ezkljs/engine\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
-      - name: Update the engine import in in-browser-evm-verifier to use @ezkljs/engine package instead of the local one;
-        run: |
-          sed -i "s|import { encodeVerifierCalldata } from '../nodejs/ezkl';|import { encodeVerifierCalldata } from '@ezkljs/engine';|" in-browser-evm-verifier/src/index.ts
-      - name: Set up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: "18.12.1"
-          registry-url: "https://registry.npmjs.org"
-      - name: Publish to npm
-        run: |
-          cd in-browser-evm-verifier
-          npm install
-          npm run build
-          npm ci
-          npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.gitignore

@@ -45,7 +45,6 @@ var/
 *.whl
 *.bak
 node_modules
-/dist
 timingData.json
 !tests/wasm/pk.key
 !tests/wasm/vk.key

Cargo.toml

@@ -15,96 +15,70 @@ crate-type = ["cdylib", "rlib"]
 
 
 [dependencies]
-halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch = "main" }
-halo2_proofs = { git = "https://github.com/zkonduit/halo2", branch = "main" }
-halo2curves = { git = "https://github.com/privacy-scaling-explorations/halo2curves", rev = "9fff22c", features = [
-    "derive_serde",
-] }
+halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch= "main" }
+halo2_proofs = { git = "https://github.com/zkonduit/halo2", branch= "main"  }
+halo2curves = { version = "0.6.0", features = ["derive_serde"] }
 rand = { version = "0.8", default_features = false }
 itertools = { version = "0.10.3", default_features = false }
-clap = { version = "4.3.3", features = ["derive"] }
+clap = { version = "4.3.3", features = ["derive"]}
 serde = { version = "1.0.126", features = ["derive"], optional = true }
-serde_json = { version = "1.0.97", default_features = false, features = [
-    "float_roundtrip",
-    "raw_value",
-], optional = true }
+serde_json = { version = "1.0.97", default_features = false, features = ["float_roundtrip", "raw_value"], optional = true }
 log = { version = "0.4.17", default_features = false, optional = true }
 thiserror = { version = "1.0.38", default_features = false }
 hex = { version = "0.4.3", default_features = false }
 halo2_wrong_ecc = { git = "https://github.com/zkonduit/halo2wrong", branch = "ac/chunked-mv-lookup", package = "ecc" }
-snark-verifier = { git = "https://github.com/zkonduit/snark-verifier", branch = "ac/chunked-mv-lookup", features = [
-    "derive_serde",
-] }
-halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier", branch = "main" }
-maybe-rayon = { version = "0.1.1", default_features = false }
+snark-verifier = { git = "https://github.com/zkonduit/snark-verifier", branch = "ac/chunked-mv-lookup", features=["derive_serde"]}
+halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier",  branch= "main" }
+maybe-rayon = { version = "0.1.1",  default_features = false }
 bincode = { version = "1.3.3", default_features = false }
 ark-std = { version = "^0.3.0", default-features = false }
 unzip-n = "0.1.2"
 num = "0.4.1"
-portable-atomic = "1.6.0"
-tosubcommand = { git = "https://github.com/zkonduit/enum_to_subcommand", package = "tosubcommand" }
-
 
 # evm related deps
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-ethers = { version = "2.0.11", default_features = false, features = [
-    "ethers-solc",
-] }
-indicatif = { version = "0.17.5", features = ["rayon"] }
-gag = { version = "1.0.0", default_features = false }
+ethers = { version = "2.0.7", default_features = false, features = ["ethers-solc"] }
+indicatif = {version = "0.17.5", features = ["rayon"]}
+gag =  { version = "1.0.0", default_features = false}
 instant = { version = "0.1" }
-reqwest = { version = "0.11.14", default-features = false, features = [
-    "default-tls",
-    "multipart",
-    "stream",
-] }
+reqwest = { version = "0.11.14", default-features = false, features = ["default-tls", "multipart", "stream"] }
 openssl = { version = "0.10.55", features = ["vendored"] }
 postgres = "0.19.5"
 pg_bigdecimal = "0.1.5"
 lazy_static = "1.4.0"
-colored_json = { version = "3.0.1", default_features = false, optional = true }
+colored_json =  { version = "3.0.1",  default_features = false, optional = true}
 plotters = { version = "0.3.0", default_features = false, optional = true }
 regex = { version = "1", default_features = false }
-tokio = { version = "1.26.0", default_features = false, features = [
-    "macros",
-    "rt",
-] }
+tokio = { version = "1.26.0",  default_features = false, features = ["macros", "rt"] }
 tokio-util = { version = "0.7.9", features = ["codec"] }
-pyo3 = { version = "0.20.2", features = [
-    "extension-module",
-    "abi3-py37",
-    "macros",
-], default_features = false, optional = true }
-pyo3-asyncio = { version = "0.20.0", features = [
-    "attributes",
-    "tokio-runtime",
-], default_features = false, optional = true }
+pyo3 = { version = "0.20.2", features = ["extension-module", "abi3-py37", "macros"],  default_features = false, optional = true }
+pyo3-asyncio = { version = "0.20.0",  features = ["attributes", "tokio-runtime"],  default_features = false, optional = true }
 pyo3-log = { version = "0.9.0", default_features = false, optional = true }
-tract-onnx = { git = "https://github.com/sonos/tract/", rev = "7b1aa33b2f7d1f19b80e270c83320f0f94daff69", default_features = false, optional = true }
+tract-onnx = { git = "https://github.com/sonos/tract/", rev= "7b1aa33b2f7d1f19b80e270c83320f0f94daff69", default_features = false, optional = true }
 tabled = { version = "0.12.0", optional = true }
 
 
 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
-colored = { version = "2.0.0", default_features = false, optional = true }
-env_logger = { version = "0.10.0", default_features = false, optional = true }
+colored = { version = "2.0.0",  default_features = false, optional = true}
+env_logger = { version = "0.10.0",  default_features = false, optional = true}
 chrono = "0.4.31"
 sha256 = "1.4.0"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.2.8", features = ["js"] }
-instant = { version = "0.1", features = ["wasm-bindgen", "inaccurate"] }
+instant = { version = "0.1", features = [ "wasm-bindgen", "inaccurate" ] }
 
 [target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
-wasm-bindgen-rayon = { version = "1.0", optional = true }
+wasm-bindgen-rayon = { version = "1.0", optional=true }
 wasm-bindgen-test = "0.3.34"
 serde-wasm-bindgen = "0.4"
-wasm-bindgen = { version = "0.2.81", features = ["serde-serialize"] }
+wasm-bindgen = { version = "0.2.81", features = ["serde-serialize"]}
 console_error_panic_hook = "0.1.7"
 wasm-bindgen-console-logger = "0.1.1"
 
 
 [dev-dependencies]
-criterion = { version = "0.3", features = ["html_reports"] }
+criterion = {version = "0.3",  features = ["html_reports"]}
 tempfile = "3.3.0"
 lazy_static = "1.4.0"
 mnist = "0.5"
@@ -176,32 +150,18 @@ required-features = ["ezkl"]
 [features]
 web = ["wasm-bindgen-rayon"]
 default = ["ezkl", "mv-lookup"]
+render = ["halo2_proofs/dev-graph", "plotters"]
 onnx = ["dep:tract-onnx"]
 python-bindings = ["pyo3", "pyo3-log", "pyo3-asyncio"]
-ezkl = [
-    "onnx",
-    "serde",
-    "serde_json",
-    "log",
-    "colored",
-    "env_logger",
-    "tabled/color",
-    "colored_json",
-    "halo2_proofs/circuit-params",
-]
-mv-lookup = [
-    "halo2_proofs/mv-lookup",
-    "snark-verifier/mv-lookup",
-    "halo2_solidity_verifier/mv-lookup",
-]
+ezkl = ["onnx", "serde", "serde_json", "log", "colored", "env_logger", "tabled/color", "colored_json", "halo2_proofs/circuit-params"]
+mv-lookup = ["halo2_proofs/mv-lookup", "snark-verifier/mv-lookup", "halo2_solidity_verifier/mv-lookup"]
 det-prove = []
 icicle = ["halo2_proofs/icicle_gpu"]
 empty-cmd = []
-no-banner = []
 
 # icicle patch to 0.1.0 if feature icicle is enabled
 [patch.'https://github.com/ingonyama-zk/icicle']
-icicle = { git = "https://github.com/ingonyama-zk/icicle?rev=45b00fb", package = "icicle", branch = "fix/vhnat/ezkl-build-fix" }
+icicle = { git = "https://github.com/ingonyama-zk/icicle?rev=45b00fb", package = "icicle", branch = "fix/vhnat/ezkl-build-fix"}
 
 [profile.release]
-rustflags = ["-C", "relocation-model=pic"]
+rustflags = [ "-C", "relocation-model=pic" ]

README.md

@@ -74,10 +74,6 @@ For more details visit the [docs](https://docs.ezkl.xyz).
 
 Build the auto-generated rust documentation and open the docs in your browser locally. `cargo doc --open`
 
-#### In-browser EVM verifier
-
-As an alternative to running the native Halo2 verifier as a WASM binding in the browser, you can use the in-browser EVM verifier. The source code of which you can find in the `in-browser-evm-verifier` directory and a README with instructions on how to use it.
-
 
 ### building the project 🔨
 

benches/accum_conv.rs

@@ -2,13 +2,11 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
 use ezkl::pfsys::create_keys;
-use ezkl::pfsys::create_proof_circuit;
+use ezkl::pfsys::create_proof_circuit_kzg;
 use ezkl::pfsys::srs::gen_srs;
 use ezkl::pfsys::TranscriptType;
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
-use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     arithmetic::Field,
@@ -17,7 +15,6 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 
 static mut KERNEL_HEIGHT: usize = 2;
 static mut KERNEL_WIDTH: usize = 2;
@@ -124,35 +121,28 @@ fn runcnvrl(c: &mut Criterion) {
             group.throughput(Throughput::Elements(*size as u64));
             group.bench_with_input(BenchmarkId::new("pk", size), &size, |b, &_| {
                 b.iter(|| {
-                    create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
-                        .unwrap();
+                    create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(
+                        &circuit, &params, true,
+                    )
+                    .unwrap();
                 });
             });
 
-            let pk = create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
-                .unwrap();
+            let pk =
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+                    .unwrap();
 
             group.throughput(Throughput::Elements(*size as u64));
             group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {
                 b.iter(|| {
-                    let prover = create_proof_circuit::<
-                        KZGCommitmentScheme<_>,
-                        MyCircuit,
-                        ProverSHPLONK<_>,
-                        VerifierSHPLONK<_>,
-                        SingleStrategy<_>,
-                        _,
-                        EvmTranscript<_, _, _, _>,
-                        EvmTranscript<_, _, _, _>,
-                    >(
+                    let prover = create_proof_circuit_kzg(
                         circuit.clone(),
-                        vec![],
                         &params,
-                        &pk,
-                        CheckMode::UNSAFE,
-                        ezkl::Commitments::KZG,
-                        TranscriptType::EVM,
                         None,
+                        &pk,
+                        TranscriptType::EVM,
+                        SingleStrategy::new(&params),
+                        CheckMode::UNSAFE,
                         None,
                     );
                     prover.unwrap();

benches/accum_dot.rs

@@ -1,13 +1,11 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit;
+use ezkl::pfsys::create_proof_circuit_kzg;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
-use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     arithmetic::Field,
@@ -16,7 +14,6 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
 
 static mut LEN: usize = 4;
@@ -93,35 +90,25 @@ fn rundot(c: &mut Criterion) {
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
             b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
             b.iter(|| {
-                let prover = create_proof_circuit::<
-                    KZGCommitmentScheme<_>,
-                    MyCircuit,
-                    ProverSHPLONK<_>,
-                    VerifierSHPLONK<_>,
-                    SingleStrategy<_>,
-                    _,
-                    EvmTranscript<_, _, _, _>,
-                    EvmTranscript<_, _, _, _>,
-                >(
+                let prover = create_proof_circuit_kzg(
                     circuit.clone(),
-                    vec![],
                     &params,
-                    &pk,
-                    CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
+                    &pk,
+                    TranscriptType::EVM,
+                    SingleStrategy::new(&params),
+                    CheckMode::UNSAFE,
                     None,
                 );
                 prover.unwrap();

benches/accum_einsum_matmul.rs

@@ -1,13 +1,11 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit;
+use ezkl::pfsys::create_proof_circuit_kzg;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
-use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     arithmetic::Field,
@@ -16,7 +14,6 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
 
 static mut LEN: usize = 4;
@@ -97,35 +94,25 @@ fn runmatmul(c: &mut Criterion) {
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
             b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
             b.iter(|| {
-                let prover = create_proof_circuit::<
-                    KZGCommitmentScheme<_>,
-                    MyCircuit,
-                    ProverSHPLONK<_>,
-                    VerifierSHPLONK<_>,
-                    SingleStrategy<_>,
-                    _,
-                    EvmTranscript<_, _, _, _>,
-                    EvmTranscript<_, _, _, _>,
-                >(
+                let prover = create_proof_circuit_kzg(
                     circuit.clone(),
-                    vec![],
                     &params,
-                    &pk,
-                    CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
+                    &pk,
+                    TranscriptType::EVM,
+                    SingleStrategy::new(&params),
+                    CheckMode::UNSAFE,
                     None,
                 );
                 prover.unwrap();

benches/accum_matmul_relu.rs

@@ -4,20 +4,17 @@ use ezkl::circuit::*;
 
 use ezkl::circuit::lookup::LookupOp;
 use ezkl::circuit::poly::PolyOp;
-use ezkl::pfsys::create_proof_circuit;
+use ezkl::pfsys::create_proof_circuit_kzg;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
-use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     circuit::{Layouter, SimpleFloorPlanner, Value},
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
 
 const BITS: Range = (-32768, 32768);
@@ -115,35 +112,25 @@ fn runmatmul(c: &mut Criterion) {
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
             b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
             b.iter(|| {
-                let prover = create_proof_circuit::<
-                    KZGCommitmentScheme<_>,
-                    MyCircuit,
-                    ProverSHPLONK<_>,
-                    VerifierSHPLONK<_>,
-                    SingleStrategy<_>,
-                    _,
-                    EvmTranscript<_, _, _, _>,
-                    EvmTranscript<_, _, _, _>,
-                >(
+                let prover = create_proof_circuit_kzg(
                     circuit.clone(),
-                    vec![],
                     &params,
-                    &pk,
-                    CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
+                    &pk,
+                    TranscriptType::EVM,
+                    SingleStrategy::new(&params),
+                    CheckMode::SAFE,
                     None,
                 );
                 prover.unwrap();

benches/accum_matmul_relu_overflow.rs

@@ -4,20 +4,17 @@ use ezkl::circuit::*;
 use ezkl::circuit::lookup::LookupOp;
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::table::Range;
-use ezkl::pfsys::create_proof_circuit;
+use ezkl::pfsys::create_proof_circuit_kzg;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
-use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     circuit::{Layouter, SimpleFloorPlanner, Value},
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use halo2curves::bn256::{Bn256, Fr};
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
 
 const BITS: Range = (-8180, 8180);
@@ -118,35 +115,25 @@ fn runmatmul(c: &mut Criterion) {
         group.throughput(Throughput::Elements(k as u64));
         group.bench_with_input(BenchmarkId::new("pk", k), &k, |b, &_| {
             b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(k as u64));
         group.bench_with_input(BenchmarkId::new("prove", k), &k, |b, &_| {
             b.iter(|| {
-                let prover = create_proof_circuit::<
-                    KZGCommitmentScheme<_>,
-                    MyCircuit,
-                    ProverSHPLONK<_>,
-                    VerifierSHPLONK<_>,
-                    SingleStrategy<_>,
-                    _,
-                    EvmTranscript<_, _, _, _>,
-                    EvmTranscript<_, _, _, _>,
-                >(
+                let prover = create_proof_circuit_kzg(
                     circuit.clone(),
-                    vec![],
                     &params,
-                    &pk,
-                    CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
+                    &pk,
+                    TranscriptType::EVM,
+                    SingleStrategy::new(&params),
+                    CheckMode::SAFE,
                     None,
                 );
                 prover.unwrap();

benches/accum_sum.rs

@@ -1,13 +1,11 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit;
+use ezkl::pfsys::create_proof_circuit_kzg;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
-use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     arithmetic::Field,
@@ -16,7 +14,6 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
 
 static mut LEN: usize = 4;
@@ -89,35 +86,25 @@ fn runsum(c: &mut Criterion) {
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
             b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
             b.iter(|| {
-                let prover = create_proof_circuit::<
-                    KZGCommitmentScheme<_>,
-                    MyCircuit,
-                    ProverSHPLONK<_>,
-                    VerifierSHPLONK<_>,
-                    SingleStrategy<_>,
-                    _,
-                    EvmTranscript<_, _, _, _>,
-                    EvmTranscript<_, _, _, _>,
-                >(
+                let prover = create_proof_circuit_kzg(
                     circuit.clone(),
-                    vec![],
                     &params,
-                    &pk,
-                    CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
+                    &pk,
+                    TranscriptType::EVM,
+                    SingleStrategy::new(&params),
+                    CheckMode::UNSAFE,
                     None,
                 );
                 prover.unwrap();

benches/accum_sumpool.rs

@@ -2,13 +2,11 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::hybrid::HybridOp;
 use ezkl::circuit::*;
 use ezkl::pfsys::create_keys;
-use ezkl::pfsys::create_proof_circuit;
+use ezkl::pfsys::create_proof_circuit_kzg;
 use ezkl::pfsys::srs::gen_srs;
 use ezkl::pfsys::TranscriptType;
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
-use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     arithmetic::Field,
@@ -17,7 +15,6 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 
 static mut IMAGE_HEIGHT: usize = 2;
 static mut IMAGE_WIDTH: usize = 2;
@@ -104,35 +101,28 @@ fn runsumpool(c: &mut Criterion) {
             group.throughput(Throughput::Elements(*size as u64));
             group.bench_with_input(BenchmarkId::new("pk", size), &size, |b, &_| {
                 b.iter(|| {
-                    create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
-                        .unwrap();
+                    create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(
+                        &circuit, &params, true,
+                    )
+                    .unwrap();
                 });
             });
 
-            let pk = create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
-                .unwrap();
+            let pk =
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+                    .unwrap();
 
             group.throughput(Throughput::Elements(*size as u64));
             group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {
                 b.iter(|| {
-                    let prover = create_proof_circuit::<
-                        KZGCommitmentScheme<_>,
-                        MyCircuit,
-                        ProverSHPLONK<_>,
-                        VerifierSHPLONK<_>,
-                        SingleStrategy<_>,
-                        _,
-                        EvmTranscript<_, _, _, _>,
-                        EvmTranscript<_, _, _, _>,
-                    >(
+                    let prover = create_proof_circuit_kzg(
                         circuit.clone(),
-                        vec![],
                         &params,
-                        &pk,
-                        CheckMode::UNSAFE,
-                        ezkl::Commitments::KZG,
-                        TranscriptType::EVM,
                         None,
+                        &pk,
+                        TranscriptType::EVM,
+                        SingleStrategy::new(&params),
+                        CheckMode::UNSAFE,
                         None,
                     );
                     prover.unwrap();

benches/pairwise_add.rs

@@ -1,13 +1,11 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit;
+use ezkl::pfsys::create_proof_circuit_kzg;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
-use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     arithmetic::Field,
@@ -16,7 +14,6 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
 
 static mut LEN: usize = 4;
@@ -87,35 +84,25 @@ fn runadd(c: &mut Criterion) {
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
             b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
             b.iter(|| {
-                let prover = create_proof_circuit::<
-                    KZGCommitmentScheme<_>,
-                    MyCircuit,
-                    ProverSHPLONK<_>,
-                    VerifierSHPLONK<_>,
-                    SingleStrategy<_>,
-                    _,
-                    EvmTranscript<_, _, _, _>,
-                    EvmTranscript<_, _, _, _>,
-                >(
+                let prover = create_proof_circuit_kzg(
                     circuit.clone(),
-                    vec![],
                     &params,
-                    &pk,
-                    CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
+                    &pk,
+                    TranscriptType::EVM,
+                    SingleStrategy::new(&params),
+                    CheckMode::SAFE,
                     None,
                 );
                 prover.unwrap();

benches/pairwise_pow.rs

@@ -2,13 +2,11 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit;
+use ezkl::pfsys::create_proof_circuit_kzg;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
-use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     arithmetic::Field,
@@ -17,7 +15,6 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 use std::marker::PhantomData;
 
 static mut LEN: usize = 4;
@@ -86,35 +83,25 @@ fn runpow(c: &mut Criterion) {
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
             b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
             b.iter(|| {
-                let prover = create_proof_circuit::<
-                    KZGCommitmentScheme<_>,
-                    MyCircuit,
-                    ProverSHPLONK<_>,
-                    VerifierSHPLONK<_>,
-                    SingleStrategy<_>,
-                    _,
-                    EvmTranscript<_, _, _, _>,
-                    EvmTranscript<_, _, _, _>,
-                >(
+                let prover = create_proof_circuit_kzg(
                     circuit.clone(),
-                    vec![],
                     &params,
-                    &pk,
-                    CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
+                    &pk,
+                    TranscriptType::EVM,
+                    SingleStrategy::new(&params),
+                    CheckMode::SAFE,
                     None,
                 );
                 prover.unwrap();

benches/poseidon.rs

@@ -4,13 +4,12 @@ use ezkl::circuit::modules::poseidon::{PoseidonChip, PoseidonConfig};
 use ezkl::circuit::modules::Module;
 use ezkl::circuit::*;
 use ezkl::pfsys::create_keys;
-use ezkl::pfsys::create_proof_circuit;
+use ezkl::pfsys::create_proof_circuit_kzg;
 use ezkl::pfsys::srs::gen_srs;
 use ezkl::pfsys::TranscriptType;
 use ezkl::tensor::*;
 use halo2_proofs::circuit::Value;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     arithmetic::Field,
@@ -19,7 +18,6 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 
 const L: usize = 10;
 
@@ -64,7 +62,7 @@ fn runposeidon(c: &mut Criterion) {
         let params = gen_srs::<KZGCommitmentScheme<_>>(k);
 
         let message = (0..*size).map(|_| Fr::random(OsRng)).collect::<Vec<_>>();
-        let _output =
+        let output =
             PoseidonChip::<PoseidonSpec, POSEIDON_WIDTH, POSEIDON_RATE, L>::run(message.to_vec())
                 .unwrap();
 
@@ -78,35 +76,25 @@ fn runposeidon(c: &mut Criterion) {
         group.throughput(Throughput::Elements(*size as u64));
         group.bench_with_input(BenchmarkId::new("pk", size), &size, |b, &_| {
             b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(*size as u64));
         group.bench_with_input(BenchmarkId::new("prove", size), &size, |b, &_| {
             b.iter(|| {
-                let prover = create_proof_circuit::<
-                    KZGCommitmentScheme<_>,
-                    MyCircuit,
-                    ProverSHPLONK<_>,
-                    VerifierSHPLONK<_>,
-                    SingleStrategy<_>,
-                    _,
-                    EvmTranscript<_, _, _, _>,
-                    EvmTranscript<_, _, _, _>,
-                >(
+                let prover = create_proof_circuit_kzg(
                     circuit.clone(),
-                    vec![],
                     &params,
+                    Some(output[0].clone()),
                     &pk,
-                    CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
                     TranscriptType::EVM,
-                    None,
+                    SingleStrategy::new(&params),
+                    CheckMode::UNSAFE,
                     None,
                 );
                 prover.unwrap();

benches/relu.rs

@@ -2,12 +2,11 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::table::Range;
 use ezkl::circuit::{ops::lookup::LookupOp, BaseConfig as Config, CheckMode};
-use ezkl::pfsys::create_proof_circuit;
+use ezkl::pfsys::create_proof_circuit_kzg;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
-use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
     circuit::{Layouter, SimpleFloorPlanner, Value},
@@ -15,7 +14,6 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::Rng;
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
 
 const BITS: Range = (-32768, 32768);
 static mut LEN: usize = 4;
@@ -93,35 +91,25 @@ fn runrelu(c: &mut Criterion) {
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("pk", len), &len, |b, &_| {
             b.iter(|| {
-                create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, Fr, NLCircuit>(&circuit, &params, true)
                     .unwrap();
             });
         });
 
-        let pk =
-            create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, &params, true).unwrap();
+        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, NLCircuit>(&circuit, &params, true)
+            .unwrap();
 
         group.throughput(Throughput::Elements(len as u64));
         group.bench_with_input(BenchmarkId::new("prove", len), &len, |b, &_| {
             b.iter(|| {
-                let prover = create_proof_circuit::<
-                    KZGCommitmentScheme<_>,
-                    NLCircuit,
-                    ProverSHPLONK<_>,
-                    VerifierSHPLONK<_>,
-                    SingleStrategy<_>,
-                    _,
-                    EvmTranscript<_, _, _, _>,
-                    EvmTranscript<_, _, _, _>,
-                >(
+                let prover = create_proof_circuit_kzg(
                     circuit.clone(),
-                    vec![],
                     &params,
-                    &pk,
-                    CheckMode::UNSAFE,
-                    ezkl::Commitments::KZG,
-                    TranscriptType::EVM,
                     None,
+                    &pk,
+                    TranscriptType::EVM,
+                    SingleStrategy::new(&params),
+                    CheckMode::SAFE,
                     None,
                 );
                 prover.unwrap();

examples/conv2d_mnist/main.rs

@@ -6,7 +6,6 @@ use ezkl::fieldutils;
 use ezkl::fieldutils::i32_to_felt;
 use ezkl::tensor::*;
 use halo2_proofs::dev::MockProver;
-use halo2_proofs::poly::commitment::Params;
 use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
 use halo2_proofs::{
     circuit::{Layouter, SimpleFloorPlanner, Value},
@@ -490,7 +489,6 @@ pub fn runconv() {
         strategy,
         pi_for_real_prover,
         &mut transcript,
-        params.n(),
     );
     assert!(verify.is_ok());
 

examples/notebooks/applications/data_attest_hashed.ipynb

@@ -309,7 +309,7 @@
             "metadata": {},
             "outputs": [],
             "source": [
-                "print(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]))"
+                "print(ezkl.string_to_felt(res['processed_outputs']['poseidon_hash'][0]))"
             ]
         },
         {
@@ -325,7 +325,7 @@
             "metadata": {},
             "outputs": [],
             "source": [
-                "from web3 import Web3, HTTPProvider\n",
+                "from web3 import Web3, HTTPProvider, utils\n",
                 "from solcx import compile_standard\n",
                 "from decimal import Decimal\n",
                 "import json\n",
@@ -338,7 +338,7 @@
                 "\n",
                 "def test_on_chain_data(res):\n",
                 "    # Step 0: Convert the tensor to a flat list\n",
-                "    data = [int(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
+                "    data = [int(ezkl.string_to_felt(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
                 "\n",
                 "    # Step 1: Prepare the data\n",
                 "    # Step 2: Prepare and compile the contract.\n",
@@ -648,7 +648,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.9.15"
+            "version": "3.9.13"
         },
         "orig_nbformat": 4
     },

examples/notebooks/applications/ezkl_demo.ipynb

@@ -695,7 +695,7 @@
         "formatted_output = \"[\"\n",
         "for i, value in enumerate(proof[\"instances\"]):\n",
         "    for j, field_element in enumerate(value):\n",
-        "        onchain_input_array.append(ezkl.felt_to_big_endian(field_element))\n",
+        "        onchain_input_array.append(ezkl.string_to_felt(field_element))\n",
         "        formatted_output += str(onchain_input_array[-1])\n",
         "        if j != len(value) - 1:\n",
         "            formatted_output += \", \"\n",
@@ -705,7 +705,7 @@
         "# copy them over to remix and see if they verify\n",
         "# What happens when you change a value?\n",
         "print(\"pubInputs: \", formatted_output)\n",
-        "print(\"proof: \", proof[\"proof\"])"
+        "print(\"proof: \", \"0x\" + proof[\"proof\"])"
       ]
     },
     {

examples/notebooks/applications/proof_splitting.ipynb

@@ -208,7 +208,7 @@
                 "- `private`: known only to the prover\n",
                 "- `hashed`: the hash pre-image is known to the prover, the prover and verifier know the hash. The prover proves that the they know the pre-image to the hash. \n",
                 "- `encrypted`: the non-encrypted element and the secret key used for decryption are known to the prover. The prover and the verifier know the encrypted element, the public key used to encrypt, and the hash of the decryption hey. The prover proves that they know the pre-image of the hashed decryption key and that this key can in fact decrypt the encrypted message.\n",
-                "- `polycommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes.  \n",
+                "- `kzgcommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes.  \n",
                 "\n",
                 "Here we create the following setup:\n",
                 "- `input_visibility`: \"public\"\n",
@@ -234,7 +234,7 @@
                 "run_args.input_scale = 2\n",
                 "run_args.logrows = 8\n",
                 "\n",
-                "ezkl.get_srs(logrows=run_args.logrows, commitment=ezkl.PyCommitments.KZG)"
+                "ezkl.get_srs(logrows=run_args.logrows)"
             ]
         },
         {
@@ -385,9 +385,9 @@
                 "###  KZG commitment intermediate calculations\n",
                 "\n",
                 "This time the visibility parameters are:\n",
-                "- `input_visibility`: \"polycommit\"\n",
+                "- `input_visibility`: \"kzgcommit\"\n",
                 "- `param_visibility`: \"public\"\n",
-                "- `output_visibility`: polycommit"
+                "- `output_visibility`: kzgcommit"
             ]
         },
         {
@@ -399,9 +399,9 @@
                 "import ezkl\n",
                 "\n",
                 "run_args = ezkl.PyRunArgs()\n",
-                "run_args.input_visibility = \"polycommit\"\n",
+                "run_args.input_visibility = \"kzgcommit\"\n",
                 "run_args.param_visibility = \"fixed\"\n",
-                "run_args.output_visibility = \"polycommit\"\n",
+                "run_args.output_visibility = \"kzgcommit\"\n",
                 "run_args.variables = [(\"batch_size\", 1)]\n",
                 "run_args.input_scale = 2\n",
                 "run_args.logrows = 8\n"

examples/notebooks/applications/simple_demo_aggregated_proofs.ipynb

@@ -275,6 +275,7 @@
                 "        proof_path,\n",
                 "        settings_path,\n",
                 "        vk_path,\n",
+                "        \n",
                 "    )\n",
                 "\n",
                 "assert res == True\n",
@@ -290,7 +291,7 @@
             "source": [
                 "# Generate a larger SRS. This is needed for the aggregated proof\n",
                 "\n",
-                "res = ezkl.get_srs(settings_path=None, logrows=21, commitment=ezkl.PyCommitments.KZG)"
+                "res = ezkl.get_srs(settings_path=None, logrows=21)"
             ]
         },
         {

examples/notebooks/applications/solvency.ipynb

@@ -9,7 +9,7 @@
       "source": [
         "## Solvency demo\n",
         "\n",
-        "Here we create a demo of a solvency calculation in the manner of [summa-solvency](https://github.com/summa-dev/summa-solvency). The aim here is to demonstrate the use of the new polycommit method detailed [here](https://blog.ezkl.xyz/post/commits/). \n",
+        "Here we create a demo of a solvency calculation in the manner of [summa-solvency](https://github.com/summa-dev/summa-solvency). The aim here is to demonstrate the use of the new kzgcommit method detailed [here](https://blog.ezkl.xyz/post/commits/). \n",
         "\n",
         "In this setup:\n",
         "- the commitments to users, respective balances, and total balance are known are publicly known to the prover and verifier. \n",
@@ -126,7 +126,7 @@
         "# Loop through each element in the y tensor\n",
         "for e in user_preimages:\n",
         "    # Apply the custom function and append the result to the list\n",
-        "    users.append(ezkl.poseidon_hash([ezkl.float_to_felt(e, 0)])[0])\n",
+        "    users.append(ezkl.poseidon_hash([ezkl.float_to_string(e, 0)])[0])\n",
         "\n",
         "users_t = torch.tensor(user_preimages)\n",
         "users_t = users_t.reshape(1, 6)\n",
@@ -177,10 +177,10 @@
         "- `private`: known only to the prover\n",
         "- `hashed`: the hash pre-image is known to the prover, the prover and verifier know the hash. The prover proves that the they know the pre-image to the hash. \n",
         "- `encrypted`: the non-encrypted element and the secret key used for decryption are known to the prover. The prover and the verifier know the encrypted element, the public key used to encrypt, and the hash of the decryption hey. The prover proves that they know the pre-image of the hashed decryption key and that this key can in fact decrypt the encrypted message.\n",
-        "- `polycommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes.  \n",
+        "- `kzgcommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes.  \n",
         "\n",
         "Here we create the following setup:\n",
-        "- `input_visibility`: \"polycommit\"\n",
+        "- `input_visibility`: \"kzgcommit\"\n",
         "- `param_visibility`: \"public\"\n",
         "- `output_visibility`: public\n",
         "\n",
@@ -202,8 +202,8 @@
       "outputs": [],
       "source": [
         "run_args = ezkl.PyRunArgs()\n",
-        "# \"polycommit\" means that the output of the hashing is not visible to the verifier and is instead fed into the computational graph\n",
-        "run_args.input_visibility = \"polycommit\"\n",
+        "# \"kzgcommit\" means that the output of the hashing is not visible to the verifier and is instead fed into the computational graph\n",
+        "run_args.input_visibility = \"kzgcommit\"\n",
         "# the parameters are public\n",
         "run_args.param_visibility = \"fixed\"\n",
         "# the output is public (this is the inequality test)\n",
@@ -303,7 +303,7 @@
         "# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
         "# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
         "witness = json.load(open(witness_path, \"r\"))\n",
-        "witness[\"outputs\"][0] = [ezkl.float_to_felt(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_string(1.0, 0)]\n",
         "json.dump(witness, open(witness_path, \"w\"))"
       ]
     },
@@ -417,7 +417,7 @@
         "# we force the output to be 1 this corresponds to the solvency test being true -- and we set this to a fixed vis output\n",
         "# this means that the output is fixed and the verifier can see it but that if the input is not in the set the output will not be 0 and the verifier will reject\n",
         "witness = json.load(open(witness_path, \"r\"))\n",
-        "witness[\"outputs\"][0] = [ezkl.float_to_felt(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_string(1.0, 0)]\n",
         "json.dump(witness, open(witness_path, \"w\"))\n"
       ]
     },
@@ -510,9 +510,9 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.9.15"
+      "version": "3.9.13"
     }
   },
   "nbformat": 4,
   "nbformat_minor": 5
-}
+}

examples/notebooks/applications/tictactoe_autoencoder.ipynb

@@ -633,7 +633,7 @@
                 "json.dump(data, open(cal_path, 'w'))\n",
                 "\n",
                 "\n",
-                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [11])"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [4])"
             ]
         },
         {
@@ -664,6 +664,7 @@
                 "    compiled_model_path,\n",
                 "    vk_path,\n",
                 "    pk_path,\n",
+                "    \n",
                 ")"
             ]
         },

examples/notebooks/applications/world_rotation.ipynb

@@ -503,11 +503,11 @@
     "pyplot.arrow(0, 0, 1, 0, width=0.02, alpha=0.5)\n",
     "pyplot.arrow(0, 0, 0, 1, width=0.02, alpha=0.5)\n",
     "\n",
-    "arrow_x = ezkl.felt_to_float(witness['outputs'][0][0], out_scale)\n",
-    "arrow_y = ezkl.felt_to_float(witness['outputs'][0][1], out_scale)\n",
+    "arrow_x = ezkl.string_to_float(witness['outputs'][0][0], out_scale)\n",
+    "arrow_y = ezkl.string_to_float(witness['outputs'][0][1], out_scale)\n",
     "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",
+    "arrow_x = ezkl.string_to_float(witness['outputs'][0][2], out_scale)\n",
+    "arrow_y = ezkl.string_to_float(witness['outputs'][0][3], out_scale)\n",
     "pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)"
    ]
   }

examples/notebooks/data_science/generalized_inverse.ipynb

@@ -10,7 +10,7 @@
         "\n",
         "## Generalized Inverse\n",
         "\n",
-        "We show how to use EZKL to prove that we know matrices $A$ and its generalized inverse $B$. Since these are large we deal with the KZG commitments, with $a$ the polycommit of $A$, $b$ the polycommit of $B$, and $ABA = A$.\n"
+        "We show how to use EZKL to prove that we know matrices $A$ and its generalized inverse $B$. Since these are large we deal with the KZG commitments, with $a$ the kzgcommit of $A$, $b$ the kzgcommit of $B$, and $ABA = A$.\n"
       ]
     },
     {
@@ -77,7 +77,7 @@
       "outputs": [],
       "source": [
         "gip_run_args = ezkl.PyRunArgs()\n",
-        "gip_run_args.input_visibility = \"polycommit\"  # matrix and generalized inverse commitments\n",
+        "gip_run_args.input_visibility = \"kzgcommit\"  # matrix and generalized inverse commitments\n",
         "gip_run_args.output_visibility = \"fixed\"   # no parameters used\n",
         "gip_run_args.param_visibility = \"fixed\" # should be Tensor(True)"
       ]
@@ -340,4 +340,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 5
-}
+}

examples/notebooks/data_science/hashed_vis.ipynb

@@ -161,7 +161,7 @@
                 "- `fixed`: known to the prover and verifier (as a commit), but not modifiable by the prover.\n",
                 "- `hashed`: the hash pre-image is known to the prover, the prover and verifier know the hash. The prover proves that the they know the pre-image to the hash. \n",
                 "- `encrypted`: the non-encrypted element and the secret key used for decryption are known to the prover. The prover and the verifier know the encrypted element, the public key used to encrypt, and the hash of the decryption hey. The prover proves that they know the pre-image of the hashed decryption key and that this key can in fact decrypt the encrypted message.\n",
-                "- `polycommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be inserted directly within the proof bytes.  \n",
+                "- `kzgcommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be inserted directly within the proof bytes.  \n",
                 "\n",
                 "\n",
                 "Here we create the following setup:\n",
@@ -510,4 +510,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 2
-}
+}

examples/notebooks/data_science/kzg_vis.ipynb

@@ -154,11 +154,11 @@
                 "- `fixed`: known to the prover and verifier (as a commit), but not modifiable by the prover.\n",
                 "- `hashed`: the hash pre-image is known to the prover, the prover and verifier know the hash. The prover proves that the they know the pre-image to the hash. \n",
                 "- `encrypted`: the non-encrypted element and the secret key used for decryption are known to the prover. The prover and the verifier know the encrypted element, the public key used to encrypt, and the hash of the decryption hey. The prover proves that they know the pre-image of the hashed decryption key and that this key can in fact decrypt the encrypted message.\n",
-                "- `polycommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes.  \n",
+                "- `kzgcommit`: unblinded advice column which generates a kzg commitment. This doesn't appear in the instances of the circuit and must instead be modified directly within the proof bytes.  \n",
                 "\n",
                 "Here we create the following setup:\n",
-                "- `input_visibility`: \"polycommit\"\n",
-                "- `param_visibility`: \"polycommit\"\n",
+                "- `input_visibility`: \"kzgcommit\"\n",
+                "- `param_visibility`: \"kzgcommit\"\n",
                 "- `output_visibility`: public\n",
                 "\n",
                 "We encourage you to play around with other setups :) \n",
@@ -186,8 +186,8 @@
                 "data_path = os.path.join('input.json')\n",
                 "\n",
                 "run_args = ezkl.PyRunArgs()\n",
-                "run_args.input_visibility = \"polycommit\"\n",
-                "run_args.param_visibility = \"polycommit\"\n",
+                "run_args.input_visibility = \"kzgcommit\"\n",
+                "run_args.param_visibility = \"kzgcommit\"\n",
                 "run_args.output_visibility = \"public\"\n",
                 "run_args.variables = [(\"batch_size\", 1)]\n",
                 "\n",
@@ -512,4 +512,4 @@
     },
     "nbformat": 4,
     "nbformat_minor": 2
-}
+}

examples/notebooks/data_science/set_membership.ipynb

@@ -122,8 +122,8 @@
         "# Loop through each element in the y tensor\n",
         "for e in y_input:\n",
         "    # Apply the custom function and append the result to the list\n",
-        "    print(ezkl.float_to_felt(e,7))\n",
-        "    result.append(ezkl.poseidon_hash([ezkl.float_to_felt(e, 7)])[0])\n",
+        "    print(ezkl.float_to_string(e,7))\n",
+        "    result.append(ezkl.poseidon_hash([ezkl.float_to_string(e, 7)])[0])\n",
         "\n",
         "y = y.unsqueeze(0)\n",
         "y = y.reshape(1, 9)\n",

examples/notebooks/deep_learning/mnist_gan_proof_splitting.ipynb

@@ -264,9 +264,9 @@
                 "###  KZG commitment intermediate calculations\n",
                 "\n",
                 "the visibility parameters are:\n",
-                "- `input_visibility`: \"polycommit\"\n",
+                "- `input_visibility`: \"kzgcommit\"\n",
                 "- `param_visibility`: \"public\"\n",
-                "- `output_visibility`: polycommit"
+                "- `output_visibility`: kzgcommit"
             ]
         },
         {
@@ -280,15 +280,15 @@
                 "srs_path = os.path.join('kzg.srs')\n",
                 "\n",
                 "run_args = ezkl.PyRunArgs()\n",
-                "run_args.input_visibility = \"polycommit\"\n",
+                "run_args.input_visibility = \"kzgcommit\"\n",
                 "run_args.param_visibility = \"fixed\"\n",
-                "run_args.output_visibility = \"polycommit\"\n",
+                "run_args.output_visibility = \"kzgcommit\"\n",
                 "run_args.variables = [(\"batch_size\", 1)]\n",
                 "run_args.input_scale = 0\n",
                 "run_args.param_scale = 0\n",
                 "run_args.logrows = 18\n",
                 "\n",
-                "ezkl.get_srs(logrows=run_args.logrows, commitment=ezkl.PyCommitments.KZG)\n"
+                "ezkl.get_srs(logrows=run_args.logrows)\n"
             ]
         },
         {
@@ -343,6 +343,7 @@
                 "         compiled_model_path,\n",
                 "         vk_path,\n",
                 "         pk_path,\n",
+                "         compress_selectors=True,\n",
                 "      )\n",
                 "\n",
                 "    assert res == True\n",

examples/onnx/gather_nd/gen.py

@@ -1,48 +0,0 @@
-from torch import nn
-import json
-import numpy as np
-import tf2onnx
-
-
-import tensorflow as tf
-from tensorflow.keras.layers import *
-from tensorflow.keras.models import Model
-
-
-# gather_nd in tf then export to onnx
-
-
-
-
-x = in1 = Input((15, 18,))
-w = in2 = Input((15, 1), dtype=tf.int32)
-x = tf.gather_nd(x, w, batch_dims=1)
-tm = Model((in1, in2), x )
-tm.summary()
-tm.compile(optimizer='adam', loss='mse')
-
-shape = [1, 15, 18]
-index_shape = [1, 15, 1]
-# After training, export to onnx (network.onnx) and create a data file (input.json)
-x = 0.1*np.random.rand(1,*shape)
-# w = random int tensor
-w = np.random.randint(0, 10, index_shape)
-
-spec = tf.TensorSpec(shape, tf.float32, name='input_0')
-index_spec = tf.TensorSpec(index_shape, tf.int32, name='input_1')
-
-model_path = "network.onnx"
-
-tf2onnx.convert.from_keras(tm, input_signature=[spec, index_spec], inputs_as_nchw=['input_0', 'input_1'], opset=12, output_path=model_path)
-
-
-d = x.reshape([-1]).tolist()
-d1 = w.reshape([-1]).tolist()
-
-
-data = dict(
-    input_data=[d, d1],
-)
-
-# Serialize data into file:
-json.dump(data, open("input.json", 'w'))

examples/onnx/scatter_nd/gen.py

@@ -1,76 +0,0 @@
-import torch
-import torch.nn as nn
-import sys
-import json
-
-sys.path.append("..")
-
-class Model(nn.Module):
-    """
-    Just one Linear layer
-    """
-    def __init__(self, configs):
-        super(Model, self).__init__()
-        self.seq_len = configs.seq_len
-        self.pred_len = configs.pred_len
-
-        # Use this line if you want to visualize the weights
-        # self.Linear.weight = nn.Parameter((1/self.seq_len)*torch.ones([self.pred_len,self.seq_len]))
-        self.channels = configs.enc_in
-        self.individual = configs.individual
-        if self.individual:
-            self.Linear = nn.ModuleList()
-            for i in range(self.channels):
-                self.Linear.append(nn.Linear(self.seq_len,self.pred_len))
-        else:
-            self.Linear = nn.Linear(self.seq_len, self.pred_len)
-
-    def forward(self, x):
-        # x: [Batch, Input length, Channel]
-        if self.individual:
-            output = torch.zeros([x.size(0),self.pred_len,x.size(2)],dtype=x.dtype).to(x.device)
-            for i in range(self.channels):
-                output[:,:,i] = self.Linear[i](x[:,:,i])
-            x = output
-        else:
-            x = self.Linear(x.permute(0,2,1)).permute(0,2,1)
-        return x # [Batch, Output length, Channel]
-
-class Configs:
-    def __init__(self, seq_len, pred_len, enc_in=321, individual=True):
-      self.seq_len = seq_len
-      self.pred_len = pred_len
-      self.enc_in = enc_in
-      self.individual = individual
-
-model = 'Linear'
-seq_len = 10
-pred_len = 4
-enc_in = 3
-
-configs = Configs(seq_len, pred_len, enc_in, True)
-circuit = Model(configs)
-
-x = torch.randn(1, seq_len, pred_len)
-
-
-torch.onnx.export(circuit, x, "network.onnx",
-                  export_params=True,        # store the trained parameter weights inside the model file
-                  opset_version=15,          # the ONNX version to export the model to
-                  do_constant_folding=True,  # whether to execute constant folding for optimization
-                  # the model's input names
-                  input_names=['input'],
-                  output_names=['output'],  # the model's output names
-                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
-                                'output': {0: 'batch_size'}})
-
-
-d1 = ((x).detach().numpy()).reshape([-1]).tolist()
-
-
-data = dict(
-    input_data=[d1],
-)
-
-# Serialize data into file:
-json.dump(data, open("input.json", 'w'))

examples/onnx/scatter_nd/input.json

@@ -1 +0,0 @@
-{"input_data": [[0.1874287724494934, 1.0498261451721191, 0.22384068369865417, 1.048445224761963, -0.5670360326766968, -0.38653188943862915, 0.12878702580928802, -2.3675858974456787, 0.5800458192825317, -0.43653929233551025, -0.2511898875236511, 0.3324051797389984, 0.27960312366485596, 0.4763695001602173, 0.3796705901622772, 1.1334782838821411, -0.87981778383255, -1.2451434135437012, 0.7672272324562073, -0.24404007196426392, -0.6875824928283691, 0.3619358539581299, -0.10131897777318954, 0.7169521450996399, 1.6585893630981445, -0.5451845526695251, 0.429487019777298, 0.7426952123641968, -0.2543637454509735, 0.06546942889690399, 0.7939824461936951, 0.1579471379518509, -0.043604474514722824, -0.8621711730957031, -0.5344759821891785, -0.05880478024482727, -0.17351101338863373, 0.5095029473304749, -0.7864817976951599, -0.449171245098114]]}

in-browser-evm-verifier/README.md

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

in-browser-evm-verifier/package.json

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

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

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

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

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

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

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

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

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

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

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

in-browser-evm-verifier/tsconfig.json

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

package.json

@@ -7,7 +7,7 @@
     "test": "jest"
   },
   "devDependencies": {
-    "@ezkljs/engine": "^9.4.4",
+    "@ezkljs/engine": "^2.4.5",
     "@ezkljs/verify": "^0.0.6",
     "@jest/types": "^29.6.3",
     "@types/file-saver": "^2.0.5",
@@ -27,4 +27,4 @@
     "tsconfig-paths": "^4.2.0",
     "typescript": "5.1.6"
   }
-}
+}

pnpm-lock.yaml

@@ -6,8 +6,8 @@ settings:
 
 devDependencies:
   '@ezkljs/engine':
-    specifier: ^9.4.4
-    version: 9.4.4
+    specifier: ^2.4.5
+    version: 2.4.5
   '@ezkljs/verify':
     specifier: ^0.0.6
     version: 0.0.6(buffer@6.0.3)
@@ -785,13 +785,6 @@ packages:
       json-bigint: 1.0.0
     dev: true
 
-  /@ezkljs/engine@9.4.4:
-    resolution: {integrity: sha512-kNsTmDQa8mIiQ6yjJmBMwVgAAxh4nfs4NCtnewJifonyA8Mfhs+teXwwW8WhERRDoQPUofKO2pT8BPvV/XGIDA==}
-    dependencies:
-      '@types/json-bigint': 1.0.1
-      json-bigint: 1.0.0
-    dev: true
-
   /@ezkljs/verify@0.0.6(buffer@6.0.3):
     resolution: {integrity: sha512-9DHoEhLKl1DBGuUVseXLThuMyYceY08Zymr/OsLH0zbdA9OoISYhb77j4QPm4ANRKEm5dCi8oHDqkwGbFc2xFQ==}
     dependencies:

src/bin/ezkl.rs

@@ -11,8 +11,8 @@ use ezkl::execute::run;
 #[cfg(not(target_arch = "wasm32"))]
 use ezkl::logger::init_logger;
 #[cfg(not(target_arch = "wasm32"))]
-use log::{debug, error, info};
-#[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
+use log::{error, info};
+#[cfg(not(target_arch = "wasm32"))]
 use rand::prelude::SliceRandom;
 #[cfg(not(target_arch = "wasm32"))]
 #[cfg(feature = "icicle")]
@@ -25,7 +25,6 @@ use std::error::Error;
 pub async fn main() -> Result<(), Box<dyn Error>> {
     let args = Cli::parse();
     init_logger();
-    #[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
     banner();
     #[cfg(feature = "icicle")]
     if env::var("ENABLE_ICICLE_GPU").is_ok() {
@@ -33,7 +32,7 @@ pub async fn main() -> Result<(), Box<dyn Error>> {
     } else {
         info!("Running with CPU");
     }
-    debug!("command: \n {}", &args.as_json()?.to_colored_json_auto()?);
+    info!("command: \n {}", &args.as_json()?.to_colored_json_auto()?);
     let res = run(args.command).await;
     match &res {
         Ok(_) => info!("succeeded"),
@@ -45,7 +44,7 @@ pub async fn main() -> Result<(), Box<dyn Error>> {
 #[cfg(target_arch = "wasm32")]
 pub fn main() {}
 
-#[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
+#[cfg(not(target_arch = "wasm32"))]
 fn banner() {
     let ell: Vec<&str> = vec![
         "for Neural Networks",

src/circuit/modules/kzg.rs

@@ -6,9 +6,10 @@ Thanks to https://github.com/summa-dev/summa-solvency/blob/master/src/chips/pose
 
 // This chip adds a set of advice columns to the gadget Chip to store the inputs of the hash
 use halo2_proofs::halo2curves::bn256::Fr as Fp;
-use halo2_proofs::poly::commitment::{Blind, CommitmentScheme, Params};
+use halo2_proofs::poly::commitment::{Blind, Params};
+use halo2_proofs::poly::kzg::commitment::ParamsKZG;
 use halo2_proofs::{circuit::*, plonk::*};
-use halo2curves::bn256::G1Affine;
+use halo2curves::bn256::{Bn256, G1Affine};
 use halo2curves::group::prime::PrimeCurveAffine;
 use halo2curves::group::Curve;
 use halo2curves::CurveAffine;
@@ -17,33 +18,35 @@ use crate::tensor::{Tensor, ValTensor, ValType, VarTensor};
 
 use super::Module;
 
-/// The number of instance columns used by the PolyCommit hash function
+/// The number of instance columns used by the KZG hash function
 pub const NUM_INSTANCE_COLUMNS: usize = 0;
-/// The number of advice columns used by the PolyCommit hash function
+/// The number of advice columns used by the KZG hash function
 pub const NUM_INNER_COLS: usize = 1;
 
 #[derive(Debug, Clone)]
-/// Configuration for the PolyCommit chip
-pub struct PolyCommitConfig {
+/// WIDTH, RATE and L are const generics for the struct, which represent the width, rate, and number of inputs for the Poseidon hash function, respectively.
+/// This means they are values that are known at compile time and can be used to specialize the implementation of the struct.
+/// The actual chip provided by halo2_gadgets is added to the parent Chip.
+pub struct KZGConfig {
     ///
-    pub inputs: VarTensor,
+    pub hash_inputs: VarTensor,
 }
 
 type InputAssignments = ();
 
-///
+/// PoseidonChip is a wrapper around the Pow5Chip that adds a set of advice columns to the gadget Chip to store the inputs of the hash
 #[derive(Debug)]
-pub struct PolyCommitChip {
-    config: PolyCommitConfig,
+pub struct KZGChip {
+    config: KZGConfig,
 }
 
-impl PolyCommitChip {
-    /// Commit to the message using the KZG commitment scheme
-    pub fn commit<Scheme: CommitmentScheme<Scalar = Fp, Curve = G1Affine>>(
-        message: Vec<Scheme::Scalar>,
+impl KZGChip {
+    /// Returns the number of inputs to the hash function
+    pub fn commit(
+        message: Vec<Fp>,
         degree: u32,
         num_unusable_rows: u32,
-        params: &Scheme::ParamsProver,
+        params: &ParamsKZG<Bn256>,
     ) -> Vec<G1Affine> {
         let k = params.k();
         let domain = halo2_proofs::poly::EvaluationDomain::new(degree, k);
@@ -78,14 +81,14 @@ impl PolyCommitChip {
     }
 }
 
-impl Module<Fp> for PolyCommitChip {
-    type Config = PolyCommitConfig;
+impl Module<Fp> for KZGChip {
+    type Config = KZGConfig;
     type InputAssignments = InputAssignments;
     type RunInputs = Vec<Fp>;
     type Params = (usize, usize);
 
     fn name(&self) -> &'static str {
-        "PolyCommit"
+        "KZG"
     }
 
     fn instance_increment_input(&self) -> Vec<usize> {
@@ -99,8 +102,8 @@ impl Module<Fp> for PolyCommitChip {
 
     /// Configuration of the PoseidonChip
     fn configure(meta: &mut ConstraintSystem<Fp>, params: Self::Params) -> Self::Config {
-        let inputs = VarTensor::new_unblinded_advice(meta, params.0, NUM_INNER_COLS, params.1);
-        Self::Config { inputs }
+        let hash_inputs = VarTensor::new_unblinded_advice(meta, params.0, NUM_INNER_COLS, params.1);
+        Self::Config { hash_inputs }
     }
 
     fn layout_inputs(
@@ -122,8 +125,8 @@ impl Module<Fp> for PolyCommitChip {
     ) -> Result<ValTensor<Fp>, Error> {
         assert_eq!(input.len(), 1);
         layouter.assign_region(
-            || "PolyCommit",
-            |mut region| self.config.inputs.assign(&mut region, 0, &input[0]),
+            || "kzg commit",
+            |mut region| self.config.hash_inputs.assign(&mut region, 0, &input[0]),
         )
     }
 
@@ -160,7 +163,7 @@ mod tests {
     }
 
     impl Circuit<Fp> for HashCircuit {
-        type Config = PolyCommitConfig;
+        type Config = KZGConfig;
         type FloorPlanner = ModulePlanner;
         type Params = ();
 
@@ -175,7 +178,7 @@ mod tests {
 
         fn configure(meta: &mut ConstraintSystem<Fp>) -> Self::Config {
             let params = (K, R);
-            PolyCommitChip::configure(meta, params)
+            KZGChip::configure(meta, params)
         }
 
         fn synthesize(
@@ -183,8 +186,8 @@ mod tests {
             config: Self::Config,
             mut layouter: impl Layouter<Fp>,
         ) -> Result<(), Error> {
-            let polycommit_chip = PolyCommitChip::new(config);
-            polycommit_chip.layout(&mut layouter, &[self.message.clone()], 0);
+            let kzg_chip = KZGChip::new(config);
+            kzg_chip.layout(&mut layouter, &[self.message.clone()], 0);
 
             Ok(())
         }
@@ -192,7 +195,7 @@ mod tests {
 
     #[test]
     #[ignore]
-    fn polycommit_chip_for_a_range_of_input_sizes() {
+    fn kzg_for_a_range_of_input_sizes() {
         let rng = rand::rngs::OsRng;
 
         #[cfg(not(target_arch = "wasm32"))]
@@ -222,7 +225,7 @@ mod tests {
 
     #[test]
     #[ignore]
-    fn polycommit_chip_much_longer_input() {
+    fn kzg_commit_much_longer_input() {
         #[cfg(not(target_arch = "wasm32"))]
         env_logger::init();
 

src/circuit/modules/mod.rs

@@ -2,7 +2,7 @@
 pub mod poseidon;
 
 ///
-pub mod polycommit;
+pub mod kzg;
 
 ///
 pub mod planner;

src/circuit/modules/planner.rs

@@ -15,7 +15,7 @@ use halo2_proofs::{
         Instance, Selector, TableColumn,
     },
 };
-use log::{debug, trace};
+use log::{trace, warn};
 
 /// A simple [`FloorPlanner`] that performs minimal optimizations.
 #[derive(Debug)]
@@ -119,7 +119,7 @@ impl<'a, F: Field, CS: Assignment<F> + 'a + SyncDeps> Layouter<F> for ModuleLayo
                 Error::Synthesis
             })?;
             if !self.regions.contains_key(&index) {
-                debug!("spawning module {}", index)
+                warn!("spawning module {}", index)
             };
             self.current_module = index;
         }

src/circuit/ops/base.rs

@@ -12,11 +12,15 @@ pub enum BaseOp {
     DotInit,
     CumProdInit,
     CumProd,
+    Identity,
     Add,
     Mult,
     Sub,
     SumInit,
     Sum,
+    Neg,
+    Range { tol: i32 },
+    IsZero,
     IsBoolean,
 }
 
@@ -32,8 +36,12 @@ impl BaseOp {
         let (a, b) = inputs;
         match &self {
             BaseOp::Add => a + b,
+            BaseOp::Identity => b,
+            BaseOp::Neg => -b,
             BaseOp::Sub => a - b,
             BaseOp::Mult => a * b,
+            BaseOp::Range { .. } => b,
+            BaseOp::IsZero => b,
             BaseOp::IsBoolean => b,
             _ => panic!("nonaccum_f called on accumulating operation"),
         }
@@ -65,15 +73,19 @@ impl BaseOp {
     /// display func
     pub fn as_str(&self) -> &'static str {
         match self {
+            BaseOp::Identity => "IDENTITY",
             BaseOp::Dot => "DOT",
             BaseOp::DotInit => "DOTINIT",
             BaseOp::CumProdInit => "CUMPRODINIT",
             BaseOp::CumProd => "CUMPROD",
             BaseOp::Add => "ADD",
+            BaseOp::Neg => "NEG",
             BaseOp::Sub => "SUB",
             BaseOp::Mult => "MULT",
             BaseOp::Sum => "SUM",
             BaseOp::SumInit => "SUMINIT",
+            BaseOp::Range { .. } => "RANGE",
+            BaseOp::IsZero => "ISZERO",
             BaseOp::IsBoolean => "ISBOOLEAN",
         }
     }
@@ -81,6 +93,8 @@ impl BaseOp {
     /// Returns the range of the query offset for this operation.
     pub fn query_offset_rng(&self) -> (i32, usize) {
         match self {
+            BaseOp::Identity => (0, 1),
+            BaseOp::Neg => (0, 1),
             BaseOp::DotInit => (0, 1),
             BaseOp::Dot => (-1, 2),
             BaseOp::CumProd => (-1, 2),
@@ -90,6 +104,8 @@ impl BaseOp {
             BaseOp::Mult => (0, 1),
             BaseOp::Sum => (-1, 2),
             BaseOp::SumInit => (0, 1),
+            BaseOp::Range { .. } => (0, 1),
+            BaseOp::IsZero => (0, 1),
             BaseOp::IsBoolean => (0, 1),
         }
     }
@@ -97,6 +113,8 @@ impl BaseOp {
     /// Returns the number of inputs for this operation.
     pub fn num_inputs(&self) -> usize {
         match self {
+            BaseOp::Identity => 1,
+            BaseOp::Neg => 1,
             BaseOp::DotInit => 2,
             BaseOp::Dot => 2,
             BaseOp::CumProdInit => 1,
@@ -106,22 +124,28 @@ impl BaseOp {
             BaseOp::Mult => 2,
             BaseOp::Sum => 1,
             BaseOp::SumInit => 1,
-            BaseOp::IsBoolean => 0,
+            BaseOp::Range { .. } => 1,
+            BaseOp::IsZero => 1,
+            BaseOp::IsBoolean => 1,
         }
     }
 
     /// Returns the number of outputs for this operation.
     pub fn constraint_idx(&self) -> usize {
         match self {
+            BaseOp::Identity => 0,
+            BaseOp::Neg => 0,
             BaseOp::DotInit => 0,
             BaseOp::Dot => 1,
             BaseOp::Add => 0,
             BaseOp::Sub => 0,
             BaseOp::Mult => 0,
+            BaseOp::Range { .. } => 0,
             BaseOp::Sum => 1,
             BaseOp::SumInit => 0,
             BaseOp::CumProd => 1,
             BaseOp::CumProdInit => 0,
+            BaseOp::IsZero => 0,
             BaseOp::IsBoolean => 0,
         }
     }