fix: array element encapsulation in ezkl_demo.ipynb (#747 )

refactor: apply num-inner cols to constant assignments as well (#749 )
chore: more complete coverage tests (#748 )
2026-01-13 08:17:57 -05:00 · 2024-03-21 08:51:01 +00:00 · 2024-03-20 23:51:38 +00:00 · 2024-03-20 18:53:47 +00:00 · 2024-03-20 10:15:11 +00:00 · 2024-03-16 16:31:01 +00:00
133 changed files with 8087 additions and 3138 deletions
--- a/.github/workflows/wasm.yml
+++ b/.github/workflows/wasm.yml
@@ -1,4 +1,4 @@
-name: Build and Publish WASM<>JS Bindings
+name: Build and Publish EZKL npm packages (wasm bindings and in-browser evm verifier)

 on:
  workflow_dispatch:
@@ -14,7 +14,7 @@ defaults:
  run:
    working-directory: .
 jobs:
-  wasm-publish:
+  publish-wasm-bindings:
    name: publish-wasm-bindings
    runs-on: ubuntu-latest
    if: startsWith(github.ref, 'refs/tags/')
@@ -174,3 +174,40 @@ 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 }}
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -303,12 +303,24 @@ jobs:
        with:
          node-version: "18.12.1"
          cache: "pnpm"
-      - name: Install dependencies
+      - name: Install dependencies for js tests and in-browser-evm-verifier package
        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
@@ -364,7 +376,7 @@ jobs:
        with:
          node-version: "18.12.1"
          cache: "pnpm"
-      - name: Install dependencies
+      - name: Install dependencies for js tests
        run: |
          pnpm install --no-frozen-lockfile
        env:
@@ -380,6 +392,10 @@ 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
@@ -440,28 +456,6 @@ 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-2024-01-04
-          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 b320f350156a0fb15c2eb13dc380deb2367c4474 --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
@@ -477,7 +471,7 @@ jobs:
        with:
          crate: cargo-nextest
          locked: true
-      - name: Mock aggr tests
+      - name: Mock aggr tests (KZG)
        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_mock_prove_and_verify_  --test-threads 8

  prove-and-verify-aggr-tests-gpu:
@@ -500,7 +494,7 @@ jobs:

  prove-and-verify-aggr-tests:
    runs-on: large-self-hosted
-    needs: [build, library-tests, python-tests]
+    needs: [build, library-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
@@ -512,12 +506,14 @@ jobs:
        with:
          crate: cargo-nextest
          locked: true
-      - name: KZG )tests
-        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 8 -- --include-ignored
+      - name: KZG tests
+        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --test-threads 4 -- --include-ignored
+
+

  prove-and-verify-aggr-evm-tests:
    runs-on: large-self-hosted
-    needs: [build, library-tests, python-tests]
+    needs: [build, library-tests]
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
@@ -575,7 +571,7 @@ jobs:
      - name: Install Anvil
        run: cargo install --git https://github.com/foundry-rs/foundry --rev b320f350156a0fb15c2eb13dc380deb2367c4474 --profile local --locked anvil --force
      - name: Build python ezkl
-        run: source .env/bin/activate; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
      - name: Run pytest
        run: source .env/bin/activate; pytest -vv

@@ -599,7 +595,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; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; unset CONDA_PREFIX; 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
@@ -617,7 +613,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v4
        with:
-          python-version: "3.9"
+          python-version: "3.10"
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: nightly-2024-01-04
@@ -634,7 +630,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; maturin develop --features python-bindings --release
+        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
      # - name: authenticate-kaggle-cli
      #   shell: bash
      #   env:
@@ -645,12 +641,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_ --no-capture
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::run_notebook_ --test-threads 1
      - 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_ --no-capture
+        run: source .env/bin/activate; cargo nextest run py_tests::tests::tictactoe_
      # - name: Postgres tutorials
      #   run: source .env/bin/activate; cargo nextest run py_tests::tests::postgres_ --test-threads 1
--- a/.gitignore
+++ b/.gitignore
@@ -45,6 +45,7 @@ var/
 *.whl
 *.bak
 node_modules
+/dist
 timingData.json
 !tests/wasm/pk.key
 !tests/wasm/vk.key
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -843,7 +843,7 @@ dependencies = [
 "anstyle",
 "bitflags 1.3.2",
 "clap_lex",
- "strsim 0.10.0",
+ "strsim",
 ]

 [[package]]
@@ -1191,41 +1191,6 @@ dependencies = [
 "cuda-config",
 ]

-[[package]]
-name = "darling"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d706e75d87e35569db781a9b5e2416cff1236a47ed380831f959382ccd5f858"
-dependencies = [
- "darling_core",
- "darling_macro",
-]
-
-[[package]]
-name = "darling_core"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0c960ae2da4de88a91b2d920c2a7233b400bc33cb28453a2987822d8392519b"
-dependencies = [
- "fnv",
- "ident_case",
- "proc-macro2",
- "quote",
- "strsim 0.9.3",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "darling_macro"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b5a2f4ac4969822c62224815d069952656cadc7084fdca9751e6d959189b72"
-dependencies = [
- "darling_core",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "der"
 version = "0.7.6"
@@ -1258,31 +1223,6 @@ dependencies = [
 "syn 1.0.109",
 ]

-[[package]]
-name = "derive_builder"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2658621297f2cf68762a6f7dc0bb7e1ff2cfd6583daef8ee0fed6f7ec468ec0"
-dependencies = [
- "darling",
- "derive_builder_core",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "derive_builder_core"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2791ea3e372c8495c0bc2033991d76b512cd799d07491fbd6890124db9458bef"
-dependencies = [
- "darling",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "derive_more"
 version = "0.99.17"
@@ -2263,7 +2203,7 @@ dependencies = [
 [[package]]
 name = "halo2_gadgets"
 version = "0.2.0"
-source = "git+https://github.com/zkonduit/halo2?branch=main#fe7522c85c8c434d7ceb9f663b0fb51909b9994f"
+source = "git+https://github.com/zkonduit/halo2?branch=main#4d7e6ddac661283e2b73c551b2e8f0011cedd50f"
 dependencies = [
 "arrayvec 0.7.4",
 "bitvec 1.0.1",
@@ -2280,7 +2220,7 @@ dependencies = [
 [[package]]
 name = "halo2_proofs"
 version = "0.3.0"
-source = "git+https://github.com/zkonduit/halo2?branch=main#fe7522c85c8c434d7ceb9f663b0fb51909b9994f"
+source = "git+https://github.com/zkonduit/halo2?branch=main#4d7e6ddac661283e2b73c551b2e8f0011cedd50f"
 dependencies = [
 "blake2b_simd",
 "env_logger",
@@ -2290,12 +2230,10 @@ dependencies = [
 "icicle",
 "log",
 "maybe-rayon",
- "plotters",
 "rand_chacha",
 "rand_core 0.6.4",
 "rustacuda",
 "sha3 0.9.1",
- "tabbycat",
 "tracing",
 ]

@@ -2624,12 +2562,6 @@ dependencies = [
 "serde_derive",
 ]

-[[package]]
-name = "ident_case"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
-
 [[package]]
 name = "idna"
 version = "0.4.0"
@@ -5014,12 +4946,6 @@ dependencies = [
 "unicode-normalization",
 ]

-[[package]]
-name = "strsim"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6446ced80d6c486436db5c078dde11a9f73d42b57fb273121e160b84f63d894c"
-
 [[package]]
 name = "strsim"
 version = "0.10.0"
@@ -5110,17 +5036,6 @@ dependencies = [
 "libc",
 ]

-[[package]]
-name = "tabbycat"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c45590f0f859197b4545be1b17b2bc3cc7bb075f7d1cc0ea1dc6521c0bf256a3"
-dependencies = [
- "anyhow",
- "derive_builder",
- "regex",
-]
-
 [[package]]
 name = "tabled"
 version = "0.12.2"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,73 +15,96 @@ 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 = { git = "https://github.com/privacy-scaling-explorations/halo2curves", rev = "9fff22c", 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" }
+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.11", 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"
@@ -153,11 +176,24 @@ 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 = []
@@ -165,7 +201,7 @@ 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"]
--- a/README.md
+++ b/README.md
@@ -31,9 +31,9 @@ EZKL

 [![Notebook](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/zkonduit/ezkl/blob/main/examples/notebooks/simple_demo_all_public.ipynb) 

-In the backend we use [Halo2](https://github.com/privacy-scaling-explorations/halo2) as a proof system.
+In the backend we use the collaboratively-developed [Halo2](https://github.com/privacy-scaling-explorations/halo2) as a proof system.

-The generated proofs can then be used on-chain to verify computation, only the Ethereum Virtual Machine (EVM) is supported at the moment.
+The generated proofs can then be verified with much less computational resources, including on-chain (with the Ethereum Virtual Machine), in a browser, or on a device. 

 - If you have any questions, we'd love for you to open up a discussion topic in [Discussions](https://github.com/zkonduit/ezkl/discussions). Alternatively, you can join the ✨[EZKL Community Telegram Group](https://t.me/+QRzaRvTPIthlYWMx)💫.

@@ -45,6 +45,8 @@ The generated proofs can then be used on-chain to verify computation, only the E

 ### getting started ⚙️

+The easiest way to get started is to try out a notebook. 
+
 #### Python
 Install the python bindings by calling.

@@ -70,10 +72,14 @@ curl https://raw.githubusercontent.com/zkonduit/ezkl/main/install_ezkl_cli.sh |

 https://user-images.githubusercontent.com/45801863/236771676-5bbbbfd1-ba6f-418a-902e-20738ce0e9f0.mp4

-For more details visit the [docs](https://docs.ezkl.xyz).
+For more details visit the [docs](https://docs.ezkl.xyz). The CLI is faster than Python, as it has less overhead. For even more speed and convenience, check out the [remote proving service](https://ei40vx5x6j0.typeform.com/to/sFv1oxvb), which feels like the CLI but is backed by a tuned cluster.

 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 🔨

@@ -120,17 +126,6 @@ unset ENABLE_ICICLE_GPU

 **NOTE:** Even with the above environment variable set, icicle is disabled for circuits where k <= 8. To change the value of `k` where icicle is enabled, you can set the environment variable `ICICLE_SMALL_K`.

-### repos
-
-The EZKL project has several libraries and repos. 
-
-| Repo | Description |
-| --- | --- |
-| [@zkonduit/ezkl](https://github.com/zkonduit/ezkl) | the main ezkl repo in rust with wasm and python bindings |
-| [@zkonduit/ezkljs](https://github.com/zkonduit/ezkljs) | typescript and javascript tooling to help integrate ezkl into web apps |
-
----------------------
-
 ### contributing 🌎

 If you're interested in contributing and are unsure where to start, reach out to one of the maintainers:
@@ -147,7 +142,7 @@ More broadly:
 - To report bugs or request new features [create a new issue within Issues](https://github.com/zkonduit/ezkl/issues) to inform the greater community.


-Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you shall be licensed to Zkonduit Inc. under the terms and conditions specified in the [CLA](https://github.com/zkonduit/ezkl/blob/main/cla.md), which you agree to by intentionally submitting a contribution. In particular, you have the right to submit the contribution and we can distribute it under the Apache 2.0 license, among other terms and conditions. 
+Any contribution intentionally submitted for inclusion in the work by you shall be licensed to Zkonduit Inc. under the terms and conditions specified in the [CLA](https://github.com/zkonduit/ezkl/blob/main/cla.md), which you agree to by intentionally submitting a contribution. In particular, you have the right to submit the contribution and we can distribute it, among other terms and conditions. 

 ### no security guarantees

@@ -155,4 +150,7 @@ Ezkl is unaudited, beta software undergoing rapid development. There may be bugs

 > NOTE: Because operations are quantized when they are converted from an onnx file to a zk-circuit, outputs in python and ezkl may differ slightly. 

+### no warranty

+Copyright (c) 2024 Zkonduit Inc. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/benches/accum_conv.rs
+++ b/benches/accum_conv.rs
@@ -2,11 +2,13 @@ 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_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::srs::gen_srs;
 use ezkl::pfsys::TranscriptType;
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
+use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    arithmetic::Field,
@@ -15,6 +17,7 @@ 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;
@@ -121,28 +124,35 @@ 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>, Fr, MyCircuit>(
-                        &circuit, &params, true,
-                    )
-                    .unwrap();
+                    create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                        .unwrap();
                });
            });

-            let pk =
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-                    .unwrap();
+            let pk = create_keys::<KZGCommitmentScheme<Bn256>, 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_kzg(
+                    let prover = create_proof_circuit::<
+                        KZGCommitmentScheme<_>,
+                        MyCircuit,
+                        ProverSHPLONK<_>,
+                        VerifierSHPLONK<_>,
+                        SingleStrategy<_>,
+                        _,
+                        EvmTranscript<_, _, _, _>,
+                        EvmTranscript<_, _, _, _>,
+                    >(
                        circuit.clone(),
+                        vec![],
                        &params,
-                        None,
                        &pk,
-                        TranscriptType::EVM,
-                        SingleStrategy::new(&params),
                        CheckMode::UNSAFE,
+                        ezkl::Commitments::KZG,
+                        TranscriptType::EVM,
+                        None,
                        None,
                    );
                    prover.unwrap();
--- a/benches/accum_dot.rs
+++ b/benches/accum_dot.rs
@@ -1,11 +1,13 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+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,
@@ -14,6 +16,7 @@ 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;
@@ -90,25 +93,35 @@ 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>, Fr, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            create_keys::<KZGCommitmentScheme<Bn256>, 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_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
-                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
+                    TranscriptType::EVM,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/accum_einsum_matmul.rs
+++ b/benches/accum_einsum_matmul.rs
@@ -1,11 +1,13 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+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,
@@ -14,6 +16,7 @@ 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;
@@ -94,25 +97,35 @@ 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>, Fr, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            create_keys::<KZGCommitmentScheme<Bn256>, 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_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
-                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
+                    TranscriptType::EVM,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/accum_matmul_relu.rs
+++ b/benches/accum_matmul_relu.rs
@@ -4,17 +4,20 @@ use ezkl::circuit::*;

 use ezkl::circuit::lookup::LookupOp;
 use ezkl::circuit::poly::PolyOp;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+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);
@@ -112,25 +115,35 @@ 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>, Fr, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            create_keys::<KZGCommitmentScheme<Bn256>, 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_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
+                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
-                    CheckMode::SAFE,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/accum_matmul_relu_overflow.rs
+++ b/benches/accum_matmul_relu_overflow.rs
@@ -4,17 +4,20 @@ use ezkl::circuit::*;
 use ezkl::circuit::lookup::LookupOp;
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::table::Range;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+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);
@@ -115,25 +118,35 @@ 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>, Fr, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            create_keys::<KZGCommitmentScheme<Bn256>, 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_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
+                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
-                    CheckMode::SAFE,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/accum_sum.rs
+++ b/benches/accum_sum.rs
@@ -1,11 +1,13 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+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,
@@ -14,6 +16,7 @@ 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,25 +89,35 @@ 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>, Fr, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            create_keys::<KZGCommitmentScheme<Bn256>, 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_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
-                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
+                    TranscriptType::EVM,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/accum_sumpool.rs
+++ b/benches/accum_sumpool.rs
@@ -2,11 +2,13 @@ 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_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::srs::gen_srs;
 use ezkl::pfsys::TranscriptType;
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
+use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    arithmetic::Field,
@@ -15,6 +17,7 @@ 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;
@@ -101,28 +104,35 @@ 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>, Fr, MyCircuit>(
-                        &circuit, &params, true,
-                    )
-                    .unwrap();
+                    create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
+                        .unwrap();
                });
            });

-            let pk =
-                create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-                    .unwrap();
+            let pk = create_keys::<KZGCommitmentScheme<Bn256>, 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_kzg(
+                    let prover = create_proof_circuit::<
+                        KZGCommitmentScheme<_>,
+                        MyCircuit,
+                        ProverSHPLONK<_>,
+                        VerifierSHPLONK<_>,
+                        SingleStrategy<_>,
+                        _,
+                        EvmTranscript<_, _, _, _>,
+                        EvmTranscript<_, _, _, _>,
+                    >(
                        circuit.clone(),
+                        vec![],
                        &params,
-                        None,
                        &pk,
-                        TranscriptType::EVM,
-                        SingleStrategy::new(&params),
                        CheckMode::UNSAFE,
+                        ezkl::Commitments::KZG,
+                        TranscriptType::EVM,
+                        None,
                        None,
                    );
                    prover.unwrap();
--- a/benches/pairwise_add.rs
+++ b/benches/pairwise_add.rs
@@ -1,11 +1,13 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use ezkl::circuit::poly::PolyOp;
 use ezkl::circuit::*;
-use ezkl::pfsys::create_proof_circuit_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+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,
@@ -14,6 +16,7 @@ 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;
@@ -84,25 +87,35 @@ 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>, Fr, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            create_keys::<KZGCommitmentScheme<Bn256>, 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_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
+                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
-                    CheckMode::SAFE,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/pairwise_pow.rs
+++ b/benches/pairwise_pow.rs
@@ -2,11 +2,13 @@ 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_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+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,
@@ -15,6 +17,7 @@ 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;
@@ -83,25 +86,35 @@ 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>, Fr, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            create_keys::<KZGCommitmentScheme<Bn256>, 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_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
+                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
-                    CheckMode::SAFE,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/poseidon.rs
+++ b/benches/poseidon.rs
@@ -4,12 +4,13 @@ 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_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::srs::gen_srs;
 use ezkl::pfsys::TranscriptType;
 use ezkl::tensor::*;
 use halo2_proofs::circuit::Value;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    arithmetic::Field,
@@ -18,6 +19,7 @@ use halo2_proofs::{
 };
 use halo2curves::bn256::{Bn256, Fr};
 use rand::rngs::OsRng;
+use snark_verifier::system::halo2::transcript::evm::EvmTranscript;

 const L: usize = 10;

@@ -62,7 +64,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();

@@ -76,25 +78,35 @@ 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>, Fr, MyCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, MyCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, MyCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            create_keys::<KZGCommitmentScheme<Bn256>, 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_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    MyCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    Some(output[0].clone()),
                    &pk,
-                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
+                    TranscriptType::EVM,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/benches/relu.rs
+++ b/benches/relu.rs
@@ -2,11 +2,12 @@ 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_kzg;
+use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
 use ezkl::tensor::*;
 use halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme;
+use halo2_proofs::poly::kzg::multiopen::{ProverSHPLONK, VerifierSHPLONK};
 use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2_proofs::{
    circuit::{Layouter, SimpleFloorPlanner, Value},
@@ -14,6 +15,7 @@ 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;
@@ -91,25 +93,35 @@ 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>, Fr, NLCircuit>(&circuit, &params, true)
+                create_keys::<KZGCommitmentScheme<Bn256>, NLCircuit>(&circuit, &params, true)
                    .unwrap();
            });
        });

-        let pk = create_keys::<KZGCommitmentScheme<Bn256>, Fr, NLCircuit>(&circuit, &params, true)
-            .unwrap();
+        let pk =
+            create_keys::<KZGCommitmentScheme<Bn256>, 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_kzg(
+                let prover = create_proof_circuit::<
+                    KZGCommitmentScheme<_>,
+                    NLCircuit,
+                    ProverSHPLONK<_>,
+                    VerifierSHPLONK<_>,
+                    SingleStrategy<_>,
+                    _,
+                    EvmTranscript<_, _, _, _>,
+                    EvmTranscript<_, _, _, _>,
+                >(
                    circuit.clone(),
+                    vec![],
                    &params,
-                    None,
                    &pk,
+                    CheckMode::UNSAFE,
+                    ezkl::Commitments::KZG,
                    TranscriptType::EVM,
-                    SingleStrategy::new(&params),
-                    CheckMode::SAFE,
+                    None,
                    None,
                );
                prover.unwrap();
--- a/examples/notebooks/data_attest_hashed.ipynb
+++ b/examples/notebooks/data_attest_hashed.ipynb
@@ -309,7 +309,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "print(ezkl.string_to_felt(res['processed_outputs']['poseidon_hash'][0]))"
+                "print(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]))"
            ]
        },
        {
@@ -325,7 +325,7 @@
            "metadata": {},
            "outputs": [],
            "source": [
-                "from web3 import Web3, HTTPProvider, utils\n",
+                "from web3 import Web3, HTTPProvider\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.string_to_felt(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
+                "    data = [int(ezkl.felt_to_big_endian(res['processed_outputs']['poseidon_hash'][0]), 0)]\n",
                "\n",
                "    # Step 1: Prepare the data\n",
                "    # Step 2: Prepare and compile the contract.\n",
@@ -648,7 +648,7 @@
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
-            "version": "3.9.13"
+            "version": "3.9.15"
        },
        "orig_nbformat": 4
    },
--- a/examples/notebooks/ezkl_demo.ipynb
+++ b/examples/notebooks/ezkl_demo.ipynb
@@ -695,17 +695,19 @@
        "formatted_output = \"[\"\n",
        "for i, value in enumerate(proof[\"instances\"]):\n",
        "    for j, field_element in enumerate(value):\n",
-        "        onchain_input_array.append(ezkl.string_to_felt(field_element))\n",
-        "        formatted_output += str(onchain_input_array[-1])\n",
+        "        onchain_input_array.append(ezkl.felt_to_big_endian(field_element))\n",
+        "        formatted_output += '\"' + str(onchain_input_array[-1]) + '\"'\n",
        "        if j != len(value) - 1:\n",
        "            formatted_output += \", \"\n",
-        "    formatted_output += \"]\"\n",
+        "    if i != len(proof[\"instances\"]) - 1:\n",
+        "        formatted_output += \", \"\n",
+        "formatted_output += \"]\"\n",
        "\n",
        "# This will be the values you use onchain\n",
        "# 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: \", \"0x\" + proof[\"proof\"])"
+        "print(\"proof: \", proof[\"proof\"])"
      ]
    },
    {
--- a/examples/notebooks/generalized_inverse.ipynb
+++ b/examples/notebooks/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 kzgcommit of $A$, $b$ the kzgcommit 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 polycommit of $A$, $b$ the polycommit of $B$, and $ABA = A$.\n"
      ]
    },
    {
@@ -77,7 +77,7 @@
      "outputs": [],
      "source": [
        "gip_run_args = ezkl.PyRunArgs()\n",
-        "gip_run_args.input_visibility = \"kzgcommit\"  # matrix and generalized inverse commitments\n",
+        "gip_run_args.input_visibility = \"polycommit\"  # matrix and generalized inverse commitments\n",
        "gip_run_args.output_visibility = \"fixed\"   # no parameters used\n",
        "gip_run_args.param_visibility = \"fixed\" # should be Tensor(True)"
      ]
@@ -340,4 +340,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/hashed_vis.ipynb
+++ b/examples/notebooks/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",
-                "- `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",
+                "- `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",
                "\n",
                "\n",
                "Here we create the following setup:\n",
@@ -510,4 +510,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 2
-}
+}
--- a/examples/notebooks/kzg_vis.ipynb
+++ b/examples/notebooks/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",
-                "- `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",
+                "- `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",
                "\n",
                "Here we create the following setup:\n",
-                "- `input_visibility`: \"kzgcommit\"\n",
-                "- `param_visibility`: \"kzgcommit\"\n",
+                "- `input_visibility`: \"polycommit\"\n",
+                "- `param_visibility`: \"polycommit\"\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 = \"kzgcommit\"\n",
-                "run_args.param_visibility = \"kzgcommit\"\n",
+                "run_args.input_visibility = \"polycommit\"\n",
+                "run_args.param_visibility = \"polycommit\"\n",
                "run_args.output_visibility = \"public\"\n",
                "run_args.variables = [(\"batch_size\", 1)]\n",
                "\n",
@@ -512,4 +512,4 @@
    },
    "nbformat": 4,
    "nbformat_minor": 2
-}
+}
--- a/examples/notebooks/mnist_gan_proof_splitting.ipynb
+++ b/examples/notebooks/mnist_gan_proof_splitting.ipynb
@@ -264,9 +264,9 @@
                "###  KZG commitment intermediate calculations\n",
                "\n",
                "the visibility parameters are:\n",
-                "- `input_visibility`: \"kzgcommit\"\n",
+                "- `input_visibility`: \"polycommit\"\n",
                "- `param_visibility`: \"public\"\n",
-                "- `output_visibility`: kzgcommit"
+                "- `output_visibility`: polycommit"
            ]
        },
        {
@@ -280,15 +280,15 @@
                "srs_path = os.path.join('kzg.srs')\n",
                "\n",
                "run_args = ezkl.PyRunArgs()\n",
-                "run_args.input_visibility = \"kzgcommit\"\n",
+                "run_args.input_visibility = \"polycommit\"\n",
                "run_args.param_visibility = \"fixed\"\n",
-                "run_args.output_visibility = \"kzgcommit\"\n",
+                "run_args.output_visibility = \"polycommit\"\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)\n"
+                "ezkl.get_srs(logrows=run_args.logrows, commitment=ezkl.PyCommitments.KZG)\n"
            ]
        },
        {
@@ -343,7 +343,6 @@
                "         compiled_model_path,\n",
                "         vk_path,\n",
                "         pk_path,\n",
-                "         compress_selectors=True,\n",
                "      )\n",
                "\n",
                "    assert res == True\n",
--- a/examples/notebooks/proof_splitting.ipynb
+++ b/examples/notebooks/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",
-                "- `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",
+                "- `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",
                "\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)"
+                "ezkl.get_srs(logrows=run_args.logrows, commitment=ezkl.PyCommitments.KZG)"
            ]
        },
        {
@@ -385,9 +385,9 @@
                "###  KZG commitment intermediate calculations\n",
                "\n",
                "This time the visibility parameters are:\n",
-                "- `input_visibility`: \"kzgcommit\"\n",
+                "- `input_visibility`: \"polycommit\"\n",
                "- `param_visibility`: \"public\"\n",
-                "- `output_visibility`: kzgcommit"
+                "- `output_visibility`: polycommit"
            ]
        },
        {
@@ -399,9 +399,9 @@
                "import ezkl\n",
                "\n",
                "run_args = ezkl.PyRunArgs()\n",
-                "run_args.input_visibility = \"kzgcommit\"\n",
+                "run_args.input_visibility = \"polycommit\"\n",
                "run_args.param_visibility = \"fixed\"\n",
-                "run_args.output_visibility = \"kzgcommit\"\n",
+                "run_args.output_visibility = \"polycommit\"\n",
                "run_args.variables = [(\"batch_size\", 1)]\n",
                "run_args.input_scale = 2\n",
                "run_args.logrows = 8\n"
--- a/examples/notebooks/set_membership.ipynb
+++ b/examples/notebooks/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_string(e,7))\n",
-        "    result.append(ezkl.poseidon_hash([ezkl.float_to_string(e, 7)])[0])\n",
+        "    print(ezkl.float_to_felt(e,7))\n",
+        "    result.append(ezkl.poseidon_hash([ezkl.float_to_felt(e, 7)])[0])\n",
        "\n",
        "y = y.unsqueeze(0)\n",
        "y = y.reshape(1, 9)\n",
--- a/examples/notebooks/simple_demo_aggregated_proofs.ipynb
+++ b/examples/notebooks/simple_demo_aggregated_proofs.ipynb
@@ -275,7 +275,6 @@
                "        proof_path,\n",
                "        settings_path,\n",
                "        vk_path,\n",
-                "        \n",
                "    )\n",
                "\n",
                "assert res == True\n",
@@ -291,7 +290,7 @@
            "source": [
                "# Generate a larger SRS. This is needed for the aggregated proof\n",
                "\n",
-                "res = ezkl.get_srs(settings_path=None, logrows=21)"
+                "res = ezkl.get_srs(settings_path=None, logrows=21, commitment=ezkl.PyCommitments.KZG)"
            ]
        },
        {
--- a/examples/notebooks/solvency.ipynb
+++ b/examples/notebooks/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 kzgcommit 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 polycommit 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_string(e, 0)])[0])\n",
+        "    users.append(ezkl.poseidon_hash([ezkl.float_to_felt(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",
-        "- `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",
+        "- `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",
        "\n",
        "Here we create the following setup:\n",
-        "- `input_visibility`: \"kzgcommit\"\n",
+        "- `input_visibility`: \"polycommit\"\n",
        "- `param_visibility`: \"public\"\n",
        "- `output_visibility`: public\n",
        "\n",
@@ -202,8 +202,8 @@
      "outputs": [],
      "source": [
        "run_args = ezkl.PyRunArgs()\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",
+        "# \"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",
        "# 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_string(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_felt(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_string(1.0, 0)]\n",
+        "witness[\"outputs\"][0] = [ezkl.float_to_felt(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.13"
+      "version": "3.9.15"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
--- a/examples/notebooks/tictactoe_autoencoder.ipynb
+++ b/examples/notebooks/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 = [4])"
+                "ezkl.calibrate_settings(cal_path, model_path, settings_path, \"resources\", scales = [11])"
            ]
        },
        {
@@ -664,7 +664,6 @@
                "    compiled_model_path,\n",
                "    vk_path,\n",
                "    pk_path,\n",
-                "    \n",
                ")"
            ]
        },
--- a/examples/notebooks/world_rotation.ipynb
+++ b/examples/notebooks/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.string_to_float(witness['outputs'][0][0], out_scale)\n",
-    "arrow_y = ezkl.string_to_float(witness['outputs'][0][1], out_scale)\n",
+    "arrow_x = ezkl.felt_to_float(witness['outputs'][0][0], out_scale)\n",
+    "arrow_y = ezkl.felt_to_float(witness['outputs'][0][1], out_scale)\n",
    "pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)\n",
-    "arrow_x = ezkl.string_to_float(witness['outputs'][0][2], out_scale)\n",
-    "arrow_y = ezkl.string_to_float(witness['outputs'][0][3], out_scale)\n",
+    "arrow_x = ezkl.felt_to_float(witness['outputs'][0][2], out_scale)\n",
+    "arrow_y = ezkl.felt_to_float(witness['outputs'][0][3], out_scale)\n",
    "pyplot.arrow(0, 0, arrow_x, arrow_y, width=0.02)"
   ]
  }
--- a/examples/onnx/1l_lppool/gen.py
+++ b/examples/onnx/1l_lppool/gen.py
@@ -0,0 +1,40 @@
+from torch import nn
+import torch
+import json
+
+class Model(nn.Module):
+    def __init__(self):
+        super(Model, self).__init__()
+        self.layer = nn.LPPool2d(2, 1, (1, 1))
+
+    def forward(self, x):
+        return self.layer(x)[0]
+
+
+circuit = Model()
+
+x = torch.empty(1, 3, 2, 2).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
+
--- a/examples/onnx/1l_lppool/input.json
+++ b/examples/onnx/1l_lppool/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.7549541592597961, 0.990360677242279, 0.9473411440849304, 0.3951031565666199, 0.8500555753707886, 0.9352139830589294, 0.11867779493331909, 0.9493132829666138, 0.6588345766067505, 0.1933223009109497, 0.12139874696731567, 0.8547163605690002]]}
--- a/examples/onnx/1l_lppool/network.onnx
+++ b/examples/onnx/1l_lppool/network.onnx
--- a/examples/onnx/celu/gen.py
+++ b/examples/onnx/celu/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = nn.CELU()(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/celu/input.json
+++ b/examples/onnx/celu/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.35387128591537476, 0.030473172664642334, 0.08707714080810547, 0.2429301142692566, 0.45228832960128784, 0.496021032333374, 0.13245105743408203, 0.8497090339660645]]}
--- a/examples/onnx/celu/network.onnx
+++ b/examples/onnx/celu/network.onnx
--- a/examples/onnx/clip/gen.py
+++ b/examples/onnx/clip/gen.py
@@ -0,0 +1,41 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.clamp(x, min=0.4, max=0.8)
+        return m
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 2, 2, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/clip/input.json
+++ b/examples/onnx/clip/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.03297048807144165, 0.46362626552581787, 0.6044231057167053, 0.4949902892112732, 0.48823297023773193, 0.6798646450042725, 0.6824942231178284, 0.03491640090942383, 0.19608813524246216, 0.24129939079284668, 0.9769315123558044, 0.6306831240653992, 0.7690497636795044, 0.252221941947937, 0.9167693853378296, 0.3882681131362915, 0.9307044148445129, 0.33559417724609375, 0.7815426588058472, 0.3435332179069519, 0.7871478796005249, 0.12240773439407349, 0.5295405983924866, 0.4874419569969177, 0.08262640237808228, 0.1124718189239502, 0.5834914445877075, 0.30927878618240356, 0.48899340629577637, 0.9376634955406189, 0.21893149614334106, 0.526070773601532]]}
--- a/examples/onnx/clip/network.onnx
+++ b/examples/onnx/clip/network.onnx
@@ -0,0 +1,24 @@
+pytorch2.2.1:±
+?/Constant_output_0	/Constant"Constant*
+value*JÍÌÌ> 
+C/Constant_1_output_0/Constant_1"Constant*
+value*JÍÌL? 
+F
+input
+/Constant_output_0
+/Constant_1_output_0output/Clip"Clip
+main_graphZ)
+input 
+
+
+batch_size
+
+
+b*
+output 
+
+
+batch_size
+
+
+B
--- a/examples/onnx/gather_nd/gen.py
+++ b/examples/onnx/gather_nd/gen.py
@@ -0,0 +1,48 @@
+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'))
--- a/examples/onnx/gather_nd/input.json
+++ b/examples/onnx/gather_nd/input.json
--- a/examples/onnx/gather_nd/network.onnx
+++ b/examples/onnx/gather_nd/network.onnx
--- a/examples/onnx/gru/gen.py
+++ b/examples/onnx/gru/gen.py
@@ -0,0 +1,41 @@
+import random
+import math
+import numpy as np
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+import json
+
+
+model = nn.GRU(3, 3)  # Input dim is 3, output dim is 3
+x = torch.randn(1, 3)  # make a sequence of length 5
+
+print(x)
+
+# Flips the neural net into inference mode
+model.eval()
+model.to('cpu')
+
+# Export the model
+torch.onnx.export(model,               # model being run
+                  # model input (or a tuple for multiple inputs)
+                  x,
+                  # where to save the model (can be a file or file-like object)
+                  "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=10,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},    # variable length axes
+                                'output': {0: 'batch_size'}})
+
+data_array = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data_json = dict(input_data=[data_array])
+
+print(data_json)
+
+# Serialize data into file:
+json.dump(data_json, open("input.json", 'w'))
--- a/examples/onnx/gru/input.json
+++ b/examples/onnx/gru/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.4145222008228302, -0.4043896496295929, 0.7545749545097351]]}
--- a/examples/onnx/gru/network.onnx
+++ b/examples/onnx/gru/network.onnx
--- a/examples/onnx/hard_max/gen.py
+++ b/examples/onnx/hard_max/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.argmax(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/hard_max/input.json
+++ b/examples/onnx/hard_max/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.5505883693695068, 0.0766521692276001, 0.12006187438964844, 0.9497959017753601, 0.9100563526153564, 0.968717098236084, 0.5978299379348755, 0.9419963359832764]]}
--- a/examples/onnx/hard_max/network.onnx
+++ b/examples/onnx/hard_max/network.onnx
--- a/examples/onnx/hard_sigmoid/gen.py
+++ b/examples/onnx/hard_sigmoid/gen.py
@@ -9,7 +9,7 @@ class MyModel(nn.Module):
        super(MyModel, self).__init__()

    def forward(self, x):          
-        m = nn.Logsoftmax()(x)
+        m = nn.Hardsigmoid()(x)
        
        return m 

--- a/examples/onnx/hard_sigmoid/input.json
+++ b/examples/onnx/hard_sigmoid/input.json
@@ -1 +1 @@
-{"input_data": [[0.2971532940864563, 0.3465197682380676, 0.05381882190704346, 0.058654189109802246, 0.014198064804077148, 0.06088751554489136, 0.1723427176475525, 0.5115123987197876]]}
+{"input_data": [[0.8326942324638367, 0.2796096205711365, 0.600328266620636, 0.3701696991920471, 0.17832040786743164, 0.6247223019599915, 0.501872718334198, 0.6961578726768494]]}
--- a/examples/onnx/hard_sigmoid/network.onnx
+++ b/examples/onnx/hard_sigmoid/network.onnx
@@ -1,4 +1,4 @@
-pytorch2.1.0:<3A>
+pytorch2.2.1:<3A>
 ;
 inputoutput/HardSigmoid"HardSigmoid*
 alpha«ª*> 
--- a/examples/onnx/hard_swish/gen.py
+++ b/examples/onnx/hard_swish/gen.py
@@ -0,0 +1,41 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):
+        m = nn.Hardswish()(x)
+        return m
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/hard_swish/input.json
+++ b/examples/onnx/hard_swish/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.6996762752532959, 0.42992985248565674, 0.5102168321609497, 0.5540387630462646, 0.8489438891410828, 0.8533616065979004, 0.36736780405044556, 0.5859147310256958]]}
--- a/examples/onnx/hard_swish/network.onnx
+++ b/examples/onnx/hard_swish/network.onnx
@@ -0,0 +1,15 @@
+pytorch2.2.1:{
+&
+inputoutput
+/HardSwish"	HardSwish
+main_graphZ!
+input
+
+
+batch_size
+b"
+output
+
+
+batch_size
+B
--- a/examples/onnx/log_softmax/gen.py
+++ b/examples/onnx/log_softmax/gen.py
@@ -9,7 +9,7 @@ class MyModel(nn.Module):
        super(MyModel, self).__init__()

    def forward(self, x):          
-        m = nn.Hardsigmoid()(x)
+        m = nn.LogSoftmax()(x)
        
        return m 

--- a/examples/onnx/logsumexp/gen.py
+++ b/examples/onnx/logsumexp/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.logsumexp(x, dim=1)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 2, 2, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/logsumexp/input.json
+++ b/examples/onnx/logsumexp/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.7973018884658813, 0.5245689153671265, 0.34149593114852905, 0.1455438733100891, 0.9482707381248474, 0.4221445322036743, 0.001363217830657959, 0.8736765384674072, 0.42954301834106445, 0.7199509739875793, 0.37641745805740356, 0.5920265316963196, 0.42270803451538086, 0.41761744022369385, 0.603948712348938, 0.7250819802284241, 0.047173500061035156, 0.5115441679954529, 0.3743387460708618, 0.16794061660766602, 0.5352339148521423, 0.037976861000061035, 0.65323406457901, 0.5585184097290039, 0.10559147596359253, 0.07827490568161011, 0.6717077493667603, 0.6480781435966492, 0.9780838489532471, 0.8353415131568909, 0.6491701006889343, 0.6573048233985901]]}
--- a/examples/onnx/logsumexp/network.onnx
+++ b/examples/onnx/logsumexp/network.onnx
--- a/examples/onnx/mish/gen.py
+++ b/examples/onnx/mish/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = nn.Mish()(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/mish/input.json
+++ b/examples/onnx/mish/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.18563222885131836, 0.4843214750289917, 0.9991059899330139, 0.02534431219100952, 0.8105666041374207, 0.9658406376838684, 0.681107759475708, 0.5365872979164124]]}
--- a/examples/onnx/mish/network.onnx
+++ b/examples/onnx/mish/network.onnx
@@ -0,0 +1,19 @@
+pytorch2.2.1:ä
+0
+input/Softplus_output_0	/Softplus"Softplus
+1
+/Softplus_output_0/Tanh_output_0/Tanh"Tanh
+*
+input
+/Tanh_output_0output/Mul"Mul
+main_graphZ!
+input
+
+
+batch_size
+b"
+output
+
+
+batch_size
+B
--- a/examples/onnx/reducel1/gen.py
+++ b/examples/onnx/reducel1/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.norm(x, p=1, dim=1)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 2, 2, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/reducel1/input.json
+++ b/examples/onnx/reducel1/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.02284395694732666, 0.7941043376922607, 0.07971876859664917, 0.8898420929908752, 0.8233054280281067, 0.11066079139709473, 0.4424799084663391, 0.4355071783065796, 0.6723723411560059, 0.6818525195121765, 0.8726171851158142, 0.17742449045181274, 0.054257750511169434, 0.5775953531265259, 0.7758923172950745, 0.8431423306465149, 0.7602444887161255, 0.29686522483825684, 0.22489851713180542, 0.0675363540649414, 0.981339693069458, 0.15771394968032837, 0.5801441669464111, 0.9044001698493958, 0.49266451597213745, 0.42621421813964844, 0.35345613956451416, 0.042848050594329834, 0.6908614039421082, 0.5422852039337158, 0.01975083351135254, 0.5772860050201416]]}
--- a/examples/onnx/reducel1/network.onnx
+++ b/examples/onnx/reducel1/network.onnx
--- a/examples/onnx/reducel2/gen.py
+++ b/examples/onnx/reducel2/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.norm(x, p=2, dim=1)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 2, 2, 8).uniform_(0, 1)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/reducel2/input.json
+++ b/examples/onnx/reducel2/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.8709188103675842, 0.11553549766540527, 0.27376580238342285, 0.7518517971038818, 0.7879393100738525, 0.8765475749969482, 0.14315760135650635, 0.8982420563697815, 0.7274006605148315, 0.39007169008255005, 0.729040801525116, 0.11306107044219971, 0.658822774887085, 0.666404664516449, 0.3001367449760437, 0.45343858003616333, 0.7460223436355591, 0.7423691749572754, 0.7544230818748474, 0.5674425959587097, 0.8728761672973633, 0.27062875032424927, 0.1595977544784546, 0.22975260019302368, 0.6711723208427429, 0.8265992403030396, 0.48679041862487793, 0.689740777015686, 0.330846905708313, 0.5630669593811035, 0.8058932423591614, 0.5802426338195801]]}
--- a/examples/onnx/reducel2/network.onnx
+++ b/examples/onnx/reducel2/network.onnx
--- a/examples/onnx/scatter_nd/gen.py
+++ b/examples/onnx/scatter_nd/gen.py
@@ -0,0 +1,76 @@
+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'))
--- a/examples/onnx/scatter_nd/input.json
+++ b/examples/onnx/scatter_nd/input.json
@@ -0,0 +1 @@
+{"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]]}
--- a/examples/onnx/scatter_nd/network.onnx
+++ b/examples/onnx/scatter_nd/network.onnx
--- a/examples/onnx/tril/gen.py
+++ b/examples/onnx/tril/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.triu(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 3, 3).uniform_(0, 5)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/tril/input.json
+++ b/examples/onnx/tril/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.4870188236236572, 2.275230646133423, 3.126268148422241, 0.6412187218666077, 0.9967470169067383, 1.9814395904541016, 1.6355383396148682, 0.6397527456283569, 0.7825168967247009]]}
--- a/examples/onnx/tril/network.onnx
+++ b/examples/onnx/tril/network.onnx
--- a/examples/onnx/triu/gen.py
+++ b/examples/onnx/triu/gen.py
@@ -0,0 +1,42 @@
+from torch import nn
+import torch
+import json
+import numpy as np
+
+
+class MyModel(nn.Module):
+    def __init__(self):
+        super(MyModel, self).__init__()
+
+    def forward(self, x):          
+        m = torch.tril(x)
+        
+        return m 
+
+
+circuit = MyModel()
+
+x = torch.empty(1, 3, 3).uniform_(0, 5)
+
+out = circuit(x)
+
+print(out)
+
+torch.onnx.export(circuit, x, "network.onnx",
+                  export_params=True,        # store the trained parameter weights inside the model file
+                  opset_version=17,          # the ONNX version to export the model to
+                  do_constant_folding=True,  # whether to execute constant folding for optimization
+                  input_names=['input'],   # the model's input names
+                  output_names=['output'],  # the model's output names
+                  dynamic_axes={'input': {0: 'batch_size'},  # variable length axes
+                                'output': {0: 'batch_size'}})
+
+
+d1 = ((x).detach().numpy()).reshape([-1]).tolist()
+
+data = dict(
+    input_data=[d1],
+)
+
+# Serialize data into file:
+json.dump(data, open("input.json", 'w'))
--- a/examples/onnx/triu/input.json
+++ b/examples/onnx/triu/input.json
@@ -0,0 +1 @@
+{"input_data": [[0.2898547053337097, 1.8070811033248901, 0.30266255140304565, 3.00581955909729, 0.5379888415336609, 1.7057424783706665, 2.415961265563965, 0.589233934879303, 0.03824889659881592]]}
--- a/examples/onnx/triu/network.onnx
+++ b/examples/onnx/triu/network.onnx
--- a/in-browser-evm-verifier/README.md
+++ b/in-browser-evm-verifier/README.md
@@ -0,0 +1,60 @@
+# 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
+```
+
+
--- a/in-browser-evm-verifier/package.json
+++ b/in-browser-evm-verifier/package.json
@@ -0,0 +1,42 @@
+{
+  "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"
+  }
+}
--- a/in-browser-evm-verifier/pnpm-lock.yaml
+++ b/in-browser-evm-verifier/pnpm-lock.yaml
--- a/in-browser-evm-verifier/src/index.ts
+++ b/in-browser-evm-verifier/src/index.ts
@@ -0,0 +1,145 @@
+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
+  }
+}
--- a/in-browser-evm-verifier/src/utils/account-utils.ts
+++ b/in-browser-evm-verifier/src/utils/account-utils.ts
@@ -0,0 +1,32 @@
+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)
+  }
+}
--- a/in-browser-evm-verifier/src/utils/tx-builder.ts
+++ b/in-browser-evm-verifier/src/utils/tx-builder.ts
@@ -0,0 +1,59 @@
+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,
+  }
+}
--- a/in-browser-evm-verifier/tsconfig.commonjs.json
+++ b/in-browser-evm-verifier/tsconfig.commonjs.json
@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "outDir": "./dist/commonjs"
+  }
+}
--- a/in-browser-evm-verifier/tsconfig.esm.json
+++ b/in-browser-evm-verifier/tsconfig.esm.json
@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "ES2020",
+    "outDir": "./dist/esm"
+  }
+}
--- a/in-browser-evm-verifier/tsconfig.json
+++ b/in-browser-evm-verifier/tsconfig.json
@@ -0,0 +1,62 @@
+{
+  "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"
+    ]
+  }
+}
--- a/package.json
+++ b/package.json
@@ -7,7 +7,7 @@
    "test": "jest"
  },
  "devDependencies": {
-    "@ezkljs/engine": "^2.4.5",
+    "@ezkljs/engine": "^9.4.4",
    "@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"
  }
-}
+}
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6,8 +6,8 @@ settings:

 devDependencies:
  '@ezkljs/engine':
-    specifier: ^2.4.5
-    version: 2.4.5
+    specifier: ^9.4.4
+    version: 9.4.4
  '@ezkljs/verify':
    specifier: ^0.0.6
    version: 0.0.6(buffer@6.0.3)
@@ -785,6 +785,13 @@ 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:
--- a/src/circuit/modules/mod.rs
+++ b/src/circuit/modules/mod.rs
@@ -2,7 +2,7 @@
 pub mod poseidon;

 ///
-pub mod kzg;
+pub mod polycommit;

 ///
 pub mod planner;
--- a/src/circuit/modules/polycommit.rs
+++ b/src/circuit/modules/polycommit.rs
@@ -6,10 +6,9 @@ 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, Params};
-use halo2_proofs::poly::kzg::commitment::ParamsKZG;
+use halo2_proofs::poly::commitment::{Blind, CommitmentScheme, Params};
 use halo2_proofs::{circuit::*, plonk::*};
-use halo2curves::bn256::{Bn256, G1Affine};
+use halo2curves::bn256::G1Affine;
 use halo2curves::group::prime::PrimeCurveAffine;
 use halo2curves::group::Curve;
 use halo2curves::CurveAffine;
@@ -18,35 +17,33 @@ use crate::tensor::{Tensor, ValTensor, ValType, VarTensor};

 use super::Module;

-/// The number of instance columns used by the KZG hash function
+/// The number of instance columns used by the PolyCommit hash function
 pub const NUM_INSTANCE_COLUMNS: usize = 0;
-/// The number of advice columns used by the KZG hash function
+/// The number of advice columns used by the PolyCommit hash function
 pub const NUM_INNER_COLS: usize = 1;

 #[derive(Debug, Clone)]
-/// 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 {
+/// Configuration for the PolyCommit chip
+pub struct PolyCommitConfig {
    ///
-    pub hash_inputs: VarTensor,
+    pub 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 KZGChip {
-    config: KZGConfig,
+pub struct PolyCommitChip {
+    config: PolyCommitConfig,
 }

-impl KZGChip {
+impl PolyCommitChip {
    /// Commit to the message using the KZG commitment scheme
-    pub fn commit(
-        message: Vec<Fp>,
+    pub fn commit<Scheme: CommitmentScheme<Scalar = Fp, Curve = G1Affine>>(
+        message: Vec<Scheme::Scalar>,
        degree: u32,
        num_unusable_rows: u32,
-        params: &ParamsKZG<Bn256>,
+        params: &Scheme::ParamsProver,
    ) -> Vec<G1Affine> {
        let k = params.k();
        let domain = halo2_proofs::poly::EvaluationDomain::new(degree, k);
@@ -81,14 +78,14 @@ impl KZGChip {
    }
 }

-impl Module<Fp> for KZGChip {
-    type Config = KZGConfig;
+impl Module<Fp> for PolyCommitChip {
+    type Config = PolyCommitConfig;
    type InputAssignments = InputAssignments;
    type RunInputs = Vec<Fp>;
    type Params = (usize, usize);

    fn name(&self) -> &'static str {
-        "KZG"
+        "PolyCommit"
    }

    fn instance_increment_input(&self) -> Vec<usize> {
@@ -102,8 +99,8 @@ impl Module<Fp> for KZGChip {

    /// Configuration of the PoseidonChip
    fn configure(meta: &mut ConstraintSystem<Fp>, params: Self::Params) -> Self::Config {
-        let hash_inputs = VarTensor::new_unblinded_advice(meta, params.0, NUM_INNER_COLS, params.1);
-        Self::Config { hash_inputs }
+        let inputs = VarTensor::new_unblinded_advice(meta, params.0, NUM_INNER_COLS, params.1);
+        Self::Config { inputs }
    }

    fn layout_inputs(
@@ -125,8 +122,8 @@ impl Module<Fp> for KZGChip {
    ) -> Result<ValTensor<Fp>, Error> {
        assert_eq!(input.len(), 1);
        layouter.assign_region(
-            || "kzg commit",
-            |mut region| self.config.hash_inputs.assign(&mut region, 0, &input[0]),
+            || "PolyCommit",
+            |mut region| self.config.inputs.assign(&mut region, 0, &input[0]),
        )
    }

@@ -163,7 +160,7 @@ mod tests {
    }

    impl Circuit<Fp> for HashCircuit {
-        type Config = KZGConfig;
+        type Config = PolyCommitConfig;
        type FloorPlanner = ModulePlanner;
        type Params = ();

@@ -178,7 +175,7 @@ mod tests {

        fn configure(meta: &mut ConstraintSystem<Fp>) -> Self::Config {
            let params = (K, R);
-            KZGChip::configure(meta, params)
+            PolyCommitChip::configure(meta, params)
        }

        fn synthesize(
@@ -186,8 +183,8 @@ mod tests {
            config: Self::Config,
            mut layouter: impl Layouter<Fp>,
        ) -> Result<(), Error> {
-            let kzg_chip = KZGChip::new(config);
-            kzg_chip.layout(&mut layouter, &[self.message.clone()], 0);
+            let polycommit_chip = PolyCommitChip::new(config);
+            polycommit_chip.layout(&mut layouter, &[self.message.clone()], 0);

            Ok(())
        }
@@ -195,7 +192,7 @@ mod tests {

    #[test]
    #[ignore]
-    fn kzg_for_a_range_of_input_sizes() {
+    fn polycommit_chip_for_a_range_of_input_sizes() {
        let rng = rand::rngs::OsRng;

        #[cfg(not(target_arch = "wasm32"))]
@@ -225,7 +222,7 @@ mod tests {

    #[test]
    #[ignore]
-    fn kzg_commit_much_longer_input() {
+    fn polycommit_chip_much_longer_input() {
        #[cfg(not(target_arch = "wasm32"))]
        env_logger::init();

--- a/src/circuit/ops/base.rs
+++ b/src/circuit/ops/base.rs
@@ -12,15 +12,11 @@ pub enum BaseOp {
    DotInit,
    CumProdInit,
    CumProd,
-    Identity,
    Add,
    Mult,
    Sub,
    SumInit,
    Sum,
-    Neg,
-    Range { tol: i32 },
-    IsZero,
    IsBoolean,
 }

@@ -36,12 +32,8 @@ 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"),
        }
@@ -73,19 +65,15 @@ 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",
        }
    }
@@ -93,8 +81,6 @@ 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),
@@ -104,8 +90,6 @@ 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),
        }
    }
@@ -113,8 +97,6 @@ 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,
@@ -124,8 +106,6 @@ impl BaseOp {
            BaseOp::Mult => 2,
            BaseOp::Sum => 1,
            BaseOp::SumInit => 1,
-            BaseOp::Range { .. } => 1,
-            BaseOp::IsZero => 0,
            BaseOp::IsBoolean => 0,
        }
    }
@@ -133,19 +113,15 @@ impl BaseOp {
    /// 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,
        }
    }
--- a/src/circuit/ops/chip.rs
+++ b/src/circuit/ops/chip.rs
@@ -19,8 +19,8 @@ use serde::{Deserialize, Serialize};
 use tosubcommand::ToFlags;

 use crate::{
-    circuit::ops::base::BaseOp,
    circuit::{
+        ops::base::BaseOp,
        table::{Range, RangeCheck, Table},
        utils,
    },
@@ -188,31 +188,158 @@ impl<'source> FromPyObject<'source> for Tolerance {
    }
 }

+/// A struct representing the selectors for the dynamic lookup tables
+#[derive(Clone, Debug, Default)]
+pub struct DynamicLookups {
+    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many dynamic lookup ops.
+    pub lookup_selectors: BTreeMap<(usize, usize), Selector>,
+    /// Selectors for the dynamic lookup tables
+    pub table_selectors: Vec<Selector>,
+    /// Inputs:
+    pub inputs: Vec<VarTensor>,
+    /// tables
+    pub tables: Vec<VarTensor>,
+}
+
+impl DynamicLookups {
+    /// Returns a new [DynamicLookups] with no inputs, no selectors, and no tables.
+    pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
+        let dummy_var = VarTensor::dummy(col_size, num_inner_cols);
+        let single_col_dummy_var = VarTensor::dummy(col_size, 1);
+
+        Self {
+            lookup_selectors: BTreeMap::new(),
+            table_selectors: vec![],
+            inputs: vec![dummy_var.clone(), dummy_var.clone(), dummy_var.clone()],
+            tables: vec![
+                single_col_dummy_var.clone(),
+                single_col_dummy_var.clone(),
+                single_col_dummy_var.clone(),
+            ],
+        }
+    }
+}
+
+/// A struct representing the selectors for the dynamic lookup tables
+#[derive(Clone, Debug, Default)]
+pub struct Shuffles {
+    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many dynamic lookup ops.
+    pub input_selectors: BTreeMap<(usize, usize), Selector>,
+    /// Selectors for the dynamic lookup tables
+    pub reference_selectors: Vec<Selector>,
+    /// Inputs:
+    pub inputs: Vec<VarTensor>,
+    /// tables
+    pub references: Vec<VarTensor>,
+}
+
+impl Shuffles {
+    /// Returns a new [DynamicLookups] with no inputs, no selectors, and no tables.
+    pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
+        let dummy_var = VarTensor::dummy(col_size, num_inner_cols);
+        let single_col_dummy_var = VarTensor::dummy(col_size, 1);
+
+        Self {
+            input_selectors: BTreeMap::new(),
+            reference_selectors: vec![],
+            inputs: vec![dummy_var.clone(), dummy_var.clone()],
+            references: vec![single_col_dummy_var.clone(), single_col_dummy_var.clone()],
+        }
+    }
+}
+
+/// A struct representing the selectors for the static lookup tables
+#[derive(Clone, Debug, Default)]
+pub struct StaticLookups<F: PrimeField + TensorType + PartialOrd> {
+    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many dynamic lookup ops.
+    pub selectors: BTreeMap<(LookupOp, usize, usize), Selector>,
+    /// Selectors for the dynamic lookup tables
+    pub tables: BTreeMap<LookupOp, Table<F>>,
+    ///
+    pub index: VarTensor,
+    ///
+    pub output: VarTensor,
+    ///
+    pub input: VarTensor,
+}
+
+impl<F: PrimeField + TensorType + PartialOrd> StaticLookups<F> {
+    /// Returns a new [StaticLookups] with no inputs, no selectors, and no tables.
+    pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
+        let dummy_var = VarTensor::dummy(col_size, num_inner_cols);
+
+        Self {
+            selectors: BTreeMap::new(),
+            tables: BTreeMap::new(),
+            index: dummy_var.clone(),
+            output: dummy_var.clone(),
+            input: dummy_var,
+        }
+    }
+}
+
+/// A struct representing the selectors for custom gates
+#[derive(Clone, Debug, Default)]
+pub struct CustomGates {
+    /// the inputs to the accumulated operations.
+    pub inputs: Vec<VarTensor>,
+    /// the (currently singular) output of the accumulated operations.
+    pub output: VarTensor,
+    /// selector
+    pub selectors: BTreeMap<(BaseOp, usize, usize), Selector>,
+}
+
+impl CustomGates {
+    /// Returns a new [CustomGates] with no inputs, no selectors, and no tables.
+    pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
+        let dummy_var = VarTensor::dummy(col_size, num_inner_cols);
+        Self {
+            inputs: vec![dummy_var.clone(), dummy_var.clone()],
+            output: dummy_var,
+            selectors: BTreeMap::new(),
+        }
+    }
+}
+
+/// A struct representing the selectors for the range checks
+#[derive(Clone, Debug, Default)]
+pub struct RangeChecks<F: PrimeField + TensorType + PartialOrd> {
+    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many dynamic lookup ops.
+    pub selectors: BTreeMap<(Range, usize, usize), Selector>,
+    /// Selectors for the dynamic lookup tables
+    pub ranges: BTreeMap<Range, RangeCheck<F>>,
+    ///
+    pub index: VarTensor,
+    ///
+    pub input: VarTensor,
+}
+
+impl<F: PrimeField + TensorType + PartialOrd> RangeChecks<F> {
+    /// Returns a new [RangeChecks] with no inputs, no selectors, and no tables.
+    pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
+        let dummy_var = VarTensor::dummy(col_size, num_inner_cols);
+        Self {
+            selectors: BTreeMap::new(),
+            ranges: BTreeMap::new(),
+            index: dummy_var.clone(),
+            input: dummy_var,
+        }
+    }
+}
+
 /// Configuration for an accumulated arg.
 #[derive(Clone, Debug, Default)]
 pub struct BaseConfig<F: PrimeField + TensorType + PartialOrd> {
-    /// the inputs to the accumulated operations.
-    pub inputs: Vec<VarTensor>,
-    /// the VarTensor reserved for lookup operations (could be an element of inputs)
-    /// Note that you should be careful to ensure that the lookup_input is not simultaneously assigned to by other non-lookup operations eg. in the case of composite ops.
-    pub lookup_input: VarTensor,
-    /// the (currently singular) output of the accumulated operations.
-    pub output: VarTensor,
-    /// the VarTensor reserved for lookup operations (could be an element of inputs or the same as output)
-    /// Note that you should be careful to ensure that the lookup_output is not simultaneously assigned to by other non-lookup operations eg. in the case of composite ops.
-    pub lookup_output: VarTensor,
-    ///
-    pub lookup_index: VarTensor,
-    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure [BaseOp].
-    pub selectors: BTreeMap<(BaseOp, usize, usize), Selector>,
-    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many lookup ops.
-    pub lookup_selectors: BTreeMap<(LookupOp, usize, usize), Selector>,
-    ///
-    pub tables: BTreeMap<LookupOp, Table<F>>,
-    ///
-    pub range_checks: BTreeMap<Range, RangeCheck<F>>,
-    /// [Selector]s generated when configuring the layer. We use a [BTreeMap] as we expect to configure many lookup ops.
-    pub range_check_selectors: BTreeMap<(Range, usize, usize), Selector>,
+    /// Custom gates
+    pub custom_gates: CustomGates,
+    /// StaticLookups
+    pub static_lookups: StaticLookups<F>,
+    /// [Selector]s for the dynamic lookup tables
+    pub dynamic_lookups: DynamicLookups,
+    /// [Selector]s for the range checks
+    pub range_checks: RangeChecks<F>,
+    /// [Selector]s for the shuffles
+    pub shuffles: Shuffles,
    /// Activate sanity checks
    pub check_mode: CheckMode,
    _marker: PhantomData<F>,
@@ -221,19 +348,12 @@ pub struct BaseConfig<F: PrimeField + TensorType + PartialOrd> {
 impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
    /// Returns a new [BaseConfig] with no inputs, no selectors, and no tables.
    pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
-        let dummy_var = VarTensor::dummy(col_size, num_inner_cols);
-
        Self {
-            inputs: vec![dummy_var.clone(), dummy_var.clone()],
-            lookup_input: dummy_var.clone(),
-            output: dummy_var.clone(),
-            lookup_output: dummy_var.clone(),
-            lookup_index: dummy_var,
-            selectors: BTreeMap::new(),
-            lookup_selectors: BTreeMap::new(),
-            range_check_selectors: BTreeMap::new(),
-            tables: BTreeMap::new(),
-            range_checks: BTreeMap::new(),
+            custom_gates: CustomGates::dummy(col_size, num_inner_cols),
+            static_lookups: StaticLookups::dummy(col_size, num_inner_cols),
+            dynamic_lookups: DynamicLookups::dummy(col_size, num_inner_cols),
+            shuffles: Shuffles::dummy(col_size, num_inner_cols),
+            range_checks: RangeChecks::dummy(col_size, num_inner_cols),
            check_mode: CheckMode::SAFE,
            _marker: PhantomData,
        }
@@ -266,10 +386,7 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
            for j in 0..output.num_inner_cols() {
                nonaccum_selectors.insert((BaseOp::Add, i, j), meta.selector());
                nonaccum_selectors.insert((BaseOp::Sub, i, j), meta.selector());
-                nonaccum_selectors.insert((BaseOp::Neg, i, j), meta.selector());
                nonaccum_selectors.insert((BaseOp::Mult, i, j), meta.selector());
-                nonaccum_selectors.insert((BaseOp::IsZero, i, j), meta.selector());
-                nonaccum_selectors.insert((BaseOp::Identity, i, j), meta.selector());
                nonaccum_selectors.insert((BaseOp::IsBoolean, i, j), meta.selector());
            }
        }
@@ -314,12 +431,6 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {

                        vec![(output.clone()) * (output.clone() - Expression::Constant(F::from(1)))]
                    }
-                    BaseOp::IsZero => {
-                        let expected_output: Tensor<Expression<F>> = output
-                            .query_rng(meta, *block_idx, *inner_col_idx, 0, 1)
-                            .expect("non accum: output query failed");
-                        vec![expected_output[base_op.constraint_idx()].clone()]
-                    }
                    _ => {
                        let expected_output: Tensor<Expression<F>> = output
                            .query_rng(meta, *block_idx, *inner_col_idx, rotation_offset, rng)
@@ -373,16 +484,15 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
            .collect();

        Self {
-            selectors,
-            lookup_selectors: BTreeMap::new(),
-            range_check_selectors: BTreeMap::new(),
-            inputs: inputs.to_vec(),
-            lookup_input: VarTensor::Empty,
-            lookup_output: VarTensor::Empty,
-            lookup_index: VarTensor::Empty,
-            tables: BTreeMap::new(),
-            range_checks: BTreeMap::new(),
-            output: output.clone(),
+            custom_gates: CustomGates {
+                inputs: inputs.to_vec(),
+                output: output.clone(),
+                selectors,
+            },
+            static_lookups: StaticLookups::default(),
+            dynamic_lookups: DynamicLookups::default(),
+            shuffles: Shuffles::default(),
+            range_checks: RangeChecks::default(),
            check_mode,
            _marker: PhantomData,
        }
@@ -403,8 +513,6 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
    where
        F: Field,
    {
-        let mut selectors = BTreeMap::new();
-
        if !index.is_advice() {
            return Err("wrong input type for lookup index".into());
        }
@@ -417,9 +525,9 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {

        // we borrow mutably twice so we need to do this dance

-        let table = if !self.tables.contains_key(nl) {
+        let table = if !self.static_lookups.tables.contains_key(nl) {
            // as all tables have the same input we see if there's another table who's input we can reuse
-            let table = if let Some(table) = self.tables.values().next() {
+            let table = if let Some(table) = self.static_lookups.tables.values().next() {
                Table::<F>::configure(
                    cs,
                    lookup_range,
@@ -430,7 +538,7 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
            } else {
                Table::<F>::configure(cs, lookup_range, logrows, nl, None)
            };
-            self.tables.insert(nl.clone(), table.clone());
+            self.static_lookups.tables.insert(nl.clone(), table.clone());
            table
        } else {
            return Ok(());
@@ -514,90 +622,292 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
                        res
                    });
                }
-                selectors.insert((nl.clone(), x, y), multi_col_selector);
+                self.static_lookups
+                    .selectors
+                    .insert((nl.clone(), x, y), multi_col_selector);
            }
        }
-        self.lookup_selectors.extend(selectors);
        // if we haven't previously initialized the input/output, do so now
-        if let VarTensor::Empty = self.lookup_input {
+        if let VarTensor::Empty = self.static_lookups.input {
            debug!("assigning lookup input");
-            self.lookup_input = input.clone();
+            self.static_lookups.input = input.clone();
        }
-        if let VarTensor::Empty = self.lookup_output {
+        if let VarTensor::Empty = self.static_lookups.output {
            debug!("assigning lookup output");
-            self.lookup_output = output.clone();
+            self.static_lookups.output = output.clone();
        }
-        if let VarTensor::Empty = self.lookup_index {
+        if let VarTensor::Empty = self.static_lookups.index {
            debug!("assigning lookup index");
-            self.lookup_index = index.clone();
+            self.static_lookups.index = index.clone();
        }
        Ok(())
    }

+    /// Configures and creates lookup selectors
+    #[allow(clippy::too_many_arguments)]
+    pub fn configure_dynamic_lookup(
+        &mut self,
+        cs: &mut ConstraintSystem<F>,
+        lookups: &[VarTensor; 3],
+        tables: &[VarTensor; 3],
+    ) -> Result<(), Box<dyn Error>>
+    where
+        F: Field,
+    {
+        for l in lookups.iter() {
+            if !l.is_advice() {
+                return Err("wrong input type for dynamic lookup".into());
+            }
+        }
+
+        for t in tables.iter() {
+            if !t.is_advice() || t.num_blocks() > 1 || t.num_inner_cols() > 1 {
+                return Err("wrong table type for dynamic lookup".into());
+            }
+        }
+
+        let one = Expression::Constant(F::ONE);
+
+        let s_ltable = cs.complex_selector();
+
+        for x in 0..lookups[0].num_blocks() {
+            for y in 0..lookups[0].num_inner_cols() {
+                let s_lookup = cs.complex_selector();
+
+                cs.lookup_any("lookup", |cs| {
+                    let s_lookupq = cs.query_selector(s_lookup);
+                    let mut expression = vec![];
+                    let s_ltableq = cs.query_selector(s_ltable);
+                    let mut lookup_queries = vec![one.clone()];
+
+                    for lookup in lookups {
+                        lookup_queries.push(match lookup {
+                            VarTensor::Advice { inner: advices, .. } => {
+                                cs.query_advice(advices[x][y], Rotation(0))
+                            }
+                            _ => unreachable!(),
+                        });
+                    }
+
+                    let mut table_queries = vec![one.clone()];
+                    for table in tables {
+                        table_queries.push(match table {
+                            VarTensor::Advice { inner: advices, .. } => {
+                                cs.query_advice(advices[0][0], Rotation(0))
+                            }
+                            _ => unreachable!(),
+                        });
+                    }
+
+                    let lhs = lookup_queries.into_iter().map(|c| c * s_lookupq.clone());
+                    let rhs = table_queries.into_iter().map(|c| c * s_ltableq.clone());
+                    expression.extend(lhs.zip(rhs));
+
+                    expression
+                });
+                self.dynamic_lookups
+                    .lookup_selectors
+                    .entry((x, y))
+                    .or_insert(s_lookup);
+            }
+        }
+        self.dynamic_lookups.table_selectors.push(s_ltable);
+
+        // if we haven't previously initialized the input/output, do so now
+        if self.dynamic_lookups.tables.is_empty() {
+            debug!("assigning dynamic lookup table");
+            self.dynamic_lookups.tables = tables.to_vec();
+        }
+        if self.dynamic_lookups.inputs.is_empty() {
+            debug!("assigning dynamic lookup input");
+            self.dynamic_lookups.inputs = lookups.to_vec();
+        }
+
+        Ok(())
+    }
+
+    /// Configures and creates lookup selectors
+    #[allow(clippy::too_many_arguments)]
+    pub fn configure_shuffles(
+        &mut self,
+        cs: &mut ConstraintSystem<F>,
+        inputs: &[VarTensor; 2],
+        references: &[VarTensor; 2],
+    ) -> Result<(), Box<dyn Error>>
+    where
+        F: Field,
+    {
+        for l in inputs.iter() {
+            if !l.is_advice() {
+                return Err("wrong input type for dynamic lookup".into());
+            }
+        }
+
+        for t in references.iter() {
+            if !t.is_advice() || t.num_blocks() > 1 || t.num_inner_cols() > 1 {
+                return Err("wrong table type for dynamic lookup".into());
+            }
+        }
+
+        let one = Expression::Constant(F::ONE);
+
+        let s_reference = cs.complex_selector();
+
+        for x in 0..inputs[0].num_blocks() {
+            for y in 0..inputs[0].num_inner_cols() {
+                let s_input = cs.complex_selector();
+
+                cs.lookup_any("lookup", |cs| {
+                    let s_inputq = cs.query_selector(s_input);
+                    let mut expression = vec![];
+                    let s_referenceq = cs.query_selector(s_reference);
+                    let mut input_queries = vec![one.clone()];
+
+                    for input in inputs {
+                        input_queries.push(match input {
+                            VarTensor::Advice { inner: advices, .. } => {
+                                cs.query_advice(advices[x][y], Rotation(0))
+                            }
+                            _ => unreachable!(),
+                        });
+                    }
+
+                    let mut ref_queries = vec![one.clone()];
+                    for reference in references {
+                        ref_queries.push(match reference {
+                            VarTensor::Advice { inner: advices, .. } => {
+                                cs.query_advice(advices[0][0], Rotation(0))
+                            }
+                            _ => unreachable!(),
+                        });
+                    }
+
+                    let lhs = input_queries.into_iter().map(|c| c * s_inputq.clone());
+                    let rhs = ref_queries.into_iter().map(|c| c * s_referenceq.clone());
+                    expression.extend(lhs.zip(rhs));
+
+                    expression
+                });
+                self.shuffles
+                    .input_selectors
+                    .entry((x, y))
+                    .or_insert(s_input);
+            }
+        }
+        self.shuffles.reference_selectors.push(s_reference);
+
+        // if we haven't previously initialized the input/output, do so now
+        if self.shuffles.references.is_empty() {
+            debug!("assigning shuffles reference");
+            self.shuffles.references = references.to_vec();
+        }
+        if self.shuffles.inputs.is_empty() {
+            debug!("assigning shuffles input");
+            self.shuffles.inputs = inputs.to_vec();
+        }
+
+        Ok(())
+    }
+
    /// Configures and creates lookup selectors
    #[allow(clippy::too_many_arguments)]
    pub fn configure_range_check(
        &mut self,
        cs: &mut ConstraintSystem<F>,
        input: &VarTensor,
+        index: &VarTensor,
        range: Range,
+        logrows: usize,
    ) -> Result<(), Box<dyn Error>>
    where
        F: Field,
    {
-        let mut selectors = BTreeMap::new();
-
        if !input.is_advice() {
            return Err("wrong input type for lookup input".into());
        }

        // we borrow mutably twice so we need to do this dance

-        let range_check =
-            if let std::collections::btree_map::Entry::Vacant(e) = self.range_checks.entry(range) {
-                // as all tables have the same input we see if there's another table who's input we can reuse
-                let range_check = RangeCheck::<F>::configure(cs, range);
-                e.insert(range_check.clone());
-                range_check
-            } else {
-                return Ok(());
-            };
+        let range_check = if let std::collections::btree_map::Entry::Vacant(e) =
+            self.range_checks.ranges.entry(range)
+        {
+            // as all tables have the same input we see if there's another table who's input we can reuse
+            let range_check = RangeCheck::<F>::configure(cs, range, logrows);
+            e.insert(range_check.clone());
+            range_check
+        } else {
+            return Ok(());
+        };

        for x in 0..input.num_blocks() {
            for y in 0..input.num_inner_cols() {
-                let single_col_sel = cs.complex_selector();
+                let len = range_check.selector_constructor.degree;
+                let multi_col_selector = cs.complex_selector();

-                cs.lookup("", |cs| {
-                    let mut res = vec![];
-                    let sel = cs.query_selector(single_col_sel);
+                for (col_idx, input_col) in range_check.inputs.iter().enumerate() {
+                    cs.lookup("", |cs| {
+                        let mut res = vec![];
+                        let sel = cs.query_selector(multi_col_selector);

-                    let input_query = match &input {
-                        VarTensor::Advice { inner: advices, .. } => {
-                            cs.query_advice(advices[x][y], Rotation(0))
-                        }
-                        _ => unreachable!(),
-                    };
+                        let synthetic_sel = match len {
+                            1 => Expression::Constant(F::from(1)),
+                            _ => match index {
+                                VarTensor::Advice { inner: advices, .. } => {
+                                    cs.query_advice(advices[x][y], Rotation(0))
+                                }
+                                _ => unreachable!(),
+                            },
+                        };

-                    let default_x = range_check.get_first_element();
+                        let input_query = match &input {
+                            VarTensor::Advice { inner: advices, .. } => {
+                                cs.query_advice(advices[x][y], Rotation(0))
+                            }
+                            _ => unreachable!(),
+                        };

-                    let not_sel = Expression::Constant(F::ONE) - sel.clone();
+                        let default_x = range_check.get_first_element(col_idx);

-                    res.extend([(
-                        sel.clone() * input_query.clone()
-                            + not_sel.clone() * Expression::Constant(default_x),
-                        range_check.input,
-                    )]);
+                        let col_expr = sel.clone()
+                            * range_check
+                                .selector_constructor
+                                .get_expr_at_idx(col_idx, synthetic_sel);

-                    res
-                });
-                selectors.insert((range, x, y), single_col_sel);
+                        let multiplier = range_check
+                            .selector_constructor
+                            .get_selector_val_at_idx(col_idx);
+
+                        let not_expr = Expression::Constant(multiplier) - col_expr.clone();
+
+                        res.extend([(
+                            col_expr.clone() * input_query.clone()
+                                + not_expr.clone() * Expression::Constant(default_x),
+                            *input_col,
+                        )]);
+
+                        log::trace!("---------------- col {:?} ------------------", col_idx,);
+                        log::trace!("expr: {:?}", col_expr,);
+                        log::trace!("multiplier: {:?}", multiplier);
+                        log::trace!("not_expr: {:?}", not_expr);
+                        log::trace!("default x: {:?}", default_x);
+
+                        res
+                    });
+                }
+                self.range_checks
+                    .selectors
+                    .insert((range, x, y), multi_col_selector);
            }
        }
-        self.range_check_selectors.extend(selectors);
        // if we haven't previously initialized the input/output, do so now
-        if let VarTensor::Empty = self.lookup_input {
-            debug!("assigning lookup input");
-            self.lookup_input = input.clone();
+        if let VarTensor::Empty = self.range_checks.input {
+            debug!("assigning range check input");
+            self.range_checks.input = input.clone();
+        }
+
+        if let VarTensor::Empty = self.range_checks.index {
+            debug!("assigning range check index");
+            self.range_checks.index = index.clone();
        }

        Ok(())
@@ -605,7 +915,7 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {

    /// layout_tables must be called before layout.
    pub fn layout_tables(&mut self, layouter: &mut impl Layouter<F>) -> Result<(), Box<dyn Error>> {
-        for (i, table) in self.tables.values_mut().enumerate() {
+        for (i, table) in self.static_lookups.tables.values_mut().enumerate() {
            if !table.is_assigned {
                debug!(
                    "laying out table for {}",
@@ -626,7 +936,7 @@ impl<F: PrimeField + TensorType + PartialOrd> BaseConfig<F> {
        &mut self,
        layouter: &mut impl Layouter<F>,
    ) -> Result<(), Box<dyn Error>> {
-        for range_check in self.range_checks.values_mut() {
+        for range_check in self.range_checks.ranges.values_mut() {
            if !range_check.is_assigned {
                debug!("laying out range check for {:?}", range_check.range);
                range_check.layout(layouter)?;
--- a/src/circuit/ops/hybrid.rs
+++ b/src/circuit/ops/hybrid.rs
@@ -277,7 +277,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for HybridOp {
                ..
            } => {
                if denom.0.fract() == 0.0 && *use_range_check_for_int {
-                    layouts::div(
+                    layouts::loop_div(
                        config,
                        region,
                        values[..].try_into()?,
--- a/src/circuit/ops/layouts.rs
+++ b/src/circuit/ops/layouts.rs
--- a/src/circuit/ops/lookup.rs
+++ b/src/circuit/ops/lookup.rs
@@ -123,6 +123,9 @@ pub enum LookupOp {
        scale: utils::F32,
        a: utils::F32,
    },
+    HardSwish {
+        scale: utils::F32,
+    },
 }

 impl LookupOp {
@@ -223,6 +226,9 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for LookupOp {
            LookupOp::ATan { scale } => Ok(tensor::ops::nonlinearities::atan(&x, scale.into())),
            LookupOp::ATanh { scale } => Ok(tensor::ops::nonlinearities::atanh(&x, scale.into())),
            LookupOp::Tanh { scale } => Ok(tensor::ops::nonlinearities::tanh(&x, scale.into())),
+            LookupOp::HardSwish { scale } => {
+                Ok(tensor::ops::nonlinearities::hardswish(&x, scale.into()))
+            }
        }?;

        let output = res.map(|x| i128_to_felt(x));
@@ -276,6 +282,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Op<F> for LookupOp {
            LookupOp::ASin { scale } => format!("ASIN(scale={})", scale),
            LookupOp::Sinh { scale } => format!("SINH(scale={})", scale),
            LookupOp::ASinh { scale } => format!("ASINH(scale={})", scale),
+            LookupOp::HardSwish { scale } => format!("HARDSWISH(scale={})", scale),
        }
    }

--- a/src/circuit/ops/poly.rs
+++ b/src/circuit/ops/poly.rs
@@ -14,10 +14,17 @@ pub enum PolyOp {
        dim: usize,
        constant_idx: Option<Tensor<usize>>,
    },
+    GatherND {
+        batch_dims: usize,
+        indices: Option<Tensor<usize>>,
+    },
    ScatterElements {
        dim: usize,
        constant_idx: Option<Tensor<usize>>,
    },
+    ScatterND {
+        constant_idx: Option<Tensor<usize>>,
+    },
    MultiBroadcastTo {
        shape: Vec<usize>,
    },
@@ -60,8 +67,6 @@ pub enum PolyOp {
        len_prod: usize,
    },
    Pow(u32),
-    Pack(u32, u32),
-    GlobalSumPool,
    Concat {
        axis: usize,
    },
@@ -78,6 +83,10 @@ pub enum PolyOp {
    And,
    Or,
    Xor,
+    Trilu {
+        upper: bool,
+        k: i32,
+    },
 }

 impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<'de>> Op<F>
@@ -91,7 +100,9 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
    fn as_string(&self) -> String {
        match &self {
            PolyOp::GatherElements { dim, .. } => format!("GATHERELEMENTS (dim={})", dim),
+            PolyOp::GatherND { batch_dims, .. } => format!("GATHERND (batch_dims={})", batch_dims),
            PolyOp::ScatterElements { dim, .. } => format!("SCATTERELEMENTS (dim={})", dim),
+            PolyOp::ScatterND { .. } => "SCATTERND".into(),
            PolyOp::MultiBroadcastTo { shape } => format!("MULTIBROADCASTTO (shape={:?})", shape),
            PolyOp::MoveAxis { .. } => "MOVEAXIS".into(),
            PolyOp::Downsample { .. } => "DOWNSAMPLE".into(),
@@ -107,11 +118,9 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
            PolyOp::Add => "ADD".into(),
            PolyOp::Mult => "MULT".into(),
            PolyOp::Sub => "SUB".into(),
-            PolyOp::Sum { .. } => "SUM".into(),
+            PolyOp::Sum { axes } => format!("SUM (axes={:?})", axes),
            PolyOp::Prod { .. } => "PROD".into(),
            PolyOp::Pow(_) => "POW".into(),
-            PolyOp::Pack(_, _) => "PACK".into(),
-            PolyOp::GlobalSumPool => "GLOBALSUMPOOL".into(),
            PolyOp::Conv { .. } => "CONV".into(),
            PolyOp::DeConv { .. } => "DECONV".into(),
            PolyOp::Concat { axis } => format!("CONCAT (axis={})", axis),
@@ -123,6 +132,7 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
            PolyOp::And => "AND".into(),
            PolyOp::Or => "OR".into(),
            PolyOp::Xor => "XOR".into(),
+            PolyOp::Trilu { upper, k } => format!("TRILU (upper={}, k={})", upper, k),
        }
    }

@@ -181,13 +191,6 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
                output_padding,
                stride,
            } => tensor::ops::deconv(&inputs, *padding, *output_padding, *stride),
-            PolyOp::Pack(base, scale) => {
-                if 1 != inputs.len() {
-                    return Err(TensorError::DimMismatch("pack inputs".to_string()));
-                }
-
-                tensor::ops::pack(&inputs[0], F::from(*base as u64), *scale)
-            }
            PolyOp::Pow(u) => {
                if 1 != inputs.len() {
                    return Err(TensorError::DimMismatch("pow inputs".to_string()));
@@ -206,7 +209,6 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
                }
                tensor::ops::prod_axes(&inputs[0], axes)
            }
-            PolyOp::GlobalSumPool => unreachable!(),
            PolyOp::Concat { axis } => {
                tensor::ops::concat(&inputs.iter().collect::<Vec<_>>(), *axis)
            }
@@ -225,6 +227,18 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
                };
                tensor::ops::gather_elements(&x, &y, *dim)
            }
+            PolyOp::GatherND {
+                indices,
+                batch_dims,
+            } => {
+                let x = inputs[0].clone();
+                let y = if let Some(idx) = indices {
+                    idx.clone()
+                } else {
+                    inputs[1].clone().map(|x| felt_to_i128(x) as usize)
+                };
+                tensor::ops::gather_nd(&x, &y, *batch_dims)
+            }
            PolyOp::ScatterElements { dim, constant_idx } => {
                let x = inputs[0].clone();

@@ -241,6 +255,22 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
                };
                tensor::ops::scatter(&x, &idx, &src, *dim)
            }
+
+            PolyOp::ScatterND { constant_idx } => {
+                let x = inputs[0].clone();
+                let idx = if let Some(idx) = constant_idx {
+                    idx.clone()
+                } else {
+                    inputs[1].clone().map(|x| felt_to_i128(x) as usize)
+                };
+                let src = if constant_idx.is_some() {
+                    inputs[1].clone()
+                } else {
+                    inputs[2].clone()
+                };
+                tensor::ops::scatter_nd(&x, &idx, &src)
+            }
+            PolyOp::Trilu { upper, k } => tensor::ops::trilu(&inputs[0], *k, *upper),
        }?;

        Ok(ForwardResult { output: res })
@@ -288,7 +318,17 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
                if let Some(idx) = constant_idx {
                    tensor::ops::gather_elements(values[0].get_inner_tensor()?, idx, *dim)?.into()
                } else {
-                    layouts::gather_elements(config, region, values[..].try_into()?, *dim)?
+                    layouts::gather_elements(config, region, values[..].try_into()?, *dim)?.0
+                }
+            }
+            PolyOp::GatherND {
+                batch_dims,
+                indices,
+            } => {
+                if let Some(idx) = indices {
+                    tensor::ops::gather_nd(values[0].get_inner_tensor()?, idx, *batch_dims)?.into()
+                } else {
+                    layouts::gather_nd(config, region, values[..].try_into()?, *batch_dims)?.0
                }
            }
            PolyOp::ScatterElements { dim, constant_idx } => {
@@ -304,6 +344,18 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
                    layouts::scatter_elements(config, region, values[..].try_into()?, *dim)?
                }
            }
+            PolyOp::ScatterND { constant_idx } => {
+                if let Some(idx) = constant_idx {
+                    tensor::ops::scatter_nd(
+                        values[0].get_inner_tensor()?,
+                        idx,
+                        values[1].get_inner_tensor()?,
+                    )?
+                    .into()
+                } else {
+                    layouts::scatter_nd(config, region, values[..].try_into()?)?
+                }
+            }
            PolyOp::DeConv {
                padding,
                output_padding,
@@ -334,14 +386,13 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
                input
            }
            PolyOp::Pow(exp) => layouts::pow(config, region, values[..].try_into()?, *exp)?,
-            PolyOp::Pack(base, scale) => {
-                layouts::pack(config, region, values[..].try_into()?, *base, *scale)?
-            }
-            PolyOp::GlobalSumPool => unreachable!(),
            PolyOp::Concat { axis } => layouts::concat(values[..].try_into()?, axis)?,
            PolyOp::Slice { axis, start, end } => {
                layouts::slice(config, region, values[..].try_into()?, axis, start, end)?
            }
+            PolyOp::Trilu { upper, k } => {
+                layouts::trilu(config, region, values[..].try_into()?, k, upper)?
+            }
        }))
    }

@@ -405,7 +456,9 @@ impl<F: PrimeField + TensorType + PartialOrd + Serialize + for<'de> Deserialize<
            vec![1, 2]
        } else if matches!(self, PolyOp::Concat { .. }) {
            (0..100).collect()
-        } else if matches!(self, PolyOp::ScatterElements { .. }) {
+        } else if matches!(self, PolyOp::ScatterElements { .. })
+            | matches!(self, PolyOp::ScatterND { .. })
+        {
            vec![0, 2]
        } else {
            vec![]
--- a/src/circuit/ops/region.rs
+++ b/src/circuit/ops/region.rs
@@ -20,6 +20,66 @@ use portable_atomic::AtomicI128 as AtomicInt;

 use super::lookup::LookupOp;

+/// Dynamic lookup index
+#[derive(Clone, Debug, Default)]
+pub struct DynamicLookupIndex {
+    index: usize,
+    col_coord: usize,
+}
+
+impl DynamicLookupIndex {
+    /// Create a new dynamic lookup index
+    pub fn new(index: usize, col_coord: usize) -> DynamicLookupIndex {
+        DynamicLookupIndex { index, col_coord }
+    }
+
+    /// Get the lookup index
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    /// Get the column coord
+    pub fn col_coord(&self) -> usize {
+        self.col_coord
+    }
+
+    /// update with another dynamic lookup index
+    pub fn update(&mut self, other: &DynamicLookupIndex) {
+        self.index += other.index;
+        self.col_coord += other.col_coord;
+    }
+}
+
+/// Dynamic lookup index
+#[derive(Clone, Debug, Default)]
+pub struct ShuffleIndex {
+    index: usize,
+    col_coord: usize,
+}
+
+impl ShuffleIndex {
+    /// Create a new dynamic lookup index
+    pub fn new(index: usize, col_coord: usize) -> ShuffleIndex {
+        ShuffleIndex { index, col_coord }
+    }
+
+    /// Get the lookup index
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    /// Get the column coord
+    pub fn col_coord(&self) -> usize {
+        self.col_coord
+    }
+
+    /// update with another shuffle index
+    pub fn update(&mut self, other: &ShuffleIndex) {
+        self.index += other.index;
+        self.col_coord += other.col_coord;
+    }
+}
+
 /// Region error
 #[derive(Debug, thiserror::Error)]
 pub enum RegionError {
@@ -66,10 +126,14 @@ pub struct RegionCtx<'a, F: PrimeField + TensorType + PartialOrd> {
    linear_coord: usize,
    num_inner_cols: usize,
    total_constants: usize,
+    dynamic_lookup_index: DynamicLookupIndex,
+    shuffle_index: ShuffleIndex,
    used_lookups: HashSet<LookupOp>,
    used_range_checks: HashSet<Range>,
    max_lookup_inputs: i128,
    min_lookup_inputs: i128,
+    max_range_size: i128,
+    throw_range_check_error: bool,
 }

 impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
@@ -78,6 +142,31 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        self.total_constants += n;
    }

+    ///
+    pub fn increment_dynamic_lookup_index(&mut self, n: usize) {
+        self.dynamic_lookup_index.index += n;
+    }
+
+    ///
+    pub fn increment_dynamic_lookup_col_coord(&mut self, n: usize) {
+        self.dynamic_lookup_index.col_coord += n;
+    }
+
+    ///
+    pub fn increment_shuffle_index(&mut self, n: usize) {
+        self.shuffle_index.index += n;
+    }
+
+    ///
+    pub fn increment_shuffle_col_coord(&mut self, n: usize) {
+        self.shuffle_index.col_coord += n;
+    }
+
+    ///
+    pub fn throw_range_check_error(&self) -> bool {
+        self.throw_range_check_error
+    }
+
    /// Create a new region context
    pub fn new(region: Region<'a, F>, row: usize, num_inner_cols: usize) -> RegionCtx<'a, F> {
        let region = Some(RefCell::new(region));
@@ -89,10 +178,14 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            row,
            linear_coord,
            total_constants: 0,
+            dynamic_lookup_index: DynamicLookupIndex::default(),
+            shuffle_index: ShuffleIndex::default(),
            used_lookups: HashSet::new(),
            used_range_checks: HashSet::new(),
            max_lookup_inputs: 0,
            min_lookup_inputs: 0,
+            max_range_size: 0,
+            throw_range_check_error: false,
        }
    }
    /// Create a new region context from a wrapped region
@@ -100,6 +193,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        region: Option<RefCell<Region<'a, F>>>,
        row: usize,
        num_inner_cols: usize,
+        dynamic_lookup_index: DynamicLookupIndex,
+        shuffle_index: ShuffleIndex,
    ) -> RegionCtx<'a, F> {
        let linear_coord = row * num_inner_cols;
        RegionCtx {
@@ -108,15 +203,23 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            linear_coord,
            row,
            total_constants: 0,
+            dynamic_lookup_index,
+            shuffle_index,
            used_lookups: HashSet::new(),
            used_range_checks: HashSet::new(),
            max_lookup_inputs: 0,
            min_lookup_inputs: 0,
+            max_range_size: 0,
+            throw_range_check_error: false,
        }
    }

    /// Create a new region context
-    pub fn new_dummy(row: usize, num_inner_cols: usize) -> RegionCtx<'a, F> {
+    pub fn new_dummy(
+        row: usize,
+        num_inner_cols: usize,
+        throw_range_check_error: bool,
+    ) -> RegionCtx<'a, F> {
        let region = None;
        let linear_coord = row * num_inner_cols;

@@ -126,10 +229,14 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            linear_coord,
            row,
            total_constants: 0,
+            dynamic_lookup_index: DynamicLookupIndex::default(),
+            shuffle_index: ShuffleIndex::default(),
            used_lookups: HashSet::new(),
            used_range_checks: HashSet::new(),
            max_lookup_inputs: 0,
            min_lookup_inputs: 0,
+            max_range_size: 0,
+            throw_range_check_error,
        }
    }

@@ -139,8 +246,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        linear_coord: usize,
        total_constants: usize,
        num_inner_cols: usize,
-        used_lookups: HashSet<LookupOp>,
-        used_range_checks: HashSet<Range>,
+        throw_range_check_error: bool,
    ) -> RegionCtx<'a, F> {
        let region = None;
        RegionCtx {
@@ -149,10 +255,14 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            linear_coord,
            row,
            total_constants,
-            used_lookups,
-            used_range_checks,
+            dynamic_lookup_index: DynamicLookupIndex::default(),
+            shuffle_index: ShuffleIndex::default(),
+            used_lookups: HashSet::new(),
+            used_range_checks: HashSet::new(),
            max_lookup_inputs: 0,
            min_lookup_inputs: 0,
+            max_range_size: 0,
+            throw_range_check_error,
        }
    }

@@ -207,6 +317,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        let min_lookup_inputs = AtomicInt::new(self.min_lookup_inputs());
        let lookups = Arc::new(Mutex::new(self.used_lookups.clone()));
        let range_checks = Arc::new(Mutex::new(self.used_range_checks.clone()));
+        let dynamic_lookup_index = Arc::new(Mutex::new(self.dynamic_lookup_index.clone()));
+        let shuffle_index = Arc::new(Mutex::new(self.shuffle_index.clone()));

        *output = output
            .par_enum_map(|idx, _| {
@@ -222,8 +334,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
                    starting_linear_coord,
                    starting_constants,
                    self.num_inner_cols,
-                    HashSet::new(),
-                    HashSet::new(),
+                    self.throw_range_check_error,
                );
                let res = inner_loop_function(idx, &mut local_reg);
                // we update the offset and constants
@@ -242,14 +353,19 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
                // update the lookups
                let mut lookups = lookups.lock().unwrap();
                lookups.extend(local_reg.used_lookups());
+                // update the range checks
                let mut range_checks = range_checks.lock().unwrap();
                range_checks.extend(local_reg.used_range_checks());
+                // update the dynamic lookup index
+                let mut dynamic_lookup_index = dynamic_lookup_index.lock().unwrap();
+                dynamic_lookup_index.update(&local_reg.dynamic_lookup_index);
+                // update the shuffle index
+                let mut shuffle_index = shuffle_index.lock().unwrap();
+                shuffle_index.update(&local_reg.shuffle_index);
+
                res
            })
-            .map_err(|e| {
-                log::error!("dummy_loop: {:?}", e);
-                Error::Synthesis
-            })?;
+            .map_err(|e| RegionError::from(format!("dummy_loop: {:?}", e)))?;
        self.total_constants = constants.into_inner();
        self.linear_coord = linear_coord.into_inner();
        #[allow(trivial_numeric_casts)]
@@ -272,6 +388,28 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            .map_err(|e| {
                RegionError::from(format!("dummy_loop: failed to get range checks: {:?}", e))
            })?;
+        self.dynamic_lookup_index = Arc::try_unwrap(dynamic_lookup_index)
+            .map_err(|e| {
+                RegionError::from(format!(
+                    "dummy_loop: failed to get dynamic lookup index: {:?}",
+                    e
+                ))
+            })?
+            .into_inner()
+            .map_err(|e| {
+                RegionError::from(format!(
+                    "dummy_loop: failed to get dynamic lookup index: {:?}",
+                    e
+                ))
+            })?;
+        self.shuffle_index = Arc::try_unwrap(shuffle_index)
+            .map_err(|e| {
+                RegionError::from(format!("dummy_loop: failed to get shuffle index: {:?}", e))
+            })?
+            .into_inner()
+            .map_err(|e| {
+                RegionError::from(format!("dummy_loop: failed to get shuffle index: {:?}", e))
+            })?;

        Ok(())
    }
@@ -300,8 +438,9 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
            return Err("update_max_min_lookup_range: invalid range".into());
        }

-        self.max_lookup_inputs = self.max_lookup_inputs.max(range.1);
-        self.min_lookup_inputs = self.min_lookup_inputs.min(range.0);
+        let range_size = (range.1 - range.0).abs();
+
+        self.max_range_size = self.max_range_size.max(range_size);
        Ok(())
    }

@@ -341,6 +480,26 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        self.total_constants
    }

+    /// Get the dynamic lookup index
+    pub fn dynamic_lookup_index(&self) -> usize {
+        self.dynamic_lookup_index.index
+    }
+
+    /// Get the dynamic lookup column coordinate
+    pub fn dynamic_lookup_col_coord(&self) -> usize {
+        self.dynamic_lookup_index.col_coord
+    }
+
+    /// Get the shuffle index
+    pub fn shuffle_index(&self) -> usize {
+        self.shuffle_index.index
+    }
+
+    /// Get the shuffle column coordinate
+    pub fn shuffle_col_coord(&self) -> usize {
+        self.shuffle_index.col_coord
+    }
+
    /// get used lookups
    pub fn used_lookups(&self) -> HashSet<LookupOp> {
        self.used_lookups.clone()
@@ -361,6 +520,11 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        self.min_lookup_inputs
    }

+    /// max range check
+    pub fn max_range_size(&self) -> i128 {
+        self.max_range_size
+    }
+
    /// Assign a constant value
    pub fn assign_constant(&mut self, var: &VarTensor, value: F) -> Result<ValType<F>, Error> {
        self.total_constants += 1;
@@ -385,6 +549,38 @@ impl<'a, F: PrimeField + TensorType + PartialOrd> RegionCtx<'a, F> {
        }
    }

+    ///
+    pub fn combined_dynamic_shuffle_coord(&self) -> usize {
+        self.dynamic_lookup_col_coord() + self.shuffle_col_coord()
+    }
+
+    /// Assign a valtensor to a vartensor
+    pub fn assign_dynamic_lookup(
+        &mut self,
+        var: &VarTensor,
+        values: &ValTensor<F>,
+    ) -> Result<ValTensor<F>, Error> {
+        self.total_constants += values.num_constants();
+        if let Some(region) = &self.region {
+            var.assign(
+                &mut region.borrow_mut(),
+                self.combined_dynamic_shuffle_coord(),
+                values,
+            )
+        } else {
+            Ok(values.clone())
+        }
+    }
+
+    /// Assign a valtensor to a vartensor
+    pub fn assign_shuffle(
+        &mut self,
+        var: &VarTensor,
+        values: &ValTensor<F>,
+    ) -> Result<ValTensor<F>, Error> {
+        self.assign_dynamic_lookup(var, values)
+    }
+
    /// Assign a valtensor to a vartensor
    pub fn assign_with_omissions(
        &mut self,
--- a/src/circuit/table.rs
+++ b/src/circuit/table.rs
@@ -6,7 +6,7 @@ use halo2_proofs::{
    circuit::{Layouter, Value},
    plonk::{ConstraintSystem, Expression, TableColumn},
 };
-use log::warn;
+use log::{debug, warn};
 use maybe_rayon::prelude::{IntoParallelIterator, ParallelIterator};

 use crate::{
@@ -130,14 +130,12 @@ impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
    pub fn cal_bit_range(bits: usize, reserved_blinding_rows: usize) -> usize {
        2usize.pow(bits as u32) - reserved_blinding_rows
    }
+}

-    ///
-    pub fn num_cols_required(range: Range, col_size: usize) -> usize {
-        // double it to be safe
-        let range_len = range.1 - range.0;
-        // number of cols needed to store the range
-        (range_len / (col_size as i128)) as usize + 1
-    }
+///
+pub fn num_cols_required(range_len: i128, col_size: usize) -> usize {
+    // number of cols needed to store the range
+    (range_len / (col_size as i128)) as usize + 1
 }

 impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
@@ -152,7 +150,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
        let factors = cs.blinding_factors() + RESERVED_BLINDING_ROWS_PAD;
        let col_size = Self::cal_col_size(logrows, factors);
        // number of cols needed to store the range
-        let num_cols = Self::num_cols_required(range, col_size);
+        let num_cols = num_cols_required((range.1 - range.0).abs(), col_size);

        log::debug!("table range: {:?}", range);

@@ -167,7 +165,7 @@ impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
        let num_cols = table_inputs.len();

        if num_cols > 1 {
-            warn!("Using {} columns for non-linearity table.", num_cols);
+            debug!("Using {} columns for non-linearity table.", num_cols);
        }

        let table_outputs = table_inputs
@@ -265,7 +263,9 @@ impl<F: PrimeField + TensorType + PartialOrd> Table<F> {
 #[derive(Clone, Debug)]
 pub struct RangeCheck<F: PrimeField> {
    /// Input to table.
-    pub input: TableColumn,
+    pub inputs: Vec<TableColumn>,
+    /// col size
+    pub col_size: usize,
    /// selector cn
    pub selector_constructor: SelectorConstructor<F>,
    /// Flags if table has been previously assigned to.
@@ -277,8 +277,10 @@ pub struct RangeCheck<F: PrimeField> {

 impl<F: PrimeField + TensorType + PartialOrd> RangeCheck<F> {
    /// get first_element of column
-    pub fn get_first_element(&self) -> F {
-        i128_to_felt(self.range.0)
+    pub fn get_first_element(&self, chunk: usize) -> F {
+        let chunk = chunk as i128;
+        // we index from 1 to prevent soundness issues
+        i128_to_felt(chunk * (self.col_size as i128) + self.range.0)
    }

    ///
@@ -290,24 +292,58 @@ impl<F: PrimeField + TensorType + PartialOrd> RangeCheck<F> {
    pub fn cal_bit_range(bits: usize, reserved_blinding_rows: usize) -> usize {
        2usize.pow(bits as u32) - reserved_blinding_rows
    }
+
+    /// get column index given input
+    pub fn get_col_index(&self, input: F) -> F {
+        //    range is split up into chunks of size col_size, find the chunk that input is in
+        let chunk =
+            (crate::fieldutils::felt_to_i128(input) - self.range.0).abs() / (self.col_size as i128);
+
+        i128_to_felt(chunk)
+    }
 }

 impl<F: PrimeField + TensorType + PartialOrd> RangeCheck<F> {
    /// Configures the table.
-    pub fn configure(cs: &mut ConstraintSystem<F>, range: Range) -> RangeCheck<F> {
+    pub fn configure(cs: &mut ConstraintSystem<F>, range: Range, logrows: usize) -> RangeCheck<F> {
        log::debug!("range check range: {:?}", range);

-        let inputs = cs.lookup_table_column();
+        let factors = cs.blinding_factors() + RESERVED_BLINDING_ROWS_PAD;
+        let col_size = Self::cal_col_size(logrows, factors);
+        // number of cols needed to store the range
+        let num_cols = num_cols_required((range.1 - range.0).abs(), col_size);
+
+        let inputs = {
+            let mut cols = vec![];
+            for _ in 0..num_cols {
+                cols.push(cs.lookup_table_column());
+            }
+            cols
+        };
+
+        let num_cols = inputs.len();
+
+        if num_cols > 1 {
+            warn!("Using {} columns for range-check.", num_cols);
+        }

        RangeCheck {
-            input: inputs,
+            inputs,
+            col_size,
            is_assigned: false,
-            selector_constructor: SelectorConstructor::new(2),
+            selector_constructor: SelectorConstructor::new(num_cols),
            range,
            _marker: PhantomData,
        }
    }

+    /// Take a linear coordinate and output the (column, row) position in the storage block.
+    pub fn cartesian_coord(&self, linear_coord: usize) -> (usize, usize) {
+        let x = linear_coord / self.col_size;
+        let y = linear_coord % self.col_size;
+        (x, y)
+    }
+
    /// Assigns values to the constraints generated when calling `configure`.
    pub fn layout(&mut self, layouter: &mut impl Layouter<F>) -> Result<(), Box<dyn Error>> {
        if self.is_assigned {
@@ -318,28 +354,43 @@ impl<F: PrimeField + TensorType + PartialOrd> RangeCheck<F> {
        let largest = self.range.1;

        let inputs: Tensor<F> = Tensor::from(smallest..=largest).map(|x| i128_to_felt(x));
+        let chunked_inputs = inputs.chunks(self.col_size);

        self.is_assigned = true;

-        layouter.assign_table(
-            || "range check table",
-            |mut table| {
-                let _ = inputs
-                    .iter()
-                    .enumerate()
-                    .map(|(row_offset, input)| {
-                        table.assign_cell(
-                            || format!("rc_i_col row {}", row_offset),
-                            self.input,
-                            row_offset,
-                            || Value::known(*input),
-                        )?;
+        let col_multipliers: Vec<F> = (0..chunked_inputs.len())
+            .map(|x| self.selector_constructor.get_selector_val_at_idx(x))
+            .collect();
+
+        let _ = chunked_inputs
+            .enumerate()
+            .map(|(chunk_idx, inputs)| {
+                layouter.assign_table(
+                    || "range check table",
+                    |mut table| {
+                        let _ = inputs
+                            .iter()
+                            .enumerate()
+                            .map(|(mut row_offset, input)| {
+                                let col_multiplier = col_multipliers[chunk_idx];
+
+                                row_offset += chunk_idx * self.col_size;
+                                let (x, y) = self.cartesian_coord(row_offset);
+                                table.assign_cell(
+                                    || format!("rc_i_col row {}", row_offset),
+                                    self.inputs[x],
+                                    y,
+                                    || Value::known(*input * col_multiplier),
+                                )?;
+
+                                Ok(())
+                            })
+                            .collect::<Result<Vec<()>, halo2_proofs::plonk::Error>>()?;
                        Ok(())
-                    })
-                    .collect::<Result<Vec<()>, halo2_proofs::plonk::Error>>()?;
-                Ok(())
-            },
-        )?;
+                    },
+                )
+            })
+            .collect::<Result<Vec<()>, halo2_proofs::plonk::Error>>()?;
        Ok(())
    }
 }
--- a/src/circuit/tests.rs
+++ b/src/circuit/tests.rs
@@ -1,4 +1,3 @@
-use crate::circuit::ops::hybrid::HybridOp;
 use crate::circuit::ops::poly::PolyOp;
 use crate::circuit::*;
 use crate::tensor::{Tensor, TensorType, ValTensor, VarTensor};
@@ -246,7 +245,13 @@ mod matmul_col_overflow {
 #[cfg(test)]
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 mod matmul_col_ultra_overflow_double_col {
-    use halo2_proofs::poly::commitment::{Params, ParamsProver};
+
+    use halo2_proofs::poly::kzg::{
+        commitment::KZGCommitmentScheme,
+        multiopen::{ProverSHPLONK, VerifierSHPLONK},
+        strategy::SingleStrategy,
+    };
+    use snark_verifier::system::halo2::transcript::evm::EvmTranscript;

    use super::*;

@@ -325,48 +330,46 @@ mod matmul_col_ultra_overflow_double_col {

        let pk = crate::pfsys::create_keys::<
            halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme<halo2curves::bn256::Bn256>,
-            F,
            MatmulCircuit<F>,
        >(&circuit, &params, true)
        .unwrap();

-        let prover = crate::pfsys::create_proof_circuit_kzg(
+        let prover = crate::pfsys::create_proof_circuit::<
+            KZGCommitmentScheme<_>,
+            _,
+            ProverSHPLONK<_>,
+            VerifierSHPLONK<_>,
+            SingleStrategy<_>,
+            _,
+            EvmTranscript<_, _, _, _>,
+            EvmTranscript<_, _, _, _>,
+        >(
            circuit.clone(),
+            vec![],
            &params,
-            None,
            &pk,
-            crate::pfsys::TranscriptType::EVM,
-            halo2_proofs::poly::kzg::strategy::SingleStrategy::new(&params),
            // use safe mode to verify that the proof is correct
            CheckMode::SAFE,
+            crate::Commitments::KZG,
+            crate::pfsys::TranscriptType::EVM,
+            None,
            None,
        );

        assert!(prover.is_ok());
-
-        let proof = prover.unwrap();
-
-        let strategy =
-            halo2_proofs::poly::kzg::strategy::SingleStrategy::new(params.verifier_params());
-        let vk = pk.get_vk();
-        let result = crate::pfsys::verify_proof_circuit_kzg(
-            params.verifier_params(),
-            proof,
-            vk,
-            strategy,
-            params.n(),
-        );
-
-        assert!(result.is_ok());
-
-        println!("done.");
    }
 }

 #[cfg(test)]
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 mod matmul_col_ultra_overflow {
-    use halo2_proofs::poly::commitment::{Params, ParamsProver};
+
+    use halo2_proofs::poly::kzg::{
+        commitment::KZGCommitmentScheme,
+        multiopen::{ProverSHPLONK, VerifierSHPLONK},
+        strategy::SingleStrategy,
+    };
+    use snark_verifier::system::halo2::transcript::evm::EvmTranscript;

    use super::*;

@@ -444,41 +447,33 @@ mod matmul_col_ultra_overflow {

        let pk = crate::pfsys::create_keys::<
            halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme<halo2curves::bn256::Bn256>,
-            F,
            MatmulCircuit<F>,
        >(&circuit, &params, true)
        .unwrap();

-        let prover = crate::pfsys::create_proof_circuit_kzg(
+        let prover = crate::pfsys::create_proof_circuit::<
+            KZGCommitmentScheme<_>,
+            _,
+            ProverSHPLONK<_>,
+            VerifierSHPLONK<_>,
+            SingleStrategy<_>,
+            _,
+            EvmTranscript<_, _, _, _>,
+            EvmTranscript<_, _, _, _>,
+        >(
            circuit.clone(),
+            vec![],
            &params,
-            None,
            &pk,
-            crate::pfsys::TranscriptType::EVM,
-            halo2_proofs::poly::kzg::strategy::SingleStrategy::new(&params),
            // use safe mode to verify that the proof is correct
            CheckMode::SAFE,
+            crate::Commitments::KZG,
+            crate::pfsys::TranscriptType::EVM,
+            None,
            None,
        );

        assert!(prover.is_ok());
-
-        let proof = prover.unwrap();
-
-        let strategy =
-            halo2_proofs::poly::kzg::strategy::SingleStrategy::new(params.verifier_params());
-        let vk = pk.get_vk();
-        let result = crate::pfsys::verify_proof_circuit_kzg(
-            params.verifier_params(),
-            proof,
-            vk,
-            strategy,
-            params.n(),
-        );
-
-        assert!(result.is_ok());
-
-        println!("done.");
    }
 }

@@ -1150,7 +1145,15 @@ mod conv {
 #[cfg(test)]
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 mod conv_col_ultra_overflow {
-    use halo2_proofs::poly::commitment::{Params, ParamsProver};
+
+    use halo2_proofs::poly::{
+        kzg::strategy::SingleStrategy,
+        kzg::{
+            commitment::KZGCommitmentScheme,
+            multiopen::{ProverSHPLONK, VerifierSHPLONK},
+        },
+    };
+    use snark_verifier::system::halo2::transcript::evm::EvmTranscript;

    use super::*;

@@ -1248,41 +1251,33 @@ mod conv_col_ultra_overflow {

        let pk = crate::pfsys::create_keys::<
            halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme<halo2curves::bn256::Bn256>,
-            F,
            ConvCircuit<F>,
        >(&circuit, &params, true)
        .unwrap();

-        let prover = crate::pfsys::create_proof_circuit_kzg(
+        let prover = crate::pfsys::create_proof_circuit::<
+            KZGCommitmentScheme<_>,
+            _,
+            ProverSHPLONK<_>,
+            VerifierSHPLONK<_>,
+            SingleStrategy<_>,
+            _,
+            EvmTranscript<_, _, _, _>,
+            EvmTranscript<_, _, _, _>,
+        >(
            circuit.clone(),
+            vec![],
            &params,
-            None,
            &pk,
-            crate::pfsys::TranscriptType::EVM,
-            halo2_proofs::poly::kzg::strategy::SingleStrategy::new(&params),
            // use safe mode to verify that the proof is correct
            CheckMode::SAFE,
+            crate::Commitments::KZG,
+            crate::pfsys::TranscriptType::EVM,
+            None,
            None,
        );

        assert!(prover.is_ok());
-
-        let proof = prover.unwrap();
-
-        let strategy =
-            halo2_proofs::poly::kzg::strategy::SingleStrategy::new(params.verifier_params());
-        let vk = pk.get_vk();
-        let result = crate::pfsys::verify_proof_circuit_kzg(
-            params.verifier_params(),
-            proof,
-            vk,
-            strategy,
-            params.n(),
-        );
-
-        assert!(result.is_ok());
-
-        println!("done.");
    }
 }

@@ -1290,7 +1285,13 @@ mod conv_col_ultra_overflow {
 // not wasm 32 unknown
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 mod conv_relu_col_ultra_overflow {
-    use halo2_proofs::poly::commitment::{Params, ParamsProver};
+
+    use halo2_proofs::poly::kzg::{
+        commitment::KZGCommitmentScheme,
+        multiopen::{ProverSHPLONK, VerifierSHPLONK},
+        strategy::SingleStrategy,
+    };
+    use snark_verifier::system::halo2::transcript::evm::EvmTranscript;

    use super::*;

@@ -1403,41 +1404,33 @@ mod conv_relu_col_ultra_overflow {

        let pk = crate::pfsys::create_keys::<
            halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme<halo2curves::bn256::Bn256>,
-            F,
            ConvCircuit<F>,
        >(&circuit, &params, true)
        .unwrap();

-        let prover = crate::pfsys::create_proof_circuit_kzg(
+        let prover = crate::pfsys::create_proof_circuit::<
+            KZGCommitmentScheme<_>,
+            _,
+            ProverSHPLONK<_>,
+            VerifierSHPLONK<_>,
+            SingleStrategy<_>,
+            _,
+            EvmTranscript<_, _, _, _>,
+            EvmTranscript<_, _, _, _>,
+        >(
            circuit.clone(),
+            vec![],
            &params,
-            None,
            &pk,
-            crate::pfsys::TranscriptType::EVM,
-            halo2_proofs::poly::kzg::strategy::SingleStrategy::new(&params),
-            // use safe mode to verify that the proof is correct
            CheckMode::SAFE,
+            crate::Commitments::KZG,
+            crate::pfsys::TranscriptType::EVM,
+            // use safe mode to verify that the proof is correct
+            None,
            None,
        );

        assert!(prover.is_ok());
-
-        let proof = prover.unwrap();
-
-        let strategy =
-            halo2_proofs::poly::kzg::strategy::SingleStrategy::new(params.verifier_params());
-        let vk = pk.get_vk();
-        let result = crate::pfsys::verify_proof_circuit_kzg(
-            params.verifier_params(),
-            proof,
-            vk,
-            strategy,
-            params.n(),
-        );
-
-        assert!(result.is_ok());
-
-        println!("done.");
    }
 }

@@ -1575,6 +1568,280 @@ mod add {
    }
 }

+#[cfg(test)]
+mod dynamic_lookup {
+    use super::*;
+
+    const K: usize = 6;
+    const LEN: usize = 4;
+    const NUM_LOOP: usize = 5;
+
+    #[derive(Clone)]
+    struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
+        tables: [[ValTensor<F>; 2]; NUM_LOOP],
+        lookups: [[ValTensor<F>; 2]; NUM_LOOP],
+        _marker: PhantomData<F>,
+    }
+
+    impl Circuit<F> for MyCircuit<F> {
+        type Config = BaseConfig<F>;
+        type FloorPlanner = SimpleFloorPlanner;
+        type Params = TestParams;
+
+        fn without_witnesses(&self) -> Self {
+            self.clone()
+        }
+
+        fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
+            let a = VarTensor::new_advice(cs, K, 2, LEN);
+            let b = VarTensor::new_advice(cs, K, 2, LEN);
+            let c: VarTensor = VarTensor::new_advice(cs, K, 2, LEN);
+
+            let d = VarTensor::new_advice(cs, K, 1, LEN);
+            let e = VarTensor::new_advice(cs, K, 1, LEN);
+            let f: VarTensor = VarTensor::new_advice(cs, K, 1, LEN);
+
+            let _constant = VarTensor::constant_cols(cs, K, LEN * NUM_LOOP, false);
+
+            let mut config =
+                Self::Config::configure(cs, &[a.clone(), b.clone()], &c, CheckMode::SAFE);
+            config
+                .configure_dynamic_lookup(
+                    cs,
+                    &[a.clone(), b.clone(), c.clone()],
+                    &[d.clone(), e.clone(), f.clone()],
+                )
+                .unwrap();
+            config
+        }
+
+        fn synthesize(
+            &self,
+            config: Self::Config,
+            mut layouter: impl Layouter<F>,
+        ) -> Result<(), Error> {
+            layouter
+                .assign_region(
+                    || "",
+                    |region| {
+                        let mut region = RegionCtx::new(region, 0, 1);
+                        for i in 0..NUM_LOOP {
+                            layouts::dynamic_lookup(
+                                &config,
+                                &mut region,
+                                &self.lookups[i],
+                                &self.tables[i],
+                            )
+                            .map_err(|_| Error::Synthesis)?;
+                        }
+                        assert_eq!(
+                            region.dynamic_lookup_col_coord(),
+                            NUM_LOOP * self.tables[0][0].len()
+                        );
+                        assert_eq!(region.dynamic_lookup_index(), NUM_LOOP);
+
+                        Ok(())
+                    },
+                )
+                .unwrap();
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn dynamiclookupcircuit() {
+        // parameters
+        let tables = (0..NUM_LOOP)
+            .map(|loop_idx| {
+                [
+                    ValTensor::from(Tensor::from(
+                        (0..LEN).map(|i| Value::known(F::from((i * loop_idx) as u64 + 1))),
+                    )),
+                    ValTensor::from(Tensor::from(
+                        (0..LEN).map(|i| Value::known(F::from((loop_idx * i * i) as u64 + 1))),
+                    )),
+                ]
+            })
+            .collect::<Vec<_>>();
+
+        let lookups = (0..NUM_LOOP)
+            .map(|loop_idx| {
+                [
+                    ValTensor::from(Tensor::from(
+                        (0..3).map(|i| Value::known(F::from((i * loop_idx) as u64 + 1))),
+                    )),
+                    ValTensor::from(Tensor::from(
+                        (0..3).map(|i| Value::known(F::from((loop_idx * i * i) as u64 + 1))),
+                    )),
+                ]
+            })
+            .collect::<Vec<_>>();
+
+        let circuit = MyCircuit::<F> {
+            tables: tables.clone().try_into().unwrap(),
+            lookups: lookups.try_into().unwrap(),
+            _marker: PhantomData,
+        };
+
+        let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
+        prover.assert_satisfied();
+
+        let lookups = (0..NUM_LOOP)
+            .map(|loop_idx| {
+                let prev_idx = if loop_idx == 0 {
+                    NUM_LOOP - 1
+                } else {
+                    loop_idx - 1
+                };
+                [
+                    ValTensor::from(Tensor::from(
+                        (0..3).map(|i| Value::known(F::from((i * prev_idx) as u64 + 1))),
+                    )),
+                    ValTensor::from(Tensor::from(
+                        (0..3).map(|i| Value::known(F::from((prev_idx * i * i) as u64 + 1))),
+                    )),
+                ]
+            })
+            .collect::<Vec<_>>();
+
+        let circuit = MyCircuit::<F> {
+            tables: tables.try_into().unwrap(),
+            lookups: lookups.try_into().unwrap(),
+            _marker: PhantomData,
+        };
+
+        let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
+        assert!(prover.verify().is_err());
+    }
+}
+
+#[cfg(test)]
+mod shuffle {
+    use super::*;
+
+    const K: usize = 6;
+    const LEN: usize = 4;
+    const NUM_LOOP: usize = 5;
+
+    #[derive(Clone)]
+    struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
+        inputs: [[ValTensor<F>; 1]; NUM_LOOP],
+        references: [[ValTensor<F>; 1]; NUM_LOOP],
+        _marker: PhantomData<F>,
+    }
+
+    impl Circuit<F> for MyCircuit<F> {
+        type Config = BaseConfig<F>;
+        type FloorPlanner = SimpleFloorPlanner;
+        type Params = TestParams;
+
+        fn without_witnesses(&self) -> Self {
+            self.clone()
+        }
+
+        fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
+            let a = VarTensor::new_advice(cs, K, 2, LEN);
+            let b = VarTensor::new_advice(cs, K, 2, LEN);
+            let c: VarTensor = VarTensor::new_advice(cs, K, 2, LEN);
+
+            let d = VarTensor::new_advice(cs, K, 1, LEN);
+            let e = VarTensor::new_advice(cs, K, 1, LEN);
+
+            let _constant = VarTensor::constant_cols(cs, K, LEN * NUM_LOOP, false);
+
+            let mut config =
+                Self::Config::configure(cs, &[a.clone(), b.clone()], &c, CheckMode::SAFE);
+            config
+                .configure_shuffles(cs, &[a.clone(), b.clone()], &[d.clone(), e.clone()])
+                .unwrap();
+            config
+        }
+
+        fn synthesize(
+            &self,
+            config: Self::Config,
+            mut layouter: impl Layouter<F>,
+        ) -> Result<(), Error> {
+            layouter
+                .assign_region(
+                    || "",
+                    |region| {
+                        let mut region = RegionCtx::new(region, 0, 1);
+                        for i in 0..NUM_LOOP {
+                            layouts::shuffles(
+                                &config,
+                                &mut region,
+                                &self.inputs[i],
+                                &self.references[i],
+                            )
+                            .map_err(|_| Error::Synthesis)?;
+                        }
+                        assert_eq!(
+                            region.shuffle_col_coord(),
+                            NUM_LOOP * self.references[0][0].len()
+                        );
+                        assert_eq!(region.shuffle_index(), NUM_LOOP);
+
+                        Ok(())
+                    },
+                )
+                .unwrap();
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn shufflecircuit() {
+        // parameters
+        let references = (0..NUM_LOOP)
+            .map(|loop_idx| {
+                [ValTensor::from(Tensor::from((0..LEN).map(|i| {
+                    Value::known(F::from((i * loop_idx) as u64 + 1))
+                })))]
+            })
+            .collect::<Vec<_>>();
+
+        let inputs = (0..NUM_LOOP)
+            .map(|loop_idx| {
+                [ValTensor::from(Tensor::from((0..LEN).rev().map(|i| {
+                    Value::known(F::from((i * loop_idx) as u64 + 1))
+                })))]
+            })
+            .collect::<Vec<_>>();
+
+        let circuit = MyCircuit::<F> {
+            references: references.clone().try_into().unwrap(),
+            inputs: inputs.try_into().unwrap(),
+            _marker: PhantomData,
+        };
+
+        let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
+        prover.assert_satisfied();
+
+        let inputs = (0..NUM_LOOP)
+            .map(|loop_idx| {
+                let prev_idx = if loop_idx == 0 {
+                    NUM_LOOP - 1
+                } else {
+                    loop_idx - 1
+                };
+                [ValTensor::from(Tensor::from((0..LEN).rev().map(|i| {
+                    Value::known(F::from((i * prev_idx) as u64 + 1))
+                })))]
+            })
+            .collect::<Vec<_>>();
+
+        let circuit = MyCircuit::<F> {
+            references: references.try_into().unwrap(),
+            inputs: inputs.try_into().unwrap(),
+            _marker: PhantomData,
+        };
+
+        let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
+        assert!(prover.verify().is_err());
+    }
+}
+
 #[cfg(test)]
 mod add_with_overflow {
    use super::*;
@@ -1978,75 +2245,6 @@ mod pow {
    }
 }

-#[cfg(test)]
-mod pack {
-    use super::*;
-
-    const K: usize = 8;
-    const LEN: usize = 4;
-
-    #[derive(Clone)]
-    struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
-        inputs: [ValTensor<F>; 1],
-        _marker: PhantomData<F>,
-    }
-
-    impl Circuit<F> for MyCircuit<F> {
-        type Config = BaseConfig<F>;
-        type FloorPlanner = SimpleFloorPlanner;
-        type Params = TestParams;
-
-        fn without_witnesses(&self) -> Self {
-            self.clone()
-        }
-
-        fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
-            let a = VarTensor::new_advice(cs, K, 1, LEN);
-            let b = VarTensor::new_advice(cs, K, 1, LEN);
-            let output = VarTensor::new_advice(cs, K, 1, LEN);
-
-            Self::Config::configure(cs, &[a, b], &output, CheckMode::SAFE)
-        }
-
-        fn synthesize(
-            &self,
-            mut config: Self::Config,
-            mut layouter: impl Layouter<F>,
-        ) -> Result<(), Error> {
-            layouter
-                .assign_region(
-                    || "",
-                    |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
-                        config
-                            .layout(
-                                &mut region,
-                                &self.inputs.clone(),
-                                Box::new(PolyOp::Pack(2, 1)),
-                            )
-                            .map_err(|_| Error::Synthesis)
-                    },
-                )
-                .unwrap();
-            Ok(())
-        }
-    }
-
-    #[test]
-    fn packcircuit() {
-        // parameters
-        let a = Tensor::from((0..LEN).map(|i| Value::known(F::from(i as u64 + 1))));
-
-        let circuit = MyCircuit::<F> {
-            inputs: [ValTensor::from(a)],
-            _marker: PhantomData,
-        };
-
-        let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied();
-    }
-}
-
 #[cfg(test)]
 mod matmul_relu {
    use super::*;
@@ -2140,148 +2338,6 @@ mod matmul_relu {
    }
 }

-#[cfg(test)]
-mod rangecheckpercent {
-    use crate::circuit::Tolerance;
-    use crate::{circuit, tensor::Tensor};
-    use halo2_proofs::{
-        circuit::{Layouter, SimpleFloorPlanner, Value},
-        dev::MockProver,
-        plonk::{Circuit, ConstraintSystem, Error},
-    };
-
-    const RANGE: f32 = 1.0; // 1 percent error tolerance
-    const K: usize = 18;
-    const LEN: usize = 1;
-    const SCALE: usize = i128::pow(2, 7) as usize;
-
-    use super::*;
-
-    #[derive(Clone)]
-    struct MyCircuit<F: PrimeField + TensorType + PartialOrd> {
-        input: ValTensor<F>,
-        output: ValTensor<F>,
-        _marker: PhantomData<F>,
-    }
-
-    impl Circuit<F> for MyCircuit<F> {
-        type Config = BaseConfig<F>;
-        type FloorPlanner = SimpleFloorPlanner;
-        type Params = TestParams;
-
-        fn without_witnesses(&self) -> Self {
-            self.clone()
-        }
-
-        fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
-            let scale = utils::F32(SCALE as f32);
-            let a = VarTensor::new_advice(cs, K, 1, LEN);
-            let b = VarTensor::new_advice(cs, K, 1, LEN);
-            let output = VarTensor::new_advice(cs, K, 1, LEN);
-            let mut config =
-                Self::Config::configure(cs, &[a.clone(), b.clone()], &output, CheckMode::SAFE);
-            // set up a new GreaterThan and Recip tables
-            let nl = &LookupOp::GreaterThan {
-                a: circuit::utils::F32((RANGE * SCALE.pow(2) as f32) / 100.0),
-            };
-            config
-                .configure_lookup(cs, &b, &output, &a, (-32768, 32768), K, nl)
-                .unwrap();
-
-            config
-                .configure_lookup(
-                    cs,
-                    &b,
-                    &output,
-                    &a,
-                    (-32768, 32768),
-                    K,
-                    &LookupOp::Recip {
-                        input_scale: scale,
-                        output_scale: scale,
-                    },
-                )
-                .unwrap();
-            config
-        }
-
-        fn synthesize(
-            &self,
-            mut config: Self::Config,
-            mut layouter: impl Layouter<F>,
-        ) -> Result<(), Error> {
-            config.layout_tables(&mut layouter).unwrap();
-            layouter
-                .assign_region(
-                    || "",
-                    |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
-                        config
-                            .layout(
-                                &mut region,
-                                &[self.output.clone(), self.input.clone()],
-                                Box::new(HybridOp::RangeCheck(Tolerance {
-                                    val: RANGE,
-                                    scale: SCALE.into(),
-                                })),
-                            )
-                            .map_err(|_| Error::Synthesis)
-                    },
-                )
-                .unwrap();
-            Ok(())
-        }
-    }
-
-    #[test]
-    #[allow(clippy::assertions_on_constants)]
-    fn test_range_check_percent() {
-        // Successful cases
-        {
-            let inp = Tensor::new(Some(&[Value::<F>::known(F::from(100_u64))]), &[1]).unwrap();
-            let out = Tensor::new(Some(&[Value::<F>::known(F::from(101_u64))]), &[1]).unwrap();
-            let circuit = MyCircuit::<F> {
-                input: ValTensor::from(inp),
-                output: ValTensor::from(out),
-                _marker: PhantomData,
-            };
-            let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-            prover.assert_satisfied();
-        }
-        {
-            let inp = Tensor::new(Some(&[Value::<F>::known(F::from(200_u64))]), &[1]).unwrap();
-            let out = Tensor::new(Some(&[Value::<F>::known(F::from(199_u64))]), &[1]).unwrap();
-            let circuit = MyCircuit::<F> {
-                input: ValTensor::from(inp),
-                output: ValTensor::from(out),
-                _marker: PhantomData,
-            };
-            let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-            prover.assert_satisfied();
-        }
-
-        // Unsuccessful case
-        {
-            let inp = Tensor::new(Some(&[Value::<F>::known(F::from(100_u64))]), &[1]).unwrap();
-            let out = Tensor::new(Some(&[Value::<F>::known(F::from(102_u64))]), &[1]).unwrap();
-            let circuit = MyCircuit::<F> {
-                input: ValTensor::from(inp),
-                output: ValTensor::from(out),
-                _marker: PhantomData,
-            };
-            let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-            match prover.verify() {
-                Ok(_) => {
-                    assert!(false)
-                }
-                Err(_) => {
-                    assert!(true)
-                }
-            }
-        }
-    }
-}
-
 #[cfg(test)]
 mod relu {
    use super::*;
@@ -2363,8 +2419,13 @@ mod lookup_ultra_overflow {
    use halo2_proofs::{
        circuit::{Layouter, SimpleFloorPlanner, Value},
        plonk::{Circuit, ConstraintSystem, Error},
-        poly::commitment::{Params, ParamsProver},
+        poly::kzg::{
+            commitment::KZGCommitmentScheme,
+            multiopen::{ProverSHPLONK, VerifierSHPLONK},
+            strategy::SingleStrategy,
+        },
    };
+    use snark_verifier::system::halo2::transcript::evm::EvmTranscript;

    #[derive(Clone)]
    struct ReLUCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -2443,150 +2504,32 @@ mod lookup_ultra_overflow {

        let pk = crate::pfsys::create_keys::<
            halo2_proofs::poly::kzg::commitment::KZGCommitmentScheme<halo2curves::bn256::Bn256>,
-            F,
            ReLUCircuit<F>,
        >(&circuit, &params, true)
        .unwrap();

-        let prover = crate::pfsys::create_proof_circuit_kzg(
+        let prover = crate::pfsys::create_proof_circuit::<
+            KZGCommitmentScheme<_>,
+            _,
+            ProverSHPLONK<_>,
+            VerifierSHPLONK<_>,
+            SingleStrategy<_>,
+            _,
+            EvmTranscript<_, _, _, _>,
+            EvmTranscript<_, _, _, _>,
+        >(
            circuit.clone(),
+            vec![],
            &params,
-            None,
            &pk,
-            crate::pfsys::TranscriptType::EVM,
-            halo2_proofs::poly::kzg::strategy::SingleStrategy::new(&params),
            // use safe mode to verify that the proof is correct
            CheckMode::SAFE,
+            crate::Commitments::KZG,
+            crate::pfsys::TranscriptType::EVM,
+            None,
            None,
        );

        assert!(prover.is_ok());
-
-        let proof = prover.unwrap();
-
-        let strategy =
-            halo2_proofs::poly::kzg::strategy::SingleStrategy::new(params.verifier_params());
-        let vk = pk.get_vk();
-        let result = crate::pfsys::verify_proof_circuit_kzg(
-            params.verifier_params(),
-            proof,
-            vk,
-            strategy,
-            params.n(),
-        );
-
-        assert!(result.is_ok());
-
-        println!("done.");
-    }
-}
-
-#[cfg(test)]
-mod softmax {
-
-    use super::*;
-    use halo2_proofs::{
-        circuit::{Layouter, SimpleFloorPlanner, Value},
-        dev::MockProver,
-        plonk::{Circuit, ConstraintSystem, Error},
-    };
-
-    const K: usize = 18;
-    const LEN: usize = 3;
-    const SCALE: f32 = 128.0;
-
-    #[derive(Clone)]
-    struct SoftmaxCircuit<F: PrimeField + TensorType + PartialOrd> {
-        pub input: ValTensor<F>,
-        _marker: PhantomData<F>,
-    }
-
-    impl Circuit<F> for SoftmaxCircuit<F> {
-        type Config = BaseConfig<F>;
-        type FloorPlanner = SimpleFloorPlanner;
-        type Params = TestParams;
-
-        fn without_witnesses(&self) -> Self {
-            self.clone()
-        }
-        fn configure(cs: &mut ConstraintSystem<F>) -> Self::Config {
-            let a = VarTensor::new_advice(cs, K, 1, LEN);
-            let b = VarTensor::new_advice(cs, K, 1, LEN);
-            let output = VarTensor::new_advice(cs, K, 1, LEN);
-            let mut config = Self::Config::configure(cs, &[a, b], &output, CheckMode::SAFE);
-            let advices = (0..3)
-                .map(|_| VarTensor::new_advice(cs, K, 1, LEN))
-                .collect::<Vec<_>>();
-
-            config
-                .configure_lookup(
-                    cs,
-                    &advices[0],
-                    &advices[1],
-                    &advices[2],
-                    (-32768, 32768),
-                    K,
-                    &LookupOp::Exp {
-                        scale: SCALE.into(),
-                    },
-                )
-                .unwrap();
-            config
-                .configure_lookup(
-                    cs,
-                    &advices[0],
-                    &advices[1],
-                    &advices[2],
-                    (-32768, 32768),
-                    K,
-                    &LookupOp::Recip {
-                        input_scale: SCALE.into(),
-                        output_scale: SCALE.into(),
-                    },
-                )
-                .unwrap();
-            config
-        }
-
-        fn synthesize(
-            &self,
-            mut config: Self::Config,
-            mut layouter: impl Layouter<F>,
-        ) -> Result<(), Error> {
-            config.layout_tables(&mut layouter).unwrap();
-            layouter
-                .assign_region(
-                    || "",
-                    |region| {
-                        let mut region = RegionCtx::new(region, 0, 1);
-                        let _output = config
-                            .layout(
-                                &mut region,
-                                &[self.input.clone()],
-                                Box::new(HybridOp::Softmax {
-                                    scale: SCALE.into(),
-                                    axes: vec![0],
-                                }),
-                            )
-                            .unwrap();
-                        Ok(())
-                    },
-                )
-                .unwrap();
-
-            Ok(())
-        }
-    }
-
-    #[test]
-    fn softmax_circuit() {
-        let input = Tensor::from((0..LEN).map(|i| Value::known(F::from(i as u64 + 1))));
-
-        let circuit = SoftmaxCircuit::<F> {
-            input: ValTensor::from(input),
-            _marker: PhantomData,
-        };
-        let prover = MockProver::run(K as u32, &circuit, vec![]).unwrap();
-        prover.assert_satisfied();
    }
 }
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -13,7 +13,7 @@ use std::path::PathBuf;
 use std::{error::Error, str::FromStr};
 use tosubcommand::{ToFlags, ToSubcommand};

-use crate::{pfsys::ProofType, RunArgs};
+use crate::{pfsys::ProofType, Commitments, RunArgs};

 use crate::circuit::CheckMode;
 #[cfg(not(target_arch = "wasm32"))]
@@ -77,7 +77,7 @@ pub const DEFAULT_CALIBRATION_FILE: &str = "calibration.json";
 /// Default lookup safety margin
 pub const DEFAULT_LOOKUP_SAFETY_MARGIN: &str = "2";
 /// Default Compress selectors
-pub const DEFAULT_COMPRESS_SELECTORS: &str = "false";
+pub const DEFAULT_DISABLE_SELECTOR_COMPRESSION: &str = "false";
 /// Default render vk seperately
 pub const DEFAULT_RENDER_VK_SEPERATELY: &str = "false";
 /// Default VK sol path
@@ -90,6 +90,8 @@ pub const DEFAULT_SCALE_REBASE_MULTIPLIERS: &str = "1,2,10";
 pub const DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION: &str = "false";
 /// Default only check for range check rebase
 pub const DEFAULT_ONLY_RANGE_CHECK_REBASE: &str = "false";
+/// Default commitment
+pub const DEFAULT_COMMITMENT: &str = "kzg";

 #[cfg(feature = "python-bindings")]
 /// Converts TranscriptType into a PyObject (Required for TranscriptType to be compatible with Python)
@@ -294,21 +296,6 @@ pub enum Commands {
        args: RunArgs,
    },

-    #[cfg(feature = "render")]
-    /// Renders the model circuit to a .png file. For an overview of how to interpret these plots, see https://zcash.github.io/halo2/user/dev-tools.html
-    #[command(arg_required_else_help = true)]
-    RenderCircuit {
-        /// The path to the .onnx model file
-        #[arg(short = 'M', long)]
-        model: PathBuf,
-        /// Path to save the .png circuit render
-        #[arg(short = 'O', long)]
-        output: PathBuf,
-        /// proving arguments
-        #[clap(flatten)]
-        args: RunArgs,
-    },
-
    /// Generates the witness from an input file.
    GenWitness {
        /// The path to the .json data file
@@ -387,6 +374,9 @@ pub enum Commands {
        /// number of logrows to use for srs
        #[arg(long)]
        logrows: usize,
+        /// commitment used
+        #[arg(long, default_value = DEFAULT_COMMITMENT)]
+        commitment: Commitments,
    },

    #[cfg(not(target_arch = "wasm32"))]
@@ -402,9 +392,9 @@ pub enum Commands {
        /// Number of logrows to use for srs. Overrides settings_path if specified.
        #[arg(long, default_value = None)]
        logrows: Option<u32>,
-        /// Check mode for SRS. Verifies downloaded srs is valid. Set to unsafe for speed.
-        #[arg(long, default_value = DEFAULT_CHECKMODE)]
-        check: CheckMode,
+        /// Commitment used
+        #[arg(long, default_value = None)]
+        commitment: Option<Commitments>,
    },
    /// Loads model and input and runs mock prover (for testing)
    Mock {
@@ -450,8 +440,11 @@ pub enum Commands {
        #[arg(long, default_value = DEFAULT_SPLIT)]
        split_proofs: bool,
        /// compress selectors
-        #[arg(long, default_value = DEFAULT_COMPRESS_SELECTORS)]
-        compress_selectors: bool,
+        #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION)]
+        disable_selector_compression: bool,
+        /// commitment used
+        #[arg(long, default_value = DEFAULT_COMMITMENT)]
+        commitment: Commitments,
    },
    /// Aggregates proofs :)
    Aggregate {
@@ -471,7 +464,7 @@ pub enum Commands {
            long,
            require_equals = true,
            num_args = 0..=1,
-            default_value_t = TranscriptType::EVM,
+            default_value_t = TranscriptType::default(),
            value_enum
        )]
        transcript: TranscriptType,
@@ -484,6 +477,9 @@ pub enum Commands {
        /// whether the accumulated proofs are segments of a larger circuit
        #[arg(long, default_value = DEFAULT_SPLIT)]
        split_proofs: bool,
+        /// commitment used
+        #[arg(long, default_value = DEFAULT_COMMITMENT)]
+        commitment: Commitments,
    },
    /// Compiles a circuit from onnx to a simplified graph (einsum + other ops) and parameters as sets of field elements
    CompileCircuit {
@@ -515,33 +511,8 @@ pub enum Commands {
        #[arg(short = 'W', long)]
        witness: Option<PathBuf>,
        /// compress selectors
-        #[arg(long, default_value = DEFAULT_COMPRESS_SELECTORS)]
-        compress_selectors: bool,
-    },
-
-    #[cfg(not(target_arch = "wasm32"))]
-    /// Fuzzes the proof pipeline with random inputs, random parameters, and random keys
-    Fuzz {
-        /// The path to the .json witness file (generated using the gen-witness command)
-        #[arg(short = 'W', long, default_value = DEFAULT_WITNESS)]
-        witness: PathBuf,
-        /// The path to the compiled model file (generated using the compile-circuit command)
-        #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT)]
-        compiled_circuit: PathBuf,
-        #[arg(
-            long,
-            require_equals = true,
-            num_args = 0..=1,
-            default_value_t = TranscriptType::EVM,
-            value_enum
-        )]
-        transcript: TranscriptType,
-        /// number of fuzz iterations
-        #[arg(long, default_value = DEFAULT_FUZZ_RUNS)]
-        num_runs: usize,
-        /// compress selectors
-        #[arg(long, default_value = DEFAULT_COMPRESS_SELECTORS)]
-        compress_selectors: bool,
+        #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION)]
+        disable_selector_compression: bool,
    },
    #[cfg(not(target_arch = "wasm32"))]
    /// Deploys a test contact that the data attester reads from and creates a data attestation formatted input.json file that contains call data information
@@ -744,12 +715,18 @@ pub enum Commands {
        /// The path to the verification key file (generated using the setup-aggregate command)
        #[arg(long, default_value = DEFAULT_VK_AGGREGATED)]
        vk_path: PathBuf,
+        /// reduced srs
+        #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION)]
+        reduced_srs: bool,
        /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
        #[arg(long)]
        srs_path: Option<PathBuf>,
        /// logrows used for aggregation circuit
        #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
        logrows: u32,
+        /// commitment
+        #[arg(long, default_value = DEFAULT_COMMITMENT)]
+        commitment: Commitments,
    },
    #[cfg(not(target_arch = "wasm32"))]
    /// Deploys an evm verifier that is generated by ezkl
--- a/src/execute.rs
+++ b/src/execute.rs
--- a/src/graph/input.rs
+++ b/src/graph/input.rs
@@ -624,13 +624,13 @@ impl ToPyObject for DataSource {
 }

 #[cfg(feature = "python-bindings")]
-use crate::pfsys::field_to_string_montgomery;
+use crate::pfsys::field_to_string;

 #[cfg(feature = "python-bindings")]
 impl ToPyObject for FileSourceInner {
    fn to_object(&self, py: Python) -> PyObject {
        match self {
-            FileSourceInner::Field(data) => field_to_string_montgomery(data).to_object(py),
+            FileSourceInner::Field(data) => field_to_string(data).to_object(py),
            FileSourceInner::Bool(data) => data.to_object(py),
            FileSourceInner::Float(data) => data.to_object(py),
        }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Sung Jun Eun	feb3b1b475	fix: array element encapsulation in ezkl_demo.ipynb (#747 )	2024-03-21 08:51:01 +00:00
dante	e134d86756	refactor: apply num-inner cols to constant assignments as well (#749 )	2024-03-20 23:51:38 +00:00
dante	6819a3acf6	chore: more complete coverage tests (#748 )	2024-03-20 18:53:47 +00:00
dante	2ccf056661	fix: logrows reset after graph creation can cause extended K overflow (#745 )	2024-03-20 10:15:11 +00:00
dante	a5bf64b1a2	feat!: ipa commitments (#740 ) BREAKING CHANGE: commitment is now an added flag	2024-03-16 16:31:01 +00:00
Ethan Cemer	56e2326be1	*nuke (#742 )	2024-03-14 14:11:03 -05:00
Ethan Cemer	2be181db35	feat: merge `@ezkljs/verify` package into core repo. (#736 )	2024-03-14 01:13:14 +00:00
jmjac	de9e3f2673	Add __version__ to python bindings (#739 )	2024-03-13 14:22:20 +00:00
dante	a1450f8df7	feat: `gather_nd`/`scatter_nd` support (#737 )	2024-03-11 22:05:40 +00:00
dante	ea535e2ecd	refactor: use linear index constraints for gather and scatter (#735 )	2024-03-09 18:00:21 +00:00
Alexander Camuto	f8aa91ed08	fix: windows compile	2024-03-06 11:40:44 +00:00
dante	a59e3780b2	chore: rm recip_int helper (#733 )	2024-03-05 21:51:14 +00:00
dante	345fb5672a	chore: cleanup unused args (#732 )	2024-03-05 13:43:29 +00:00
dante	70daaff2e4	chore: cleanup calibrate (#731 )	2024-03-04 17:52:11 +00:00
dante	a437d8a51f	feat: "sub"-dynamic tables (#730 )	2024-03-04 10:35:28 +00:00
Ethan Cemer	fe535c1cac	feat: wasm felt to little endian string (#729 ) --------- Co-authored-by: Alexander Camuto <45801863+alexander-camuto@users.noreply.github.com>	2024-03-01 14:06:20 +00:00
dante	3e8dcb001a	chore: test for reduced-srs on wasm bundle (#728 ) --------- Co-authored-by: Ethan <tylercemer@gmail.com>	2024-03-01 13:23:07 +00:00
dante	14786acb95	feat: dynamic lookups (#727 )	2024-03-01 01:44:45 +00:00
dante	80a3c44cb4	feat: lookup-less recip by default (#725 )	2024-02-28 16:35:20 +00:00
dante	1656846d1a	fix: transcript should serialize as lc flag (#726 )	2024-02-26 22:02:47 +00:00
dante	88098b8190	fix!: cleanup felt serialization language in python and wasm (#724 ) BREAKING CHANGE: python and wasm felt utilities have new names	2024-02-25 14:06:48 +00:00
				`@@ -0,0 +1 @@`
				`{"input_data": [[0.7549541592597961, 0.990360677242279, 0.9473411440849304, 0.3951031565666199, 0.8500555753707886, 0.9352139830589294, 0.11867779493331909, 0.9493132829666138, 0.6588345766067505, 0.1933223009109497, 0.12139874696731567, 0.8547163605690002]]}`
				`@@ -0,0 +1 @@`
				`{"input_data": [[0.35387128591537476, 0.030473172664642334, 0.08707714080810547, 0.2429301142692566, 0.45228832960128784, 0.496021032333374, 0.13245105743408203, 0.8497090339660645]]}`
				`@@ -0,0 +1 @@`
				{"input_data": [[0.03297048807144165, 0.46362626552581787, 0.6044231057167053, 0.4949902892112732, 0.48823297023773193, 0.6798646450042725, 0.6824942231178284, 0.03491640090942383, 0.19608813524246216, 0.24129939079284668, 0.9769315123558044, 0.6306831240653992, 0.7690497636795044, 0.252221941947937, 0.9167693853378296, 0.3882681131362915, 0.9307044148445129, 0.33559417724609375, 0.7815426588058472, 0.3435332179069519, 0.7871478796005249, 0.12240773439407349, 0.5295405983924866, 0.4874419569969177, 0.08262640237808228, 0.1124718189239502, 0.5834914445877075, 0.30927878618240356, 0.48899340629577637, 0.9376634955406189, 0.21893149614334106, 0.526070773601532]]}
				`@@ -0,0 +1 @@`
				`{"input_data": [[0.4145222008228302, -0.4043896496295929, 0.7545749545097351]]}`
				`@@ -0,0 +1 @@`
				`{"input_data": [[0.5505883693695068, 0.0766521692276001, 0.12006187438964844, 0.9497959017753601, 0.9100563526153564, 0.968717098236084, 0.5978299379348755, 0.9419963359832764]]}`
				`@@ -0,0 +1 @@`
				`{"input_data": [[0.6996762752532959, 0.42992985248565674, 0.5102168321609497, 0.5540387630462646, 0.8489438891410828, 0.8533616065979004, 0.36736780405044556, 0.5859147310256958]]}`
				`@@ -0,0 +1 @@`
				{"input_data": [[0.7973018884658813, 0.5245689153671265, 0.34149593114852905, 0.1455438733100891, 0.9482707381248474, 0.4221445322036743, 0.001363217830657959, 0.8736765384674072, 0.42954301834106445, 0.7199509739875793, 0.37641745805740356, 0.5920265316963196, 0.42270803451538086, 0.41761744022369385, 0.603948712348938, 0.7250819802284241, 0.047173500061035156, 0.5115441679954529, 0.3743387460708618, 0.16794061660766602, 0.5352339148521423, 0.037976861000061035, 0.65323406457901, 0.5585184097290039, 0.10559147596359253, 0.07827490568161011, 0.6717077493667603, 0.6480781435966492, 0.9780838489532471, 0.8353415131568909, 0.6491701006889343, 0.6573048233985901]]}
				`@@ -0,0 +1 @@`
				`{"input_data": [[0.18563222885131836, 0.4843214750289917, 0.9991059899330139, 0.02534431219100952, 0.8105666041374207, 0.9658406376838684, 0.681107759475708, 0.5365872979164124]]}`
				`@@ -0,0 +1 @@`
				{"input_data": [[0.02284395694732666, 0.7941043376922607, 0.07971876859664917, 0.8898420929908752, 0.8233054280281067, 0.11066079139709473, 0.4424799084663391, 0.4355071783065796, 0.6723723411560059, 0.6818525195121765, 0.8726171851158142, 0.17742449045181274, 0.054257750511169434, 0.5775953531265259, 0.7758923172950745, 0.8431423306465149, 0.7602444887161255, 0.29686522483825684, 0.22489851713180542, 0.0675363540649414, 0.981339693069458, 0.15771394968032837, 0.5801441669464111, 0.9044001698493958, 0.49266451597213745, 0.42621421813964844, 0.35345613956451416, 0.042848050594329834, 0.6908614039421082, 0.5422852039337158, 0.01975083351135254, 0.5772860050201416]]}